Complete TELA API Guide

// Basic XSWD connection setup
const applicationData = {
    "id": "your-unique-app-id",
    "name": "Your TELA Application", 
    "description": "Description of your app",
    "url": "http://localhost:" + location.port
};
 
const socket = new WebSocket("ws://127.0.0.1:44326/xswd");
 
socket.addEventListener("open", function(event) {
    // Send handshake
    socket.send(JSON.stringify(applicationData));
});
 
socket.addEventListener("message", function(event) {
    const response = JSON.parse(event.data);
    // Handle responses
});

{
    "jsonrpc": "2.0",
    "id": "unique-request-id",
    "method": "METHOD_NAME", 
    "params": { /* parameters */ }
}

{
    "height": 12345,
    "topoheight": 12345,
    "difficulty": 1000000000,
    "hashrate": 62500000,
    "version": "5.2.0",
    "peer_count": 8,
    "tx_pool_size": 2,
    "total_supply": 18400000000000,
    "network_active_miners": 150,
    "target": 18,
    "uptime": 3600,
    "testnet": false,
    "top_block_hash": "abc123...",
    "treehash": "def456...",
    "stableheight": 12340
}

const networkInfo = await xswd.call('DERO.GetInfo');
console.log('Current height:', networkInfo.height);
console.log('Network hashrate:', networkInfo.hashrate);
 
// Format for display
const hashrateMH = (networkInfo.hashrate / 1000000).toFixed(2) + ' MH/s';
const supply = (networkInfo.total_supply / 100000).toFixed(2) + ' DERO';

{
    "height": 12345,
    "stableheight": 12340,
    "topoheight": 12345
}

{
    "block_header": {
        "depth": 0,
        "difficulty": 1000000,
        "hash": "abc123...",
        "height": 12345,
        "timestamp": 1640995200,
        "reward": 30000000000,
        "orphan_status": false,
        "txcount": 5
    },
    "tx_hashes": ["tx1hash", "tx2hash", "tx3hash"]
}

// Get by height (most common)
const block = await xswd.call('DERO.GetBlock', {height: 12345});
 
// Get by hash (when you have the hash)
const block = await xswd.call('DERO.GetBlock', {hash: 'abc123...'});
 
// Process transaction hashes
if (block.tx_hashes && block.tx_hashes.length > 0) {
    console.log(`Block ${block.block_header.height} has ${block.tx_hashes.length} transactions`);
}

// Perfect for live monitoring
const latest = await xswd.call('DERO.GetLastBlockHeader');
const header = latest.block_header;
 
// Update dashboard
document.getElementById('current-height').textContent = header.height;
document.getElementById('current-difficulty').textContent = header.difficulty;
 
// Calculate time since last block
const timeSince = Date.now() - (header.timestamp * 1000);
const secondsAgo = Math.floor(timeSince / 1000);
document.getElementById('last-block-time').textContent = secondsAgo + 's ago';

{
    "txs": [{
        "txid": "abc123...",
        "block_height": 12345,
        "timestamp": 1640995200,
        "fee": 50000,
        "size": 1024,
        "in_pool": false,
        "as_hex": "hexdata..."
    }]
}

// Single transaction
const tx = await xswd.call('DERO.GetTransaction', {
    txs_hashes: ['abc123...']
});
 
// Multiple transactions (use sparingly!)
const txs = await xswd.call('DERO.GetTransaction', {
    txs_hashes: ['hash1', 'hash2', 'hash3']
});
 
// Process results
if (tx.txs && tx.txs.length > 0) {
    const transaction = tx.txs[0];
    console.log('Fee:', transaction.fee);
    console.log('Size:', transaction.size, 'bytes');
    
    // Format fee for display
    const feeDERO = (transaction.fee / 100000).toFixed(5) + ' DERO';
}

{
    "txs": [
        {
            "as_hex": "0100000...",
            "fee": 50000,
            "size": 1024
        }
    ]
}

