jaelis-node 1.1.0 → 1.3.0

package/lib/index.js

@@ -11,8 +11,310 @@
 
 const path = require('path');
 const fs = require('fs');
+const crypto = require('crypto');
 const EventEmitter = require('events');
 
+// ═══════════════════════════════════════════════════════════════════════════
+// MULTI-CHAIN ADDRESS UTILITIES
+// Supports: EVM (0x...), Solana (base58), Bitcoin (P2PKH/bech32), etc.
+// JAELIS accepts ANY chain's address format - TRUE multi-chain!
+// ═══════════════════════════════════════════════════════════════════════════
+
+const ADDRESS_FORMATS = {
+    // EVM chains (Ethereum, Polygon, Arbitrum, etc.)
+    evm: {
+        pattern: /^0x[a-fA-F0-9]{40}$/,
+        name: 'EVM (Ethereum, Polygon, etc.)',
+        example: '0x742d35Cc6634C0532925a3b844Bc9e7595f...'
+    },
+    // Solana (base58)
+    solana: {
+        pattern: /^[1-9A-HJ-NP-Za-km-z]{32,44}$/,
+        name: 'Solana',
+        example: '7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZ...'
+    },
+    // Bitcoin P2PKH (starts with 1 or 3)
+    bitcoin_legacy: {
+        pattern: /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/,
+        name: 'Bitcoin (Legacy)',
+        example: '1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2'
+    },
+    // Bitcoin bech32 (starts with bc1)
+    bitcoin_bech32: {
+        pattern: /^bc1[a-z0-9]{39,59}$/,
+        name: 'Bitcoin (SegWit)',
+        example: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq'
+    },
+    // TON (base64url)
+    ton: {
+        pattern: /^[A-Za-z0-9_-]{48}$/,
+        name: 'TON',
+        example: 'EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N'
+    },
+    // Aptos/Sui (hex with 0x, 64 chars)
+    move: {
+        pattern: /^0x[a-fA-F0-9]{64}$/,
+        name: 'Move (Aptos/Sui)',
+        example: '0x1234567890abcdef...'
+    },
+    // JAELIS native (same as EVM for now, but could be extended)
+    jaelis: {
+        pattern: /^0x[a-fA-F0-9]{40}$/,
+        name: 'JAELIS Native',
+        example: '0x742d35Cc6634C0532925a3b844Bc9e7595f...'
+    }
+};
+
+/**
+ * Detect the chain type from an address
+ */
+function detectAddressType(address) {
+    if (!address || typeof address !== 'string') {
+        return null;
+    }
+
+    // Check each format
+    for (const [type, config] of Object.entries(ADDRESS_FORMATS)) {
+        if (config.pattern.test(address)) {
+            return { type, ...config };
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Validate any chain address
+ */
+function validateAddress(address) {
+    const detected = detectAddressType(address);
+    if (!detected) {
+        return {
+            valid: false,
+            error: 'Unknown address format',
+            supportedFormats: Object.keys(ADDRESS_FORMATS)
+        };
+    }
+    return {
+        valid: true,
+        type: detected.type,
+        name: detected.name
+    };
+}
+
+/**
+ * Convert any address to canonical form for internal storage
+ * EVM addresses are lowercased, others kept as-is
+ */
+function toCanonicalAddress(address) {
+    const detected = detectAddressType(address);
+    if (!detected) {
+        throw new Error('Invalid address format');
+    }
+
+    // EVM addresses are case-insensitive, normalize to lowercase
+    if (detected.type === 'evm' || detected.type === 'jaelis') {
+        return address.toLowerCase();
+    }
+
+    // Other formats are case-sensitive
+    return address;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// NODE WALLET CONFIGURATION (Like Geth --suggested-fee-recipient)
+// Stores the node operator's wallet for receiving rewards
+// NO STAKING REQUIRED - JAELIS doesn't hold your funds!
+// ═══════════════════════════════════════════════════════════════════════════
+
+class NodeWalletConfig {
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+        this.configPath = path.join(dataDir, 'node-wallet.json');
+        this.config = null;
+    }
+
+    /**
+     * Load wallet configuration from disk
+     */
+    load() {
+        try {
+            if (fs.existsSync(this.configPath)) {
+                const data = fs.readFileSync(this.configPath, 'utf8');
+                this.config = JSON.parse(data);
+                return this.config;
+            }
+        } catch (e) {
+            console.warn('[WALLET] Failed to load wallet config:', e.message);
+        }
+        return null;
+    }
+
+    /**
+     * Save wallet configuration to disk
+     */
+    save() {
+        try {
+            // Ensure directory exists
+            if (!fs.existsSync(this.dataDir)) {
+                fs.mkdirSync(this.dataDir, { recursive: true });
+            }
+            fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+            return true;
+        } catch (e) {
+            console.error('[WALLET] Failed to save wallet config:', e.message);
+            return false;
+        }
+    }
+
+    /**
+     * Set the reward recipient wallet (ANY chain address!)
+     * Like Geth's --suggested-fee-recipient
+     */
+    setRewardRecipient(address) {
+        const validation = validateAddress(address);
+        if (!validation.valid) {
+            throw new Error(`Invalid address: ${validation.error}`);
+        }
+
+        if (!this.config) {
+            this.config = { createdAt: Date.now() };
+        }
+
+        this.config.rewardRecipient = {
+            address: toCanonicalAddress(address),
+            originalFormat: address,
+            type: validation.type,
+            typeName: validation.name,
+            setAt: Date.now()
+        };
+
+        this.save();
+        console.log(`[WALLET] Reward recipient set: ${address} (${validation.name})`);
+        return this.config.rewardRecipient;
+    }
+
+    /**
+     * Get the reward recipient address
+     */
+    getRewardRecipient() {
+        if (!this.config) this.load();
+        return this.config?.rewardRecipient || null;
+    }
+
+    /**
+     * Add an additional wallet (for multi-wallet nodes)
+     */
+    addWallet(name, address, options = {}) {
+        const validation = validateAddress(address);
+        if (!validation.valid) {
+            throw new Error(`Invalid address: ${validation.error}`);
+        }
+
+        if (!this.config) {
+            this.config = { createdAt: Date.now() };
+        }
+
+        if (!this.config.wallets) {
+            this.config.wallets = [];
+        }
+
+        // Check for duplicates
+        const existing = this.config.wallets.find(w =>
+            toCanonicalAddress(w.address) === toCanonicalAddress(address)
+        );
+        if (existing) {
+            throw new Error(`Wallet already exists: ${existing.name}`);
+        }
+
+        const wallet = {
+            name,
+            address: toCanonicalAddress(address),
+            originalFormat: address,
+            type: validation.type,
+            typeName: validation.name,
+            purpose: options.purpose || 'general',
+            addedAt: Date.now()
+        };
+
+        this.config.wallets.push(wallet);
+        this.save();
+        console.log(`[WALLET] Added wallet: ${name} (${validation.name})`);
+        return wallet;
+    }
+
+    /**
+     * Remove a wallet by name or address
+     */
+    removeWallet(nameOrAddress) {
+        if (!this.config?.wallets) {
+            throw new Error('No wallets configured');
+        }
+
+        const canonical = nameOrAddress.startsWith('0x') || nameOrAddress.startsWith('bc1')
+            ? toCanonicalAddress(nameOrAddress)
+            : null;
+
+        const index = this.config.wallets.findIndex(w =>
+            w.name === nameOrAddress ||
+            (canonical && toCanonicalAddress(w.address) === canonical)
+        );
+
+        if (index === -1) {
+            throw new Error(`Wallet not found: ${nameOrAddress}`);
+        }
+
+        const removed = this.config.wallets.splice(index, 1)[0];
+        this.save();
+        console.log(`[WALLET] Removed wallet: ${removed.name}`);
+        return removed;
+    }
+
+    /**
+     * List all configured wallets
+     */
+    listWallets() {
+        if (!this.config) this.load();
+        return {
+            rewardRecipient: this.config?.rewardRecipient || null,
+            wallets: this.config?.wallets || []
+        };
+    }
+
+    /**
+     * Get node identity (generates one if not exists)
+     * Like Solana's identity keypair
+     */
+    getNodeIdentity() {
+        if (!this.config) this.load();
+        if (!this.config) {
+            this.config = { createdAt: Date.now() };
+        }
+
+        if (!this.config.nodeIdentity) {
+            // Generate a node identity (not a wallet, just an ID)
+            const nodeId = crypto.randomBytes(32).toString('hex');
+            this.config.nodeIdentity = {
+                id: nodeId,
+                publicKey: '0x' + crypto.createHash('sha256').update(nodeId).digest('hex').slice(0, 40),
+                createdAt: Date.now()
+            };
+            this.save();
+            console.log(`[WALLET] Generated node identity: ${this.config.nodeIdentity.publicKey}`);
+        }
+
+        return this.config.nodeIdentity;
+    }
+
+    /**
+     * Get full configuration
+     */
+    getConfig() {
+        if (!this.config) this.load();
+        return this.config;
+    }
+}
+
 // JAELIS Network Endpoints - users connect here automatically
 const JAELIS_NETWORKS = {
     testnet: {
@@ -73,6 +375,65 @@ class JaelisNode extends EventEmitter {
         this.isRunning = false;
         this.startTime = null;
         this.peerCount = 0;
+
+        // Initialize wallet configuration (like Geth's keystore)
+        this.walletConfig = new NodeWalletConfig(this.options.dataDir);
+        this.walletConfig.load();
+
+        // Set reward recipient if provided via options (like --suggested-fee-recipient)
+        if (options.rewardRecipient) {
+            this.walletConfig.setRewardRecipient(options.rewardRecipient);
+        }
+    }
+
+    /**
+     * Get the wallet configuration manager
+     */
+    getWalletConfig() {
+        return this.walletConfig;
+    }
+
+    /**
+     * Set the reward recipient address (ANY chain format!)
+     * Like Geth's --suggested-fee-recipient
+     */
+    setRewardRecipient(address) {
+        return this.walletConfig.setRewardRecipient(address);
+    }
+
+    /**
+     * Get the reward recipient address
+     */
+    getRewardRecipient() {
+        return this.walletConfig.getRewardRecipient();
+    }
+
+    /**
+     * Add a wallet to this node
+     */
+    addWallet(name, address, options = {}) {
+        return this.walletConfig.addWallet(name, address, options);
+    }
+
+    /**
+     * Remove a wallet from this node
+     */
+    removeWallet(nameOrAddress) {
+        return this.walletConfig.removeWallet(nameOrAddress);
+    }
+
+    /**
+     * List all configured wallets
+     */
+    listWallets() {
+        return this.walletConfig.listWallets();
+    }
+
+    /**
+     * Get node identity
+     */
+    getNodeIdentity() {
+        return this.walletConfig.getNodeIdentity();
     }
 
     /**
@@ -110,6 +471,12 @@ class JaelisNode extends EventEmitter {
             this.isRunning = true;
             this.startTime = Date.now();
 
+            // Register with the JAELIS network for tracking
+            await this._registerWithNetwork();
+
+            // Start heartbeat to keep registration alive
+            this._startHeartbeat();
+
             this.emit('started', {
                 network: this.options.network,
                 chainId: this.options.chainId,
@@ -135,6 +502,9 @@ class JaelisNode extends EventEmitter {
 
         console.log('[JAELIS] Stopping node...');
 
+        // Stop heartbeat first
+        this._stopHeartbeat();
+
         // Stop RPC server
         if (this.rpcServer) {
             await this._stopRpcServer();
@@ -275,6 +645,141 @@ class JaelisNode extends EventEmitter {
         }
     }
 
+    /**
+     * Register this node with the JAELIS network for tracking
+     * Mario can see all nodes that connect! Lifetime tracking!
+     */
+    async _registerWithNetwork() {
+        try {
+            const https = require('https');
+            const http = require('http');
+
+            const identity = this.walletConfig.getNodeIdentity();
+            const rewardRecipient = this.walletConfig.getRewardRecipient();
+
+            const nodeInfo = {
+                nodeId: identity.id,
+                publicKey: identity.publicKey,
+                network: this.options.network,
+                chainId: this.options.chainId,
+                version: '1.3.0',
+                rewardAddress: rewardRecipient?.address || null,
+                rewardChainType: rewardRecipient?.type || null,
+                capabilities: ['full-node', 'rpc'],
+                p2pPort: this.options.p2pPort,
+                rpcPort: this.options.rpcPort
+            };
+
+            // Store for heartbeat
+            this._nodeInfo = nodeInfo;
+
+            const data = JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'jaelis_node_register',
+                params: [nodeInfo],
+                id: 1
+            });
+
+            const url = new URL(this.options.remoteRpc);
+            const protocol = url.protocol === 'https:' ? https : http;
+
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                path: url.pathname || '/',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(data)
+                }
+            };
+
+            await new Promise((resolve) => {
+                const req = protocol.request(options, (res) => {
+                    let body = '';
+                    res.on('data', chunk => body += chunk);
+                    res.on('end', () => {
+                        try {
+                            const result = JSON.parse(body);
+                            if (result.result?.registered) {
+                                console.log(`[JAELIS] Node registered with network (ID: ${identity.publicKey.slice(0, 12)}...)`);
+                            }
+                        } catch (e) {
+                            // Silent - registration is best-effort
+                        }
+                        resolve();
+                    });
+                });
+
+                req.on('error', () => resolve()); // Silent fail - will retry on heartbeat
+                req.write(data);
+                req.end();
+            });
+
+        } catch (error) {
+            // Registration is best-effort, don't fail node startup
+            console.log('[JAELIS] Network registration pending (will retry)');
+        }
+    }
+
+    /**
+     * Start heartbeat to keep node registration alive
+     * Sends heartbeat every 60 seconds
+     */
+    _startHeartbeat() {
+        const HEARTBEAT_INTERVAL = 60000; // 60 seconds
+
+        this._heartbeatInterval = setInterval(async () => {
+            if (!this.isRunning || !this._nodeInfo) return;
+
+            try {
+                const https = require('https');
+                const http = require('http');
+
+                const data = JSON.stringify({
+                    jsonrpc: '2.0',
+                    method: 'jaelis_node_heartbeat',
+                    params: [this._nodeInfo.nodeId],
+                    id: 1
+                });
+
+                const url = new URL(this.options.remoteRpc);
+                const protocol = url.protocol === 'https:' ? https : http;
+
+                const options = {
+                    hostname: url.hostname,
+                    port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                    path: url.pathname || '/',
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(data)
+                    }
+                };
+
+                const req = protocol.request(options, () => {});
+                req.on('error', () => {}); // Silent
+                req.write(data);
+                req.end();
+
+            } catch (e) {
+                // Silent - heartbeat is best-effort
+            }
+        }, HEARTBEAT_INTERVAL);
+
+        console.log('[JAELIS] Heartbeat started (60s interval)');
+    }
+
+    /**
+     * Stop heartbeat
+     */
+    _stopHeartbeat() {
+        if (this._heartbeatInterval) {
+            clearInterval(this._heartbeatInterval);
+            this._heartbeatInterval = null;
+        }
+    }
+
     /**
      * Get node status
      */
