API Call Patterns

// From app1 - VERIFIED RPC FORMAT
function sendRPC(method, params = {}) {
    return new Promise((resolve, reject) => {
        if (!isConnected || !socket || socket.readyState !== WebSocket.OPEN) {
            reject(new Error('Not connected'));
            return;
        }
        
        const id = (++requestId).toString();
        const request = {
            jsonrpc: "2.0",      // Required: JSON-RPC 2.0
            id: id,              // Required: Unique request ID
            method: method       // Required: RPC method name
        };
        
        // Optional: Add params if provided
        if (Object.keys(params).length > 0) {
            request.params = params;
        }
        
        // Store pending request for response matching
        pendingRequests.set(id, { resolve, reject, method });
        
        // Send request
        socket.send(JSON.stringify(request));
        
        // Timeout after 10 seconds
        setTimeout(() => {
            if (pendingRequests.has(id)) {
                pendingRequests.delete(id);
                reject(new Error(`Timeout: ${method}`));
            }
        }, 10000);
    });
}

// Handle RPC responses
function handleRPCResponse(response) {
    if (response.id && pendingRequests.has(response.id)) {
        const { resolve, reject } = pendingRequests.get(response.id);
        pendingRequests.delete(response.id);
        
        if (response.error) {
            reject(new Error(response.error.message || 'RPC error'));
        } else {
            resolve(response.result);
        }
    }
}

async function getAddress() {
    try {
        const result = await sendRPC('GetAddress');
        console.log('Address:', result.address);
        return result.address;
    } catch (error) {
        console.error('Error:', error.message);
    }
}

{
  "jsonrpc": "2.0",
  "id": "1",
  "result": {
    "address": "deto1qy..."
  }
}

async function getBalance() {
    try {
        const result = await sendRPC('GetBalance');
        const balance = result.unlocked_balance / 100000;  // Convert to DERO
        console.log('Balance:', balance, 'DERO');
        return balance;
    } catch (error) {
        console.error('Error:', error.message);
    }
}

{
  "jsonrpc": "2.0",
  "id": "2",
  "result": {
    "balance": 100000000,
    "unlocked_balance": 100000000
  }
}

async function getNetworkInfo() {
    try {
        const result = await sendRPC('DERO.GetInfo');
        console.log('Network height:', result.height);
        console.log('Difficulty:', result.difficulty);
        return result;
    } catch (error) {
        console.error('Error:', error.message);
    }
}

// ✅ CORRECT: Use incremental or unique IDs
let requestId = 0;
const id = (++requestId).toString();  // "1", "2", "3"...
 
// Or use UUID/random
const id = Date.now().toString(16);  // Hex timestamp
 
// ❌ WRONG: Reusing IDs causes response matching issues
const id = "1";  // Multiple requests with same ID!

// RPC Error Response Format
{
  "jsonrpc": "2.0",
  "id": "1",
  "error": {
    "code": -32000,
    "message": "Error description"
  }
}
 
// Handle errors
socket.onmessage = function(event) {
    const response = JSON.parse(event.data);
    
    if (response.error) {
        console.error('RPC Error:', response.error.message);
        // Reject promise or handle error
    } else if (response.result) {
        // Success - resolve promise
    }
};