const pool = await xswd.call('DERO.GetTxPool');
 
// Display pool activity
if (pool.txs && pool.txs.length > 0) {
    console.log(`${pool.txs.length} transactions in mempool`);
    
    // Extract transaction hashes for display
    const recentHashes = pool.txs.slice(0, 5).map(tx => {
        if (tx.as_hex) {
            return tx.as_hex.substring(0, 8) + '...';
        }
        return 'Unknown';
    });
    
    console.log('Recent transactions:', recentHashes);
}

{
    "code": "Function Initialize() Uint64\n10 RETURN 0\nEnd Function",
    "balance": 1000000000,
    "variables": {
        "var1": "value1",
        "var2": 12345
    }
}

// Get contract overview (lightweight)
const contract = await xswd.call('DERO.GetSC', {
    scid: 'contract_id_here',
    code: false,
    variables: false
});
 
// Get full contract details (heavy)
const fullContract = await xswd.call('DERO.GetSC', {
    scid: 'contract_id_here',
    code: true,
    variables: true
});
 
// Display contract balance
const balanceDERO = (contract.balance / 100000).toFixed(5) + ' DERO';
console.log('Contract balance:', balanceDERO);

{
    "address": "dero1...",
    "status": "OK"
}

{
    "address": "dero1abc123..."
}

{
    "balance": 1000000000000,
    "unlocked_balance": 800000000000
}

// Get DERO balance
const balance = await xswd.call('GetBalance');
const deroBal = (balance.unlocked_balance / 100000).toFixed(5) + ' DERO';
 
// Get specific asset balance
const assetBalance = await xswd.call('GetBalance', {scid: 'asset_id'});

{
    "txid": "abc123...",
    "fee": 50000
}

const transfer = await xswd.call('Transfer', {
    destinations: [{
        address: 'dero1...',
        amount: 1000000000000  // 10,000 DERO in atomic units
    }],
    ringsize: 8  // Good privacy/cost balance
});
 
console.log('Transaction sent:', transfer.txid);
console.log('Fee paid:', (transfer.fee / 100000).toFixed(5) + ' DERO');

{
    "lastIndexHeight": 12345
}

{
    "count": 1500
}

{
    "owner": "dero1abc123..."
}

{
    "contracts": {
        "scid1": "owner1",
        "scid2": "owner2"
    }
}

{
    "variables": [
        {
            "key": "var1",
            "value": "value1", 
            "height": 12345
        }
    ]
}

{
    "epochHashes": 1000,
    "epochDuration": 5000,  // Duration in milliseconds
    "epochSubmitted": 5     // Number of successful submissions
}

// Basic mining operation
const result = await xswd.call('AttemptEPOCH', { hashes: 1000 });
 
console.log(`⛏️ Mining completed:`);
console.log(`   Hashes: ${result.epochHashes}`);
console.log(`   Duration: ${result.epochDuration}ms`);
console.log(`   Submitted: ${result.epochSubmitted}`);
 
// Calculate hash rate
const hashRate = (result.epochHashes / result.epochDuration) * 1000;
console.log(`   Hash Rate: ${hashRate.toFixed(2)} H/s`);

{
    "maxHashes": 10000
}

{
    "epochAddress": "dero1abc123..."
}

{
    "sessionHashes": 15000,
    "sessionMinis": 25
}

// Monitor mining session
const session = await xswd.call('GetSessionEPOCH');
 
console.log(`📊 Current Mining Session:`);
console.log(`   Total Hashes: ${session.sessionHashes.toLocaleString()}`);
console.log(`   Miniblocks Found: ${session.sessionMinis}`);
 
// Calculate efficiency
if (session.sessionHashes > 0) {
    const efficiency = (session.sessionMinis / session.sessionHashes * 100).toFixed(6);
    console.log(`   Efficiency: ${efficiency}%`);
}

{
    "telaLinkResult": "opened_successfully"
}