@@ -362,14 +867,26 @@ class BootstrapNode extends EventEmitter {
 }
 
 // ============================================================
-// EMBEDDED MINIMAL IMPLEMENTATIONS (for standalone operation)
+// EMBEDDED IMPLEMENTATIONS WITH UNIFIED VM
 // ============================================================
 
+// Import VM Executor (UnifiedJaelisVM integration)
+let VMExecutor;
+try {
+    VMExecutor = require('./vm').VMExecutor;
+} catch (e) {
+    console.log('[JAELIS] VM module not loaded - running in light mode');
+}
+
 class EmbeddedBlockchain {
     constructor(options = {}) {
         this.chainId = options.chainId || 4545;
         this.chain = [];
         this.state = new Map();
+        this.pendingTransactions = [];
+
+        // Initialize VM Executor (UnifiedJaelisVM - NO BRIDGES!)
+        this.vmExecutor = null;
     }
 
     async initialize() {
@@ -378,9 +895,19 @@ class EmbeddedBlockchain {
             this.chain.push({
                 number: 0,
                 hash: '0x' + '0'.repeat(64),
+                parentHash: '0x' + '0'.repeat(64),
                 timestamp: Date.now(),
-                transactions: []
+                transactions: [],
+                stateRoot: '0x' + '0'.repeat(64)
+            });
+        }
+
+        // Initialize the Unified VM
+        if (VMExecutor) {
+            this.vmExecutor = new VMExecutor(this, {
+                debug: false
             });
+            console.log('[BLOCKCHAIN] Unified VM initialized - TRUE cross-chain interop!');
         }
     }
 
@@ -388,8 +915,119 @@ class EmbeddedBlockchain {
         return this.chain.length - 1;
     }
 
+    getLatestBlock() {
+        return this.chain[this.chain.length - 1];
+    }
+
+    getBlock(numberOrHash) {
+        if (typeof numberOrHash === 'number') {
+            return this.chain[numberOrHash];
+        }
+        return this.chain.find(b => b.hash === numberOrHash);
+    }
+
+    /**
+     * Deploy a smart contract (ANY language!)
+     */
+    async deployContract(source, language, options = {}) {
+        if (!this.vmExecutor) {
+            throw new Error('VM not available - initialize blockchain first');
+        }
+        return this.vmExecutor.deployContract(source, language, options);
+    }
+
+    /**
+     * Execute a contract call
+     */
+    async executeContract(to, functionName, args = [], options = {}) {
+        if (!this.vmExecutor) {
+            throw new Error('VM not available');
+        }
+        return this.vmExecutor.executeCall(to, functionName, args, options);
+    }
+
+    /**
+     * Cross-contract call (NO BRIDGES!)
+     */
+    async crossContractCall(from, to, functionName, args = []) {
+        if (!this.vmExecutor) {
+            throw new Error('VM not available');
+        }
+        return this.vmExecutor.crossContractCall(from, to, functionName, args);
+    }
+
+    /**
+     * Process a transaction
+     */
+    async processTransaction(tx) {
+        if (this.vmExecutor) {
+            return this.vmExecutor.processTransaction(tx);
+        }
+        // Fallback: just store in pending
+        this.pendingTransactions.push(tx);
+        return { status: 'pending' };
+    }
+
+    /**
+     * Create a new block with pending transactions
+     */
+    async createBlock(validator) {
+        const crypto = require('crypto');
+        const parentBlock = this.getLatestBlock();
+
+        const block = {
+            number: parentBlock.number + 1,
+            hash: null,
+            parentHash: parentBlock.hash,
+            timestamp: Date.now(),
+            validator: validator || '0x0',
+            transactions: [...this.pendingTransactions],
+            stateRoot: this._computeStateRoot(),
+            gasUsed: 0  // ZERO FEES!
+        };
+
+        // Compute block hash
+        block.hash = '0x' + crypto.createHash('sha256')
+            .update(JSON.stringify({
+                number: block.number,
+                parentHash: block.parentHash,
+                timestamp: block.timestamp,
+                stateRoot: block.stateRoot
+            }))
+            .digest('hex');
+
+        // Add to chain
+        this.chain.push(block);
+        this.pendingTransactions = [];
+
+        console.log(`[BLOCKCHAIN] Block #${block.number} created with ${block.transactions.length} txs`);
+
+        return block;
+    }
+
+    _computeStateRoot() {
+        const crypto = require('crypto');
+        const stateData = JSON.stringify(Array.from(this.state.entries()));
+        return '0x' + crypto.createHash('sha256').update(stateData).digest('hex');
+    }
+
+    /**
+     * Get VM stats
+     */
+    getVMStats() {
+        return this.vmExecutor?.getStats?.() || { vmAvailable: false };
+    }
+
+    /**
+     * Get all deployed contracts
+     */
+    getContracts() {
+        return this.vmExecutor?.getAllContracts?.() || [];
+    }
+
     async save() {
-        // Minimal save
+        // Save blockchain state to disk
+        // TODO: Implement persistent storage
     }
 }
 
