jaelis-node 1.4.1 → 1.7.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
      */
@@ -1042,6 +1097,82 @@ 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) {
+            throw new Error('Invalid block');
+        }
+
+        const expectedNumber = this.chain.length;
+        if (block.number !== expectedNumber) {
+            // Skip if we already have this block or it's out of order
+            if (block.number < expectedNumber) {
+                return { status: 'skipped', reason: 'already_have' };
+            }
+            throw new Error(`Block out of order: expected ${expectedNumber}, got ${block.number}`);
+        }
+
+        // Validate parent hash
+        const parentBlock = this.getLatestBlock();
+        if (block.parentHash && parentBlock.hash && block.parentHash !== parentBlock.hash) {
+            throw new Error('Invalid parent hash - possible chain reorg');
+        }
+
+        // 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
@@ -1125,30 +1256,113 @@ class EmbeddedNetwork {
     }
 
     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()
+                });
+
+                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)
+                    }
+                }, (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); }
+                    });
                 });
 
-                // Simple fetch for block number (keeps node in sync)
-                // Full sync implementation would fetch blocks
+                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 +1386,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 +1457,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 +1510,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',
@@ -1276,11 +1547,18 @@ class EmbeddedRpcServer {
                     vmActive: !!this.blockchain?.vmExecutor
                 };
 
+            case 'jaelis_deploy':
             case 'jaelis_deployContract':
                 // Deploy contract in ANY language!
                 // params: [source, language, options]
                 return this._deployContract(params[0], params[1], params[2] || {});
 
+            case 'jaelis_deployUnified':
+                // THE KEY INNOVATION: Deploy unified contract bundle!
+                // Compile MULTIPLE contracts from MULTIPLE languages into ONE bytecode!
+                // params: [{ from, sources: [{ code, language, name }...] }]
+                return this._deployUnified(params[0]);
+
             case 'jaelis_executeContract':
                 // Execute contract call
                 // params: [to, functionName, args, options]
@@ -1300,6 +1578,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!)
             // ═══════════════════════════════════════════════════════════════
@@ -1345,6 +1662,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
@@ -1567,6 +1921,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(
@@ -1589,6 +2097,150 @@ class EmbeddedRpcServer {
         };
     }
 
+    /**
+     * Deploy unified contract bundle (THE KEY INNOVATION!)
+     *
+     * Compiles MULTIPLE contracts from MULTIPLE languages into ONE bytecode bundle.
+     * All contracts share memory and can call each other DIRECTLY - no bridges!
+     *
+     * 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, targetChains } = params;
+
+        if (!sources || !Array.isArray(sources) || sources.length === 0) {
+            throw new Error('sources array is required for unified deployment');
+        }
+
+        console.log(`[RPC] Deploying unified bundle with ${sources.length} contracts...`);
+        console.log(`[RPC] Languages: ${[...new Set(sources.map(s => s.language))].join(', ')}`);
+
+        // 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
+            });
+
+            // 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');
+
+        if (this.blockchain.contracts) {
+            this.blockchain.contracts.set(address, {
+                bytecode: compiled.bytecode,
+                abi: compiled.abi || [],
+                sources: sources.map(s => s.name),
+                languages: [...new Set(sources.map(s => s.language))],
+                deployedAt: Date.now(),
+                deployer: from
+            });
+        }
+
+        const contractsMap = {};
+        for (const source of sources) {
+            contractsMap[source.name] = {
+                address: address,
+                language: source.language,
+                name: source.name
+            };
+        }
+
+        return {
+            address,
+            bytecode: compiled.bytecode?.toString('hex'),
+            abi: compiled.abi || [],
+            contracts: contractsMap,
+            metadata: compiled.metadata,
+            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);
@@ -1728,6 +2380,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();