// Open a TELA application
const result = await xswd.call('HandleTELALinks', {
    telaLink: 'tela://app-name'
});
 
if (result.telaLinkResult === 'opened_successfully') {
    console.log('TELA app opened successfully');
}

// Error handling wrapper for all API calls
async function safeCall(method, params = {}, retries = 3) {
    for (let i = 0; i < retries; i++) {
        try {
            return await xswd.call(method, params);
        } catch (error) {
            console.warn(`Attempt ${i + 1} failed:`, error.message);
            
            if (i === retries - 1) {
                throw error;
            }
            
            // Wait before retry
            await new Promise(resolve => setTimeout(resolve, 1000));
        }
    }
}
 
// Connection monitoring
function monitorConnection() {
    if (!xswd || !xswd.isConnected) {
        console.warn('XSWD connection lost');
        // Handle disconnection
        showConnectionError();
        return false;
    }
    return true;
}
 
// User-friendly error messages
function handleUserError(error) {
    const userMessages = {
        'Wallet locked': 'Please unlock your DERO wallet to continue.',
        'Insufficient balance': 'Insufficient funds for this transaction.',
        'Network error': 'Connection to DERO network failed. Please try again.',
        'Request timeout': 'Request timed out. Please check your connection.'
    };
    
    const userMessage = userMessages[error.message] || 
                       'An unexpected error occurred. Please try again.';
    
    // Display to user
    showError(userMessage);
}

// Rate limiting for XSWD calls
let lastCallTime = 0;
const MIN_CALL_INTERVAL = 500; // 500ms between calls
 
async function rateLimitedCall(method, params) {
    const now = Date.now();
    const timeSinceLastCall = now - lastCallTime;
    
    if (timeSinceLastCall < MIN_CALL_INTERVAL) {
        await new Promise(resolve => 
            setTimeout(resolve, MIN_CALL_INTERVAL - timeSinceLastCall)
        );
    }
    
    lastCallTime = Date.now();
    return xswd.call(method, params);
}
 
// Data caching system
const cache = new Map();
const CACHE_TTL = 15000; // 15 seconds
 
function getCachedData(key, fetchFunction) {
    const cached = cache.get(key);
    
    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
        return Promise.resolve(cached.data);
    }
    
    return fetchFunction().then(data => {
        cache.set(key, {
            data: data,
            timestamp: Date.now()
        });
        return data;
    });
}
 
// Usage
const networkInfo = await getCachedData('network-info', () => 
    xswd.call('DERO.GetInfo')
);