@@ -529,34 +1167,44 @@ class EmbeddedRpcServer {
 
         this.app = express();
         this.app.use(cors());
-        this.app.use(express.json());
+        this.app.use(express.json({ limit: '50mb' }));  // Allow large contract deployments
 
-        // Basic RPC endpoint
-        this.app.post('/', (req, res) => {
+        // Main RPC endpoint
+        this.app.post('/', async (req, res) => {
             const { method, params, id } = req.body;
 
-            let result = null;
-            let error = null;
-
-            switch (method) {
-                case 'jaelis_getHealth':
-                case 'eth_chainId':
-                    result = { status: 'healthy', chainId: this.blockchain?.chainId };
-                    break;
-                case 'jaelis_blockNumber':
-                case 'eth_blockNumber':
-                    result = '0x' + (this.blockchain?.getHeight?.() || 0).toString(16);
-                    break;
-                default:
-                    error = { code: -32601, message: 'Method not found' };
+            try {
+                const result = await this._handleMethod(method, params || []);
+                res.json({ jsonrpc: '2.0', id, result });
+            } catch (error) {
+                res.json({
+                    jsonrpc: '2.0',
+                    id,
+                    error: { code: -32000, message: error.message }
+                });
             }
-
-            res.json({ jsonrpc: '2.0', id, result, error });
         });
 
         // Health check
         this.app.get('/', (req, res) => {
-            res.json({ status: 'online', service: 'JAELIS Node', chainId: this.blockchain?.chainId });
+            const vmStats = this.blockchain?.getVMStats?.() || {};
+            res.json({
+                status: 'online',
+                service: 'JAELIS Node',
+                chainId: this.blockchain?.chainId,
+                blockHeight: this.blockchain?.getHeight?.() || 0,
+                vm: {
+                    available: vmStats.vmAvailable || false,
+                    contractsDeployed: vmStats.contractsDeployed || 0,
+                    crossContractCalls: vmStats.crossContractCalls || 0
+                },
+                features: [
+                    'ZERO_FEES',
+                    'UNIFIED_VM',
+                    'NO_BRIDGES',
+                    'CROSS_CHAIN_INTEROP'
+                ]
+            });
         });
 
         return new Promise((resolve) => {
@@ -566,6 +1214,284 @@ class EmbeddedRpcServer {
         });
     }
 
+    async _handleMethod(method, params) {
+        switch (method) {
+            // ═══════════════════════════════════════════════════════════════
+            // STANDARD ETHEREUM-COMPATIBLE METHODS
+            // ═══════════════════════════════════════════════════════════════
+            case 'eth_chainId':
+                return '0x' + (this.blockchain?.chainId || 4545).toString(16);
+
+            case 'eth_blockNumber':
+            case 'jaelis_blockNumber':
+                return '0x' + (this.blockchain?.getHeight?.() || 0).toString(16);
+
+            case 'eth_getBlockByNumber':
+                const blockNum = parseInt(params[0], 16);
+                return this.blockchain?.getBlock?.(blockNum) || null;
+
+            case 'eth_sendTransaction':
+            case 'eth_sendRawTransaction':
+                return this._sendTransaction(params[0]);
+
+            case 'eth_call':
+                return this._call(params[0], params[1]);
+
+            case 'eth_getTransactionReceipt':
+                return this.blockchain?.vmExecutor?.getReceipt?.(params[0]) || null;
+
+            // ═══════════════════════════════════════════════════════════════
+            // JAELIS-SPECIFIC METHODS (Unified VM)
+            // ═══════════════════════════════════════════════════════════════
+            case 'jaelis_getHealth':
+                return {
+                    status: 'healthy',
+                    chainId: this.blockchain?.chainId,
+                    blockHeight: this.blockchain?.getHeight?.() || 0,
+                    vmActive: !!this.blockchain?.vmExecutor
+                };
+
+            case 'jaelis_deployContract':
+                // Deploy contract in ANY language!
+                // params: [source, language, options]
+                return this._deployContract(params[0], params[1], params[2] || {});
+
+            case 'jaelis_executeContract':
+                // Execute contract call
+                // params: [to, functionName, args, options]
+                return this._executeContract(params[0], params[1], params[2] || [], params[3] || {});
+
+            case 'jaelis_crossContractCall':
+                // Cross-contract call (NO BRIDGES!)
+                // params: [fromContract, toContract, functionName, args]
+                return this._crossContractCall(params[0], params[1], params[2], params[3] || []);
+
+            case 'jaelis_getContracts':
+                return this.blockchain?.getContracts?.() || [];
+
+            case 'jaelis_getVMStats':
+                return this.blockchain?.getVMStats?.() || { vmAvailable: false };
+
+            case 'jaelis_getSupportedLanguages':
+                return ['solidity', 'rust', 'move', 'func', 'cairo', 'vyper'];
+
+            // ═══════════════════════════════════════════════════════════════
+            // CROSS-CHAIN SETTLEMENT METHODS (Universal State Layer!)
+            // ═══════════════════════════════════════════════════════════════
+
+            case 'jaelis_crossChain_getChains':
+                // Get all registered chains
+                return this._getCrossChainRegistry();
+
+            case 'jaelis_crossChain_getChainInfo':
+                // Get info for specific chain ID
+                return this._getCrossChainInfo(params[0]);
+
+            case 'jaelis_crossChain_readState':
+                // Read settled state from external chain
+                // params: [chainId, contractAddress, variableName]
+                return this._readCrossChainState(params[0], params[1], params[2]);
+
+            case 'jaelis_crossChain_settleState':
+                // Settle external chain state with proof
+                // params: [chainId, contractAddress, variableName, value, proof]
+                return this._settleCrossChainState(params[0], params[1], params[2], params[3], params[4]);
+
+            case 'jaelis_crossChain_getStateDiff':
+                // Get state diff between two chains
+                // params: [chainId1, chainId2, contractAddress, variableNames]
+                return this._getCrossChainStateDiff(params[0], params[1], params[2], params[3]);
+
+            case 'jaelis_crossChain_computeSlot':
+                // Compute namespaced storage slot
+                // params: [chainId, contractAddress, variableName]
+                return this._computeCrossChainSlot(params[0], params[1], params[2]);
+
+            case 'jaelis_crossChain_getLightClientStatus':
+                // Get light client status for a chain
+                return this._getLightClientStatus(params[0]);
+
+            case 'jaelis_crossChain_getSettlements':
+                // Get all settlements for a contract
+                // params: [chainId, contractAddress]
+                return this._getSettlements(params[0], params[1]);
+
+            case 'jaelis_crossChain_getStats':
+                // Get cross-chain stats
+                return this._getCrossChainStats();
+
+            default:
+                throw new Error(`Method not found: ${method}`);
+        }
+    }
+
+    async _sendTransaction(tx) {
+        if (!this.blockchain) throw new Error('Blockchain not available');
+        const result = await this.blockchain.processTransaction(tx);
+        return result.transactionHash || '0x0';
+    }
+
+    async _call(callObject) {
+        if (!this.blockchain?.vmExecutor) throw new Error('VM not available');
+        const result = await this.blockchain.vmExecutor.executeCall(
+            callObject.to,
+            callObject.data?.functionName || 'call',
+            callObject.data?.args || [],
+            { from: callObject.from }
+        );
+        return result.returnValue;
+    }
+
+    async _deployContract(source, language, options) {
+        if (!this.blockchain) throw new Error('Blockchain not available');
+        console.log(`[RPC] Deploying ${language} contract...`);
+        const result = await this.blockchain.deployContract(source, language, options);
+        return {
+            address: result.address,
+            language,
+            gasUsed: 0  // ZERO FEES!
+        };
+    }
+
+    async _executeContract(to, functionName, args, options) {
+        if (!this.blockchain) throw new Error('Blockchain not available');
+        return this.blockchain.executeContract(to, functionName, args, options);
+    }
+
+    async _crossContractCall(from, to, functionName, args) {
+        if (!this.blockchain) throw new Error('Blockchain not available');
+        console.log(`[RPC] Cross-call: ${from.substring(0, 10)}... → ${to.substring(0, 10)}...::${functionName}`);
+        return this.blockchain.crossContractCall(from, to, functionName, args);
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // CROSS-CHAIN SETTLEMENT IMPLEMENTATIONS
+    // ═══════════════════════════════════════════════════════════════
+
+    _getCrossChainRegistry() {
+        // Return the VM's cross-chain registry if available
+        if (this.blockchain?.vmExecutor?.vm?.getAllChains) {
+            return this.blockchain.vmExecutor.vm.getAllChains();
+        }
+        // Fallback: return hardcoded registry
+        return {
+            JAELIS_MAINNET: { id: 4547, name: 'JAELIS Mainnet', type: 'native', status: 'upcoming' },
+            JAELIS_TESTNET: { id: 4545, name: 'JAELIS Testnet', type: 'native', status: 'live' },
+            ETH_MAINNET: { id: 1, name: 'Ethereum Mainnet', type: 'evm' },
+            ETH_SEPOLIA: { id: 11155111, name: 'Ethereum Sepolia', type: 'evm' },
+            POLYGON: { id: 137, name: 'Polygon PoS', type: 'evm' },
+            ARBITRUM_ONE: { id: 42161, name: 'Arbitrum One', type: 'evm' },
+            OPTIMISM: { id: 10, name: 'OP Mainnet', type: 'evm' },
+            BASE: { id: 8453, name: 'Base', type: 'evm' },
+            AVALANCHE_C: { id: 43114, name: 'Avalanche C-Chain', type: 'evm' },
+            BSC: { id: 56, name: 'BNB Smart Chain', type: 'evm' },
+            SOLANA_MAINNET: { id: 101, name: 'Solana Mainnet', type: 'svm', cluster: 'mainnet-beta' },
+            SOLANA_DEVNET: { id: 102, name: 'Solana Devnet', type: 'svm', cluster: 'devnet' },
+            APTOS_MAINNET: { id: 1, name: 'Aptos Mainnet', type: 'move', network: 'aptos' },
+            SUI_MAINNET: { id: 1, name: 'Sui Mainnet', type: 'move', network: 'sui' },
+            TON_MAINNET: { id: -1, name: 'TON Mainnet', type: 'tvm', workchain: -1 }
+        };
+    }
+
+    _getCrossChainInfo(chainId) {
+        const chains = this._getCrossChainRegistry();
+        const chain = Object.values(chains).find(c => c.id === chainId);
+        return chain || { error: 'Chain not found', chainId };
+    }
+
+    async _readCrossChainState(chainId, contractAddress, variableName) {
+        if (this.blockchain?.vmExecutor?.vm?.readCrossChainState) {
+            const value = this.blockchain.vmExecutor.vm.readCrossChainState(chainId, contractAddress, variableName);
+            return {
+                chainId,
+                contractAddress,
+                variableName,
+                value: value ? '0x' + value.toString('hex') : '0x0',
+                settled: value ? true : false
+            };
+        }
+        return { error: 'Cross-chain state not available', chainId, contractAddress, variableName };
+    }
+
+    async _settleCrossChainState(chainId, contractAddress, variableName, value, proof) {
+        if (this.blockchain?.vmExecutor?.vm?.settleExternalState) {
+            const valueBuffer = Buffer.from(value.replace('0x', ''), 'hex');
+            const result = await this.blockchain.vmExecutor.vm.settleExternalState(
+                chainId, contractAddress, variableName, valueBuffer, proof
+            );
+            console.log(`[RPC] Cross-chain settlement: Chain ${chainId} → ${variableName}`);
+            return {
+                success: true,
+                chainId,
+                contractAddress,
+                variableName,
+                slot: result.slot ? '0x' + result.slot.toString('hex') : null,
+                settlement: result.settlement
+            };
+        }
+        return { error: 'Cross-chain settlement not available' };
+    }
+
+    _getCrossChainStateDiff(chainId1, chainId2, contractAddress, variableNames) {
+        if (this.blockchain?.vmExecutor?.vm?.getCrossChainStateDiff) {
+            return this.blockchain.vmExecutor.vm.getCrossChainStateDiff(
+                chainId1, chainId2, contractAddress, variableNames
+            );
+        }
+        return { error: 'State diff not available', chainId1, chainId2 };
+    }
+
+    _computeCrossChainSlot(chainId, contractAddress, variableName) {
+        if (this.blockchain?.vmExecutor?.vm?.computeCrossChainSlot) {
+            const slot = this.blockchain.vmExecutor.vm.computeCrossChainSlot(chainId, contractAddress, variableName);
+            return '0x' + slot.toString('hex');
+        }
+        // Fallback: compute locally
+        const crypto = require('crypto');
+        const data = Buffer.concat([
+            Buffer.alloc(4),  // chainId placeholder
+            Buffer.from(contractAddress.replace('0x', ''), 'hex'),
+            Buffer.from(variableName, 'utf8')
+        ]);
+        data.writeUInt32LE(chainId, 0);
+        return '0x' + crypto.createHash('sha256').update(data).digest('hex');
+    }
+
+    _getLightClientStatus(chainId) {
+        if (this.blockchain?.vmExecutor?.vm?.crossChainManager?.stateStore?.lightClients) {
+            const client = this.blockchain.vmExecutor.vm.crossChainManager.stateStore.lightClients.get(chainId);
+            if (client) {
+                return {
+                    chainId,
+                    synced: client.synced || false,
+                    latestBlock: client.latestBlock || 0,
+                    stateRoot: client.latestStateRoot ? '0x' + client.latestStateRoot.toString('hex') : null
+                };
+            }
+        }
+        return { chainId, synced: false, error: 'Light client not available' };
+    }
+
+    _getSettlements(chainId, contractAddress) {
+        if (this.blockchain?.vmExecutor?.vm?.crossChainManager?.stateStore?.settlementLog) {
+            const log = this.blockchain.vmExecutor.vm.crossChainManager.stateStore.settlementLog;
+            return log.filter(s => s.chainId === chainId && s.contractAddress === contractAddress);
+        }
+        return [];
+    }
+
+    _getCrossChainStats() {
+        if (this.blockchain?.vmExecutor?.vm?.crossChainManager?.getStats) {
+            return this.blockchain.vmExecutor.vm.crossChainManager.getStats();
+        }
+        return {
+            totalSettlements: 0,
+            chainsActive: 0,
+            lightClientsRegistered: 0,
+            stateSize: 0
+        };
+    }
+
     async stop() {
         if (this.server) {
             this.server.close();
@@ -599,6 +1525,15 @@ module.exports = {
     EmbeddedRpcServer,
     EmbeddedStorage,
 
+    // Wallet configuration (like Geth's keystore)
+    NodeWalletConfig,
+
+    // Multi-chain address utilities
+    ADDRESS_FORMATS,
+    detectAddressType,
+    validateAddress,
+    toCanonicalAddress,
+
     // Convenience factory
     createNode: (options) => new JaelisNode(options),
     createBootstrap: (options) => new BootstrapNode(options)