jaelis-node 1.5.0 → 1.8.0

package/lib/index.js

@@ -485,6 +485,9 @@ class JaelisNode extends EventEmitter {
                 await this._initRpcServer();
             }
 
+            // Start Settlement Server for cross-chain deployments
+            await this._initSettlementServer();
+
             this.isRunning = true;
             this.startTime = Date.now();
 
@@ -522,6 +525,11 @@ class JaelisNode extends EventEmitter {
         // Stop heartbeat first
         this._stopHeartbeat();
 
+        // Stop Settlement server
+        if (this.settlementServer) {
+            await this._stopSettlementServer();
+        }
+
         // Stop RPC server
         if (this.rpcServer) {
             await this._stopRpcServer();
@@ -623,7 +631,8 @@ class JaelisNode extends EventEmitter {
         console.log('[JAELIS] Initializing RPC server...');
 
         if (this.JaelisRpcServer) {
-            this.rpcServer = new this.JaelisRpcServer(this.blockchain, this.options.rpcPort);
+            // Pass network reference for sync status reporting
+            this.rpcServer = new this.JaelisRpcServer(this.blockchain, this.options.rpcPort, this.network);
 
             if (this.rpcServer.start) {
                 await this.rpcServer.start();
@@ -635,6 +644,52 @@ class JaelisNode extends EventEmitter {
         console.log(`[JAELIS] RPC server started on http://${this.options.rpcHost}:${this.options.rpcPort}`);
     }
 
+    /**
+     * Initialize Settlement Server for cross-chain deployments
+     *
+     * The Settlement Server handles propagating JAELIS contract deployments
+     * to external chains. NO GAS - NO FEES - NO SANDBOX - NO WALLS!
+     */
+    async _initSettlementServer() {
+        console.log('[JAELIS] Initializing Settlement Server...');
+
+        try {
+            // Load the settlement server module
+            const settlementPath = path.join(__dirname, 'settlement-server.js');
+
+            if (fs.existsSync(settlementPath)) {
+                const { SettlementServer } = require(settlementPath);
+
+                this.settlementServer = new SettlementServer({
+                    port: this.options.settlementPort || 3847,
+                    host: this.options.rpcHost || '0.0.0.0'
+                });
+
+                await this.settlementServer.start();
+
+                console.log(`[JAELIS] Settlement Server started on port ${this.options.settlementPort || 3847}`);
+                console.log('[JAELIS] Cross-chain deployments: ENABLED');
+                console.log('[JAELIS] NO GAS - NO FEES - NO SANDBOX - NO WALLS!');
+            } else {
+                console.log('[JAELIS] Settlement Server not found, cross-chain disabled');
+            }
+        } catch (error) {
+            // Don't fail node startup if settlement server fails
+            console.error('[JAELIS] Settlement Server error:', error.message);
+            console.log('[JAELIS] Continuing without cross-chain support...');
+        }
+    }
+
+    /**
+     * Stop Settlement Server
+     */
+    async _stopSettlementServer() {
+        if (this.settlementServer && this.settlementServer.stop) {
+            await this.settlementServer.stop();
+            console.log('[JAELIS] Settlement Server stopped');
+        }
+    }
+
     /**
      * Stop RPC server
      */
@@ -707,7 +762,8 @@ class JaelisNode extends EventEmitter {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(data)
+                    'Content-Length': Buffer.byteLength(data),
+                    'User-Agent': 'JAELIS-Node/1.7.0'  // Identifies us as a node - gets priority treatment
                 }
             };
 
@@ -770,7 +826,8 @@ class JaelisNode extends EventEmitter {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json',
-                        'Content-Length': Buffer.byteLength(data)
+                        'Content-Length': Buffer.byteLength(data),
+                        'User-Agent': 'JAELIS-Node/1.7.0'  // Identifies us as a node - gets priority treatment
                     }
                 };
 
@@ -1042,6 +1099,105 @@ class EmbeddedBlockchain {
         return this.vmExecutor?.getAllContracts?.() || [];
     }
 
+    /**
+     * Add a block received from sync (RPC fallback or P2P)
+     * Validates the block before adding to chain
+     */
+    async addBlock(block) {
+        if (!block || block.number === undefined) {
+            throw new Error('Invalid block');
+        }
+
+        // Normalize block number - could be hex string (0x1) or decimal
+        let blockNumber = block.number;
+        if (typeof blockNumber === 'string') {
+            if (blockNumber.startsWith('0x')) {
+                blockNumber = parseInt(blockNumber, 16);
+            } else {
+                blockNumber = parseInt(blockNumber, 10);
+            }
+        }
+
+        const expectedNumber = this.chain.length;
+        if (blockNumber !== expectedNumber) {
+            // Skip if we already have this block or it's out of order
+            if (blockNumber < expectedNumber) {
+                return { status: 'skipped', reason: 'already_have' };
+            }
+            throw new Error(`Block out of order: expected ${expectedNumber}, got ${blockNumber}`);
+        }
+
+        // Store normalized block number for consistency
+        block.number = blockNumber;
+
+        // Validate parent hash (skip for first sync - genesis hash may differ)
+        // Like Ethereum "fast sync" - we trust the RPC source initially
+        const parentBlock = this.getLatestBlock();
+        if (blockNumber > 1 && block.parentHash && parentBlock.hash) {
+            // Only validate parent hash for blocks after genesis
+            // During initial sync, parent hashes are validated by the remote node
+            if (block.parentHash !== parentBlock.hash) {
+                // Check if this is initial sync (chain is mostly empty)
+                if (this.chain.length > 10) {
+                    throw new Error('Invalid parent hash - possible chain reorg');
+                }
+                // During initial sync, log but continue
+                console.log(`[SYNC] Accepting block ${blockNumber} (trusting remote during initial sync)`);
+            }
+        }
+
+        // Add block to chain
+        this.chain.push(block);
+
+        // Process transactions in the block
+        if (block.transactions && Array.isArray(block.transactions)) {
+            for (const tx of block.transactions) {
+                // Update account states from transactions
+                if (tx.from && tx.to && tx.value) {
+                    const value = BigInt(tx.value || '0');
+                    const fromBalance = BigInt(this.state.get(tx.from)?.balance || '0');
+                    const toBalance = BigInt(this.state.get(tx.to)?.balance || '0');
+
+                    // Debit sender, credit receiver
+                    this.state.set(tx.from, {
+                        ...this.state.get(tx.from),
+                        balance: (fromBalance - value).toString(),
+                        nonce: (parseInt(this.state.get(tx.from)?.nonce || '0') + 1).toString()
+                    });
+                    this.state.set(tx.to, {
+                        ...this.state.get(tx.to),
+                        balance: (toBalance + value).toString()
+                    });
+                }
+            }
+        }
+
+        console.log(`[BLOCKCHAIN] Synced block #${block.number} (${block.transactions?.length || 0} txs)`);
+
+        return { status: 'added', blockNumber: block.number };
+    }
+
+    /**
+     * Get sync status (jaelis_syncing compatible)
+     */
+    getSyncStatus(remoteHeight) {
+        const localHeight = this.getHeight();
+        const isSyncing = localHeight < remoteHeight;
+
+        if (!isSyncing) {
+            return false; // Fully synced
+        }
+
+        return {
+            startingBlock: '0x0',
+            currentBlock: '0x' + localHeight.toString(16),
+            highestBlock: '0x' + remoteHeight.toString(16),
+            syncedBlocks: localHeight,
+            remainingBlocks: remoteHeight - localHeight,
+            percentComplete: ((localHeight / remoteHeight) * 100).toFixed(2) + '%'
+        };
+    }
+
     async save() {
         // Save blockchain state to disk
         // TODO: Implement persistent storage
@@ -1084,9 +1240,10 @@ class EmbeddedNetwork {
         const { tcp } = await import('@libp2p/tcp');
         const { noise } = await import('@chainsafe/libp2p-noise');
         const { yamux } = await import('@chainsafe/libp2p-yamux');
-        const { bootstrap } = await import('@libp2p/bootstrap');
         const { identify } = await import('@libp2p/identify');
 
+        // Create libp2p node - JAELIS user node
+        // Like Ethereum: start listening, bootstrap nodes come later via DHT
         const config = {
             addresses: {
                 listen: [`/ip4/${this.host}/tcp/${this.port}`]
@@ -1099,17 +1256,11 @@ class EmbeddedNetwork {
             }
         };
 
-        // Add bootstrap if we have nodes
-        if (this.bootstrapNodes.length > 0) {
-            const validBootstrap = this.bootstrapNodes.filter(n => n.includes('/p2p/'));
-            if (validBootstrap.length > 0) {
-                config.peerDiscovery = [bootstrap({ list: validBootstrap })];
-            }
-        }
-
         this.libp2p = await createLibp2p(config);
         await this.libp2p.start();
 
+        console.log(`[P2P] Node started with ID: ${this.libp2p.peerId.toString().slice(0, 16)}...`);
+
         // Track peers
         this.libp2p.addEventListener('peer:connect', (evt) => {
             const peerId = evt.detail.toString();
@@ -1122,33 +1273,131 @@ class EmbeddedNetwork {
             this.peers.delete(peerId);
             console.log(`[P2P] Peer disconnected (${this.peers.size} remaining)`);
         });
+
+        // Try to dial bootstrap nodes directly (without peer ID)
+        // Like Ethereum: we connect via TCP, then learn peer ID during handshake
+        for (const addr of this.bootstrapNodes) {
+            try {
+                const { multiaddr } = await import('@multiformats/multiaddr');
+                const ma = multiaddr(addr);
+                await this.libp2p.dial(ma);
+                console.log(`[P2P] Connected to bootstrap: ${addr}`);
+            } catch (err) {
+                // Bootstrap unavailable - this is OK, we'll use RPC fallback
+                console.log(`[P2P] Bootstrap ${addr.slice(0, 30)}... unavailable`);
+            }
+        }
     }
 
     async _startRPCFallback() {
-        // Sync from remote RPC periodically
-        const syncFromRPC = async () => {
-            try {
+        // Track sync state
+        this.syncState = {
+            localHeight: 0,
+            remoteHeight: 0,
+            syncing: false,
+            lastSync: null,
+            blocksDownloaded: 0
+        };
+
+        // Helper to make RPC calls to remote node
+        const rpcCall = async (method, params = []) => {
+            return new Promise((resolve, reject) => {
                 const https = require('https');
                 const http = require('http');
-                const protocol = this.remoteRpc.startsWith('https') ? https : http;
+                const url = new URL(this.remoteRpc);
+                const protocol = url.protocol === 'https:' ? https : http;
 
                 const data = JSON.stringify({
                     jsonrpc: '2.0',
-                    method: 'eth_blockNumber',
-                    params: [],
-                    id: 1
+                    method,
+                    params,
+                    id: Date.now()
                 });
 
-                // Simple fetch for block number (keeps node in sync)
-                // Full sync implementation would fetch blocks
+                const req = protocol.request({
+                    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),
+                        'User-Agent': 'JAELIS-Node/1.7.0'  // Node sync traffic - exempt from rate limits
+                    }
+                }, (res) => {
+                    let body = '';
+                    res.on('data', chunk => body += chunk);
+                    res.on('end', () => {
+                        try {
+                            const json = JSON.parse(body);
+                            if (json.error) reject(new Error(json.error.message));
+                            else resolve(json.result);
+                        } catch (e) { reject(e); }
+                    });
+                });
+
+                req.on('error', reject);
+                req.write(data);
+                req.end();
+            });
+        };
+
+        // Sync blocks from remote RPC using JAELIS NATIVE methods
+        const syncFromRPC = async () => {
+            if (this.syncState.syncing) return; // Already syncing
+            this.syncState.syncing = true;
+
+            try {
+                // 1. Get remote block height using NATIVE jaelis_blockNumber
+                const remoteHeightHex = await rpcCall('jaelis_blockNumber');
+                this.syncState.remoteHeight = parseInt(remoteHeightHex, 16);
+
+                // 2. Get local block height
+                this.syncState.localHeight = this.blockchain?.getHeight?.() || 0;
+
+                // 3. Sync missing blocks (batch of 10 at a time)
+                const blocksToSync = Math.min(10, this.syncState.remoteHeight - this.syncState.localHeight);
+
+                if (blocksToSync > 0) {
+                    console.log(`[SYNC] Syncing blocks ${this.syncState.localHeight + 1} to ${this.syncState.localHeight + blocksToSync} (remote: ${this.syncState.remoteHeight})`);
+
+                    for (let i = 1; i <= blocksToSync; i++) {
+                        const blockNum = this.syncState.localHeight + i;
+                        const blockHex = '0x' + blockNum.toString(16);
+
+                        // Fetch full block with transactions using NATIVE jaelis_getBlockByNumber
+                        // This returns JAELIS-native fields (lodeUsed, consensus: PoEC, etc.)
+                        const block = await rpcCall('jaelis_getBlockByNumber', [blockHex, true]);
+
+                        if (block) {
+                            // Store block in local blockchain
+                            if (this.blockchain?.addBlock) {
+                                await this.blockchain.addBlock(block);
+                            }
+                            this.syncState.blocksDownloaded++;
+                        }
+                    }
+
+                    this.syncState.localHeight += blocksToSync;
+                    console.log(`[SYNC] Downloaded ${blocksToSync} blocks. Local height: ${this.syncState.localHeight}`);
+                }
+
+                this.syncState.lastSync = Date.now();
+                this.emit('sync', this.syncState);
+
             } catch (err) {
-                // Silent fail - will retry
+                console.error('[SYNC] Error:', err.message);
+            } finally {
+                this.syncState.syncing = false;
             }
         };
 
-        // Sync every 5 seconds
-        this.syncInterval = setInterval(syncFromRPC, 5000);
+        // Initial sync
+        console.log('[SYNC] Starting RPC fallback sync from', this.remoteRpc);
         await syncFromRPC();
+
+        // Continue syncing every 3 seconds (JAELIS has 3-second blocks)
+        this.syncInterval = setInterval(syncFromRPC, 3000);
     }
 
     async stop() {
@@ -1172,9 +1421,10 @@ class EmbeddedNetwork {
 }
 
 class EmbeddedRpcServer {
-    constructor(blockchain, port) {
+    constructor(blockchain, port, network = null) {
         this.blockchain = blockchain;
         this.port = port;
+        this.network = network;  // Reference to EmbeddedNetwork for sync status
         this.app = null;
     }
 
@@ -1242,6 +1492,36 @@ class EmbeddedRpcServer {
             case 'jaelis_blockNumber':
                 return '0x' + (this.blockchain?.getHeight?.() || 0).toString(16);
 
+            case 'jaelis_syncing':
+                // Return sync status - false if fully synced, object if syncing
+                if (this.network?.syncState) {
+                    return this.blockchain?.getSyncStatus?.(this.network.syncState.remoteHeight) || false;
+                }
+                return false;
+
+            case 'jaelis_getBlockByNumber':
+                // Native JAELIS method - returns JAELIS-native block fields
+                const jaelisBlockNum = typeof params[0] === 'string' && params[0].startsWith('0x')
+                    ? parseInt(params[0], 16)
+                    : params[0];
+                const jaelisBlock = this.blockchain?.getBlock?.(jaelisBlockNum);
+                if (jaelisBlock) {
+                    // Add JAELIS-specific fields
+                    return {
+                        ...jaelisBlock,
+                        lodeUsed: '0x0', // ZERO FEES
+                        consensus: 'PoEC', // Proof of Entropy Contribution
+                        jaelisVersion: '1.0.0'
+                    };
+                }
+                return null;
+
+            case 'jaelis_getBlockByHash':
+                // Find block by hash
+                const targetHash = params[0];
+                const foundBlock = this.blockchain?.chain?.find(b => b.hash === targetHash);
+                return foundBlock || null;
+
             // ═══════════════════════════════════════════════════════════════
             // LAYER 2: ETHEREUM COMPATIBILITY (PROXIES → jaelis_*)
             // ═══════════════════════════════════════════════════════════════
@@ -1265,9 +1545,35 @@ class EmbeddedRpcServer {
             case 'eth_getTransactionReceipt':
                 return this.blockchain?.vmExecutor?.getReceipt?.(params[0]) || null;
 
+            case 'eth_getCode':
+                // CRITICAL: This is how block explorers detect contracts!
+                // Returns bytecode at address, or '0x' for EOAs
+                return this._getCode(params[0], params[1] || 'latest');
+
+            case 'eth_getBalance':
+                return this._getBalance(params[0], params[1] || 'latest');
+
+            case 'eth_getTransactionCount':
+                return this._getTransactionCount(params[0], params[1] || 'latest');
+
+            case 'eth_getStorageAt':
+                return this._getStorageAt(params[0], params[1], params[2] || 'latest');
+
+            case 'eth_estimateGas':
+                // JAELIS has ZERO GAS - always return minimal
+                return '0x5208';  // 21000 in hex
+
+            case 'eth_gasPrice':
+                // JAELIS has ZERO GAS
+                return '0x0';
+
             // ═══════════════════════════════════════════════════════════════
             // JAELIS-SPECIFIC METHODS (Unified VM)
             // ═══════════════════════════════════════════════════════════════
+            case 'jaelis_getCode':
+                // Native JAELIS method - returns contract bytecode
+                return this._getCode(params[0], params[1] || 'latest');
+
             case 'jaelis_getHealth':
                 return {
                     status: 'healthy',
@@ -1307,6 +1613,45 @@ class EmbeddedRpcServer {
             case 'jaelis_getSupportedLanguages':
                 return ['solidity', 'rust', 'move', 'func', 'cairo', 'vyper'];
 
+            // ═══════════════════════════════════════════════════════════════
+            // CROSS-CHAIN DEPLOYMENT METHODS (NEW!)
+            // Query contract deployments across chains
+            // ═══════════════════════════════════════════════════════════════
+
+            case 'jaelis_crossChain_getDeployment':
+                // Get deployment info for an address
+                // params: [address]
+                return this._getCrossChainDeployment(params[0]);
+
+            case 'jaelis_crossChain_getChainDeployments':
+                // Get all deployments to a specific chain
+                // params: [chainId]
+                return this._getChainDeployments(params[0]);
+
+            case 'jaelis_crossChain_getExplorerUrl':
+                // Get explorer URL for a deployment
+                // params: [chainId, address]
+                return this._getExplorerUrl(params[0], params[1]);
+
+            case 'jaelis_crossChain_getDeploymentStats':
+                // Get deployment statistics
+                return this._getDeploymentStats();
+
+            // ═══════════════════════════════════════════════════════════════
+            // MULTI-CHAIN SIGNATURE METHODS (Per-chain wallet authorization)
+            // ═══════════════════════════════════════════════════════════════
+
+            case 'jaelis_crossChain_getSigningRequests':
+                // Get signing messages for each target chain
+                // params: [bytecode, targetChains[]]
+                // Returns array of { chainId, message, switchParams } for frontend
+                return this._getMultiChainSigningRequests(params[0], params[1]);
+
+            case 'jaelis_crossChain_deployWithSignatures':
+                // Deploy with per-chain wallet signatures
+                // params: [{ from, bytecode, abi, targetChains, chainSignatures: {chainId: sig} }]
+                return this._deployWithMultiChainSignatures(params[0]);
+
             // ═══════════════════════════════════════════════════════════════
             // CROSS-CHAIN SETTLEMENT METHODS (Universal State Layer!)
             // ═══════════════════════════════════════════════════════════════
@@ -1352,6 +1697,43 @@ class EmbeddedRpcServer {
                 // Get cross-chain stats
                 return this._getCrossChainStats();
 
+            // ═══════════════════════════════════════════════════════════════
+            // MCP SHORTHAND ALIASES (crosschain_* → jaelis_crossChain_*)
+            // Unified RPC - same methods, shorter names for AI agents
+            // ═══════════════════════════════════════════════════════════════
+            case 'crosschain_getChains':
+                return this._handleMethod('jaelis_crossChain_getChains', params);
+            case 'crosschain_getChainInfo':
+                return this._handleMethod('jaelis_crossChain_getChainInfo', params);
+            case 'crosschain_readState':
+                return this._handleMethod('jaelis_crossChain_readState', params);
+            case 'crosschain_settleState':
+                return this._handleMethod('jaelis_crossChain_settleState', params);
+            case 'crosschain_getStateDiff':
+                return this._handleMethod('jaelis_crossChain_getStateDiff', params);
+            case 'crosschain_computeSlot':
+                return this._handleMethod('jaelis_crossChain_computeSlot', params);
+            case 'crosschain_getLightClientStatus':
+                return this._handleMethod('jaelis_crossChain_getLightClientStatus', params);
+            case 'crosschain_getSettlements':
+                return this._handleMethod('jaelis_crossChain_getSettlements', params);
+            case 'crosschain_getStats':
+                return this._handleMethod('jaelis_crossChain_getStats', params);
+            case 'crosschain_getDeployment':
+                return this._handleMethod('jaelis_crossChain_getDeployment', params);
+            case 'crosschain_getExplorerUrl':
+                return this._handleMethod('jaelis_crossChain_getExplorerUrl', params);
+            case 'crosschain_getDeploymentStats':
+                return this._handleMethod('jaelis_crossChain_getDeploymentStats', params);
+            case 'crosschain_getSigningRequests':
+                return this._handleMethod('jaelis_crossChain_getSigningRequests', params);
+            case 'crosschain_deployWithSignatures':
+                return this._handleMethod('jaelis_crossChain_deployWithSignatures', params);
+            case 'crosschain_deployUnified':
+                return this._handleMethod('jaelis_deployUnified', params);
+            case 'crosschain_syncState':
+                return this._handleMethod('jaelis_crossChain_settleState', params);
+
             // ═══════════════════════════════════════════════════════════════
             // LAYER 2: SOLANA COMPATIBILITY (PROXIES → jaelis_*)
             // For Rust/SPL developers familiar with Solana RPC
@@ -1574,6 +1956,160 @@ class EmbeddedRpcServer {
         return result.transactionHash || '0x0';
     }
 
+    /**
+     * Get contract bytecode at address
+     *
+     * CRITICAL: This is how block explorers detect contracts!
+     * - Returns bytecode hex string if contract exists
+     * - Returns '0x' if address is an EOA or doesn't exist
+     *
+     * Block explorers use: eth_getCode(address) !== '0x' → it's a contract!
+     */
+    async _getCode(address, blockTag = 'latest') {
+        if (!this.blockchain) return '0x';
+
+        try {
+            // Normalize address
+            const normalizedAddr = address.toLowerCase();
+
+            // Try StateManager first (persistent LevelDB storage)
+            if (this.blockchain.stateManager) {
+                const code = await this.blockchain.stateManager.getCode(normalizedAddr);
+                if (code && code.length > 0) {
+                    // Return as hex string
+                    if (Buffer.isBuffer(code)) {
+                        return '0x' + code.toString('hex');
+                    }
+                    if (typeof code === 'string') {
+                        return code.startsWith('0x') ? code : '0x' + code;
+                    }
+                    return '0x' + Buffer.from(code).toString('hex');
+                }
+            }
+
+            // Try VM Executor
+            if (this.blockchain.vmExecutor?.stateManager) {
+                const code = await this.blockchain.vmExecutor.stateManager.getCode(normalizedAddr);
+                if (code && code.length > 0) {
+                    if (Buffer.isBuffer(code)) {
+                        return '0x' + code.toString('hex');
+                    }
+                    return code.startsWith('0x') ? code : '0x' + code;
+                }
+            }
+
+            // Try UnifiedVM contracts
+            if (this.blockchain.unifiedVM?.contractManager) {
+                const contract = this.blockchain.unifiedVM.contractManager.contracts.get(normalizedAddr);
+                if (contract?.bytecode) {
+                    if (Buffer.isBuffer(contract.bytecode)) {
+                        return '0x' + contract.bytecode.toString('hex');
+                    }
+                    return contract.bytecode.startsWith('0x') ? contract.bytecode : '0x' + contract.bytecode;
+                }
+            }
+
+            // Try contracts Map directly
+            if (this.blockchain.contracts) {
+                const contract = this.blockchain.contracts.get(normalizedAddr);
+                if (contract?.bytecode) {
+                    if (Buffer.isBuffer(contract.bytecode)) {
+                        return '0x' + contract.bytecode.toString('hex');
+                    }
+                    return contract.bytecode.startsWith('0x') ? contract.bytecode : '0x' + contract.bytecode;
+                }
+            }
+
+            // No bytecode found - it's an EOA or doesn't exist
+            return '0x';
+        } catch (error) {
+            console.error(`[RPC] _getCode error for ${address}:`, error.message);
+            return '0x';
+        }
+    }
+
+    /**
+     * Get account balance
+     */
+    async _getBalance(address, blockTag = 'latest') {
+        if (!this.blockchain) return '0x0';
+
+        try {
+            const normalizedAddr = address.toLowerCase();
+
+            // Try StateManager
+            if (this.blockchain.stateManager) {
+                const account = await this.blockchain.stateManager.getAccount(normalizedAddr);
+                if (account?.balance !== undefined) {
+                    const balance = BigInt(account.balance || 0);
+                    return '0x' + balance.toString(16);
+                }
+            }
+
+            // Default balance (JAELIS has no native token, but return 0)
+            return '0x0';
+        } catch (error) {
+            return '0x0';
+        }
+    }
+
+    /**
+     * Get transaction count (nonce)
+     */
+    async _getTransactionCount(address, blockTag = 'latest') {
+        if (!this.blockchain) return '0x0';
+
+        try {
+            const normalizedAddr = address.toLowerCase();
+
+            // Try StateManager
+            if (this.blockchain.stateManager) {
+                const account = await this.blockchain.stateManager.getAccount(normalizedAddr);
+                if (account?.nonce !== undefined) {
+                    const nonce = BigInt(account.nonce || 0);
+                    return '0x' + nonce.toString(16);
+                }
+            }
+
+            return '0x0';
+        } catch (error) {
+            return '0x0';
+        }
+    }
+
+    /**
+     * Get storage value at slot
+     */
+    async _getStorageAt(address, slot, blockTag = 'latest') {
+        if (!this.blockchain) return '0x' + '0'.repeat(64);
+
+        try {
+            const normalizedAddr = address.toLowerCase();
+
+            // Try StateManager
+            if (this.blockchain.stateManager) {
+                const value = await this.blockchain.stateManager.getStorage(normalizedAddr, slot);
+                if (value !== undefined) {
+                    const bigValue = BigInt(value || 0);
+                    return '0x' + bigValue.toString(16).padStart(64, '0');
+                }
+            }
+
+            // Try VM Executor StateManager
+            if (this.blockchain.vmExecutor?.stateManager) {
+                const value = await this.blockchain.vmExecutor.stateManager.getStorage(normalizedAddr, slot);
+                if (value !== undefined) {
+                    const bigValue = BigInt(value || 0);
+                    return '0x' + bigValue.toString(16).padStart(64, '0');
+                }
+            }
+
+            return '0x' + '0'.repeat(64);
+        } catch (error) {
+            return '0x' + '0'.repeat(64);
+        }
+    }
+
     async _call(callObject) {
         if (!this.blockchain?.vmExecutor) throw new Error('VM not available');
         const result = await this.blockchain.vmExecutor.executeCall(
@@ -1602,13 +2138,17 @@ class EmbeddedRpcServer {
      * Compiles MULTIPLE contracts from MULTIPLE languages into ONE bytecode bundle.
      * All contracts share memory and can call each other DIRECTLY - no bridges!
      *
-     * @param {Object} params - { from, sources: [{ code, language, name }...] }
+     * NOW WITH CROSS-CHAIN PROPAGATION:
+     * - Contracts appear on ETH, SOL, and other block explorers!
+     * - Shadow contracts on external chains proxy to JAELIS
+     *
+     * @param {Object} params - { from, sources: [{ code, language, name }...], targetChains?: number[] }
      */
     async _deployUnified(params) {
         if (!this.blockchain) throw new Error('Blockchain not available');
         if (!this.blockchain.unifiedVM) throw new Error('Unified VM not available');
 
-        const { from, sources } = params;
+        const { from, sources, targetChains } = params;
 
         if (!sources || !Array.isArray(sources) || sources.length === 0) {
             throw new Error('sources array is required for unified deployment');
@@ -1617,13 +2157,95 @@ class EmbeddedRpcServer {
         console.log(`[RPC] Deploying unified bundle with ${sources.length} contracts...`);
         console.log(`[RPC] Languages: ${[...new Set(sources.map(s => s.language))].join(', ')}`);
 
-        // Compile all sources together using the Unified Compiler
-        const compiled = await this.blockchain.unifiedVM.compileBundle(sources);
+        // Default target chains if not specified - ALL 30+ chains we support!
+        const defaultTargetChains = [
+            // EVM Mainnets
+            1,        // Ethereum Mainnet
+            137,      // Polygon PoS
+            42161,    // Arbitrum One
+            42170,    // Arbitrum Nova
+            10,       // OP Mainnet
+            8453,     // Base
+            56,       // BNB Smart Chain
+            43114,    // Avalanche C-Chain
+            250,      // Fantom Opera
+            100,      // Gnosis
+            59144,    // Linea
+            324,      // zkSync Era
+            534352,   // Scroll
+            5000,     // Mantle
+            81457,    // Blast
+
+            // Solana
+            101,      // Solana Mainnet
+
+            // Move chains (using type prefix to differentiate)
+            // Note: Aptos/Sui use same IDs but different networks
+
+            // TON
+            -1,       // TON Mainnet
+
+            // StarkNet (using string identifier due to large chain ID)
+            'starknet-main',  // StarkNet Mainnet
+
+            // Cosmos
+            118,      // Cosmos Hub
+            119,      // Osmosis
+
+            // Bitcoin
+            0         // Bitcoin Mainnet
+        ];
+        const chains = targetChains || defaultTargetChains;
+
+        console.log(`[RPC] Target chains: ${chains.join(', ')}`);
+
+        // Use the new deployUnifiedWithPropagation for cross-chain deployment
+        if (this.blockchain.unifiedVM.deployUnifiedWithPropagation) {
+            const result = await this.blockchain.unifiedVM.deployUnifiedWithPropagation({
+                from,
+                sources,
+                targetChains: chains
+            });
 
-        // Deploy the unified bytecode
+            // Build contracts map for response
+            const contractsMap = {};
+            for (const source of sources) {
+                contractsMap[source.name] = {
+                    address: result.address,
+                    language: source.language,
+                    name: source.name
+                };
+            }
+
+            console.log(`[RPC] Unified bundle deployed at ${result.address}`);
+            console.log(`[RPC] Chain deployments: ${result.deployments?.length || 0}`);
+
+            // Log explorer URLs
+            if (result.explorerUrls) {
+                console.log(`[RPC] Explorer URLs:`);
+                for (const [chainId, url] of Object.entries(result.explorerUrls)) {
+                    console.log(`[RPC]   Chain ${chainId}: ${url}`);
+                }
+            }
+
+            return {
+                address: result.address,
+                bytecode: result.bytecode,
+                abi: result.abi || [],
+                contracts: contractsMap,
+                deployments: result.deployments,
+                explorerUrls: result.explorerUrls,
+                metadata: result.metadata,
+                gasUsed: 0  // ZERO FEES!
+            };
+        }
+
+        // Fallback: original local-only deployment
+        console.log(`[RPC] Fallback: local-only deployment (no cross-chain propagation)`);
+
+        const compiled = await this.blockchain.unifiedVM.compileBundle(sources);
         const address = '0x' + require('crypto').randomBytes(20).toString('hex');
 
-        // Store the unified contract
         if (this.blockchain.contracts) {
             this.blockchain.contracts.set(address, {
                 bytecode: compiled.bytecode,
@@ -1635,15 +2257,10 @@ class EmbeddedRpcServer {
             });
         }
 
-        console.log(`[RPC] Unified bundle deployed at ${address}`);
-        console.log(`[RPC] Bytecode: ${compiled.bytecode?.length || 0} bytes`);
-        console.log(`[RPC] Cross-references: ${compiled.crossReferences?.size || 0}`);
-
-        // Build contracts map for response
         const contractsMap = {};
         for (const source of sources) {
             contractsMap[source.name] = {
-                address: address,  // All share the same bundle address
+                address: address,
                 language: source.language,
                 name: source.name
             };
@@ -1798,6 +2415,131 @@ class EmbeddedRpcServer {
         };
     }
 
+    // ═══════════════════════════════════════════════════════════════
+    // CROSS-CHAIN DEPLOYMENT QUERY IMPLEMENTATIONS
+    // ═══════════════════════════════════════════════════════════════
+
+    _getCrossChainDeployment(address) {
+        if (this.blockchain?.unifiedVM?.deployManager?.getDeployment) {
+            const deployment = this.blockchain.unifiedVM.deployManager.getDeployment(address);
+            if (deployment) {
+                return deployment;
+            }
+        }
+        return { error: 'Deployment not found', address };
+    }
+
+    _getChainDeployments(chainId) {
+        if (this.blockchain?.unifiedVM?.deployManager?.getChainDeployments) {
+            return this.blockchain.unifiedVM.deployManager.getChainDeployments(chainId);
+        }
+        return [];
+    }
+
+    _getExplorerUrl(chainId, address) {
+        if (this.blockchain?.unifiedVM?.deployManager?.getExplorerUrl) {
+            const url = this.blockchain.unifiedVM.deployManager.getExplorerUrl(chainId, address);
+            return { chainId, address, url };
+        }
+        return { chainId, address, url: null, error: 'Deploy manager not available' };
+    }
+
+    _getDeploymentStats() {
+        if (this.blockchain?.unifiedVM?.deployManager?.getStats) {
+            return this.blockchain.unifiedVM.deployManager.getStats();
+        }
+        return {
+            totalDeployments: 0,
+            pendingCount: 0,
+            failedCount: 0,
+            chainStats: {}
+        };
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // MULTI-CHAIN SIGNATURE IMPLEMENTATIONS
+    // For external chains to accept deployments, user signs per-chain
+    // ═══════════════════════════════════════════════════════════════
+
+    /**
+     * Get signing requests for each target chain
+     *
+     * Frontend flow:
+     * 1. Get these messages
+     * 2. For each chain, switch wallet network and sign
+     * 3. Collect all signatures
+     * 4. Call deployWithSignatures
+     */
+    _getMultiChainSigningRequests(bytecode, targetChains) {
+        if (this.blockchain?.unifiedVM?.deployManager?.getMultiChainSigningRequests) {
+            return this.blockchain.unifiedVM.deployManager.getMultiChainSigningRequests(bytecode, targetChains);
+        }
+
+        // Fallback implementation
+        const crypto = require('crypto');
+        const bytecodeHash = crypto.createHash('sha256')
+            .update(bytecode || '')
+            .digest('hex')
+            .substring(0, 16);
+
+        const timestamp = Date.now();
+        const requests = [];
+
+        for (const chainId of (targetChains || [])) {
+            const message = `JAELIS Cross-Chain Deploy Authorization
+
+Chain ID: ${chainId}
+Bytecode Hash: ${bytecodeHash}
+Timestamp: ${timestamp}
+
+I authorize JAELIS to deploy this contract.
+ZERO FEES - No gas cost to me.`;
+
+            requests.push({
+                chainId,
+                message,
+                messageHash: '0x' + crypto.createHash('sha256')
+                    .update(`\x19Ethereum Signed Message:\n${message.length}${message}`)
+                    .digest('hex'),
+                switchParams: { chainId: '0x' + chainId.toString(16) }
+            });
+        }
+
+        return { requests, bytecodeHash, timestamp, totalChains: targetChains?.length || 0 };
+    }
+
+    /**
+     * Deploy with per-chain wallet signatures
+     *
+     * Each chain that needs to recognize the deployment
+     * requires its own signature from the deployer's wallet.
+     */
+    async _deployWithMultiChainSignatures(params) {
+        const { from, bytecode, abi, targetChains, chainSignatures, metadata } = params;
+
+        console.log(`[RPC] Multi-chain signature deployment from ${from}`);
+        console.log(`[RPC] Target chains: ${targetChains?.length || 0}`);
+        console.log(`[RPC] Signatures provided: ${Object.keys(chainSignatures || {}).length}`);
+
+        if (this.blockchain?.unifiedVM?.deployManager?.deployWithMultiChainSignatures) {
+            return await this.blockchain.unifiedVM.deployManager.deployWithMultiChainSignatures({
+                from,
+                bytecode,
+                abi,
+                targetChains,
+                chainSignatures,
+                metadata
+            });
+        }
+
+        // Fallback: regular deployment without chain signatures
+        console.log(`[RPC] Fallback: Deploy manager not available, using standard flow`);
+        return {
+            error: 'Multi-chain signatures not supported',
+            message: 'Deploy manager not initialized'
+        };
+    }
+
     async stop() {
         if (this.server) {
             this.server.close();