({
    name: 'tela-complete-example',
    version: '1.0.0',
    
    // Initialize application
    init: function() {
        var self = this;
        console.log('🚀 Initializing TELA application...');
        
        // Check XSWD connection
        if (!window.xswd || !window.xswd.isConnected) {
            console.error('XSWD not connected');
            return false;
        }
        
        // Load initial data
        self.loadDashboardData();
        
        // Set up periodic updates
        setInterval(function() {
            self.updateLiveData();
        }, 18000); // Every 18 seconds
        
        return true;
    },
    
    // Load dashboard data
    loadDashboardData: function() {
        var self = this;
        
        // Get network info
        window.xswd.call('DERO.GetInfo').then(function(info) {
            self.displayNetworkInfo(info);
        }).catch(function(error) {
            console.error('Failed to load network info:', error);
        });
        
        // Get wallet info
        window.xswd.call('GetAddress').then(function(addr) {
            return window.xswd.call('GetBalance').then(function(bal) {
                self.displayWalletInfo(addr.address, bal);
            });
        }).catch(function(error) {
            console.error('Failed to load wallet info:', error);
        });
        
        // Get transaction pool
        window.xswd.call('DERO.GetTxPool').then(function(pool) {
            self.displayPoolInfo(pool);
        }).catch(function(error) {
            console.error('Failed to load pool info:', error);
        });
    },
    
    // Display network information
    displayNetworkInfo: function(info) {
        var html = '<div class="network-info">';
        html += '<h3>Network Status</h3>';
        html += '<p>Height: ' + info.height.toLocaleString() + '</p>';
        html += '<p>Difficulty: ' + info.difficulty.toLocaleString() + '</p>';
        html += '<p>Hash Rate: ' + (info.hashrate / 1000000).toFixed(2) + ' MH/s</p>';
        html += '<p>Peers: ' + info.peer_count + '</p>';
        html += '</div>';
        
        var container = document.getElementById('network-container');
        if (container) container.innerHTML = html;
    },
    
    // Display wallet information
    displayWalletInfo: function(address, balance) {
        var html = '<div class="wallet-info">';
        html += '<h3>Wallet Status</h3>';
        html += '<p>Address: ' + address.substring(0, 20) + '...</p>';
        html += '<p>Balance: ' + (balance.unlocked_balance / 100000).toFixed(5) + ' DERO</p>';
        html += '</div>';
        
        var container = document.getElementById('wallet-container');
        if (container) container.innerHTML = html;
    },
    
    // Display transaction pool
    displayPoolInfo: function(pool) {
        var html = '<div class="pool-info">';
        html += '<h3>Transaction Pool</h3>';
        html += '<p>Pending Transactions: ' + (pool.txs ? pool.txs.length : 0) + '</p>';
        
        if (pool.txs && pool.txs.length > 0) {
            html += '<h4>Recent Transactions:</h4>';
            html += '<ul>';
            for (var i = 0; i < Math.min(5, pool.txs.length); i++) {
                var tx = pool.txs[i];
                var hash = tx.as_hex ? tx.as_hex.substring(0, 8) + '...' : 'Unknown';
                html += '<li>' + hash + '</li>';
            }
            html += '</ul>';
        }
        
        html += '</div>';
        
        var container = document.getElementById('pool-container');
        if (container) container.innerHTML = html;
    },
    
    // Update live data
    updateLiveData: function() {
        var self = this;
        
        // Update network info only
        window.xswd.call('DERO.GetInfo').then(function(info) {
            // Update height display
            var heightEl = document.getElementById('current-height');
            if (heightEl) {
                heightEl.textContent = info.height.toLocaleString();
            }
            
            // Update difficulty
            var diffEl = document.getElementById('current-difficulty');
            if (diffEl) {
                diffEl.textContent = info.difficulty.toLocaleString();
            }
        }).catch(function(error) {
            console.warn('Live update failed:', error);
        });
    },
    
    // Mine some blocks (example)
    startMining: function(hashCount) {
        var self = this;
        hashCount = hashCount || 1000;
        
        console.log('🔨 Starting mining with ' + hashCount + ' hashes...');
        
        return window.xswd.call('AttemptEPOCH', { hashes: hashCount })
            .then(function(result) {
                console.log('⛏️ Mining completed:');
                console.log('   Hashes: ' + result.epochHashes);
                console.log('   Duration: ' + result.epochDuration + 'ms');
                console.log('   Submitted: ' + result.epochSubmitted);
                
                // Calculate and display hash rate
                var hashRate = (result.epochHashes / result.epochDuration) * 1000;
                console.log('   Hash Rate: ' + hashRate.toFixed(2) + ' H/s');
                
                return result;
            })
            .catch(function(error) {
                console.error('❌ Mining failed:', error);
                return null;
            });
    },
    
    // Search for smart contracts
    searchContracts: function(ownerAddress) {
        var self = this;
        
        return window.xswd.call('Gnomon.GetAllOwnersAndSCIDs')
            .then(function(allContracts) {
                var ownedContracts = [];
                
                for (var scid in allContracts) {
                    if (allContracts[scid] === ownerAddress) {
                        ownedContracts.push(scid);
                    }
                }
                
                console.log('Found ' + ownedContracts.length + ' contracts for ' + ownerAddress);
                return ownedContracts;
            })
            .catch(function(error) {
                console.error('Contract search failed:', error);
                return [];
            });
    }
});