jaelis-node 1.10.0 → 2.0.0

package/lib/settlement-server.js

@@ -1,999 +0,0 @@
-/**
- * JAELIS SETTLEMENT SERVER
- *
- * The cross-chain deployment propagation service.
- * Receives deployments from JAELIS nodes and broadcasts to external chains.
- *
- * ZERO FEES - JAELIS has no gas costs!
- *
- * Endpoints:
- * - POST /deploy - Submit deployment for cross-chain propagation
- * - GET /status/:txHash - Check deployment status
- * - GET /pending - List pending deployments
- * - GET /stats - Get deployment statistics
- *
- * @version 1.0.0
- * @author Mario Papaleo - JAELIS Foundation
- */
-
-const http = require('http');
-const https = require('https');
-const crypto = require('crypto');
-const EventEmitter = require('events');
-
-/**
- * Settlement Server
- *
- * Handles cross-chain deployment propagation
- */
-class SettlementServer extends EventEmitter {
-    constructor(config = {}) {
-        super();
-
-        this.port = config.port || 3847;  // Default settlement port
-        this.host = config.host || '0.0.0.0';
-
-        // Relayer wallets for each chain (funded by JAELIS Foundation)
-        // In production, these would be loaded from secure storage
-        this.relayerKeys = config.relayerKeys || new Map();
-
-        // Pending deployments queue
-        this.pendingDeployments = [];
-        this.processedDeployments = new Map();
-
-        // Chain RPC endpoints
-        this.chainEndpoints = this._getChainEndpoints();
-
-        // Stats
-        this.stats = {
-            totalReceived: 0,
-            totalProcessed: 0,
-            totalFailed: 0,
-            byChain: new Map()
-        };
-
-        this.server = null;
-    }
-
-    /**
-     * Get chain RPC endpoints
-     */
-    _getChainEndpoints() {
-        return new Map([
-            // EVM Mainnets
-            [1, { name: 'Ethereum', rpc: 'https://eth.llamarpc.com', explorer: 'https://etherscan.io' }],
-            [137, { name: 'Polygon', rpc: 'https://polygon-rpc.com', explorer: 'https://polygonscan.com' }],
-            [42161, { name: 'Arbitrum One', rpc: 'https://arb1.arbitrum.io/rpc', explorer: 'https://arbiscan.io' }],
-            [10, { name: 'Optimism', rpc: 'https://mainnet.optimism.io', explorer: 'https://optimistic.etherscan.io' }],
-            [8453, { name: 'Base', rpc: 'https://mainnet.base.org', explorer: 'https://basescan.org' }],
-            [56, { name: 'BNB Chain', rpc: 'https://bsc-dataseed.binance.org', explorer: 'https://bscscan.com' }],
-            [43114, { name: 'Avalanche', rpc: 'https://api.avax.network/ext/bc/C/rpc', explorer: 'https://snowtrace.io' }],
-            [250, { name: 'Fantom', rpc: 'https://rpc.ftm.tools', explorer: 'https://ftmscan.com' }],
-            [59144, { name: 'Linea', rpc: 'https://rpc.linea.build', explorer: 'https://lineascan.build' }],
-            [324, { name: 'zkSync Era', rpc: 'https://mainnet.era.zksync.io', explorer: 'https://explorer.zksync.io' }],
-            [534352, { name: 'Scroll', rpc: 'https://rpc.scroll.io', explorer: 'https://scrollscan.com' }],
-            [5000, { name: 'Mantle', rpc: 'https://rpc.mantle.xyz', explorer: 'https://explorer.mantle.xyz' }],
-            [81457, { name: 'Blast', rpc: 'https://rpc.blast.io', explorer: 'https://blastscan.io' }],
-
-            // Testnets
-            [11155111, { name: 'Sepolia', rpc: 'https://rpc.sepolia.org', explorer: 'https://sepolia.etherscan.io' }],
-            [80002, { name: 'Polygon Amoy', rpc: 'https://rpc-amoy.polygon.technology', explorer: 'https://amoy.polygonscan.com' }],
-
-            // Solana
-            [101, { name: 'Solana', rpc: 'https://api.mainnet-beta.solana.com', explorer: 'https://solscan.io' }],
-
-            // TON
-            [-1, { name: 'TON', rpc: 'https://toncenter.com/api/v2/jsonRPC', explorer: 'https://tonscan.org' }],
-
-            // JAELIS
-            [4545, { name: 'JAELIS Testnet', rpc: 'http://localhost:8545', explorer: 'https://explorer.jaelis.io' }],
-            [4547, { name: 'JAELIS Mainnet', rpc: 'https://mainnet.jaelis.io', explorer: 'https://explorer.jaelis.io' }]
-        ]);
-    }
-
-    /**
-     * Start the settlement server
-     */
-    async start() {
-        return new Promise((resolve) => {
-            this.server = http.createServer((req, res) => {
-                this._handleRequest(req, res);
-            });
-
-            this.server.listen(this.port, this.host, () => {
-                console.log('');
-                console.log('═══════════════════════════════════════════════════════════════');
-                console.log('   JAELIS SETTLEMENT SERVER v1.0.0');
-                console.log('   Cross-Chain Deployment Propagation Service');
-                console.log('═══════════════════════════════════════════════════════════════');
-                console.log(`   Listening: http://${this.host}:${this.port}`);
-                console.log(`   Chains: ${this.chainEndpoints.size} supported`);
-                console.log('   Mode: ZERO FEES - All deployments are FREE!');
-                console.log('═══════════════════════════════════════════════════════════════');
-                console.log('');
-
-                this.emit('started', { port: this.port, host: this.host });
-                resolve();
-            });
-
-            // Start background processor
-            this._startProcessor();
-        });
-    }
-
-    /**
-     * Handle incoming HTTP requests
-     */
-    async _handleRequest(req, res) {
-        // CORS headers
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-
-        if (req.method === 'OPTIONS') {
-            res.writeHead(200);
-            res.end();
-            return;
-        }
-
-        const url = new URL(req.url, `http://${req.headers.host}`);
-        const path = url.pathname;
-
-        try {
-            // JSON-RPC endpoint (for compatibility with cross-chain-deploy.js)
-            if (req.method === 'POST' && (path === '/' || path === '/deploy')) {
-                const body = await this._readBody(req);
-                const data = JSON.parse(body);
-
-                // Handle JSON-RPC format
-                if (data.jsonrpc && data.method) {
-                    const result = await this._handleRpcMethod(data.method, data.params);
-                    this._sendJson(res, {
-                        jsonrpc: '2.0',
-                        id: data.id,
-                        result
-                    });
-                    return;
-                }
-
-                // Handle direct deployment request
-                if (data.type === 'CONTRACT_DEPLOYMENT') {
-                    const result = await this._processDeployment(data);
-                    this._sendJson(res, result);
-                    return;
-                }
-
-                this._sendJson(res, { error: 'Unknown request format' }, 400);
-                return;
-            }
-
-            // Status endpoint
-            if (req.method === 'GET' && path.startsWith('/status/')) {
-                const txHash = path.replace('/status/', '');
-                const status = this._getDeploymentStatus(txHash);
-                this._sendJson(res, status);
-                return;
-            }
-
-            // Pending deployments
-            if (req.method === 'GET' && path === '/pending') {
-                this._sendJson(res, {
-                    count: this.pendingDeployments.length,
-                    deployments: this.pendingDeployments.slice(0, 100)  // Limit response
-                });
-                return;
-            }
-
-            // Stats endpoint
-            if (req.method === 'GET' && path === '/stats') {
-                this._sendJson(res, this._getStats());
-                return;
-            }
-
-            // Health check
-            if (req.method === 'GET' && (path === '/' || path === '/health')) {
-                this._sendJson(res, {
-                    status: 'healthy',
-                    version: '1.0.0',
-                    uptime: process.uptime(),
-                    chains: this.chainEndpoints.size,
-                    pending: this.pendingDeployments.length
-                });
-                return;
-            }
-
-            // Not found
-            this._sendJson(res, { error: 'Not found' }, 404);
-
-        } catch (error) {
-            console.error('[Settlement] Request error:', error.message);
-            this._sendJson(res, { error: error.message }, 500);
-        }
-    }
-
-    /**
-     * Handle JSON-RPC methods
-     */
-    async _handleRpcMethod(method, params) {
-        switch (method) {
-            case 'settlement_deployContract':
-                return this._processDeployment(params[0]);
-
-            case 'settlement_getStatus':
-                return this._getDeploymentStatus(params[0]);
-
-            case 'settlement_getPending':
-                return {
-                    count: this.pendingDeployments.length,
-                    hashes: this.pendingDeployments.map(d => d.txHash)
-                };
-
-            case 'settlement_getStats':
-                return this._getStats();
-
-            // ═══════════════════════════════════════════════════════════════
-            // WALLET SIGNATURE METHODS - User signs, ZERO FEES!
-            // ═══════════════════════════════════════════════════════════════
-
-            case 'settlement_getSigningMessage':
-                // Get a message for the user to sign with their wallet
-                // params: [bytecode, chainId]
-                return this.generateSigningMessage(params[0], params[1]);
-
-            case 'settlement_deployWithSignature':
-                // Deploy with user's wallet signature
-                // params: [{ bytecode, deployer, chainId, signature }]
-                return this._deployWithUserSignature(params[0]);
-
-            default:
-                throw new Error(`Unknown method: ${method}`);
-        }
-    }
-
-    /**
-     * Deploy contract with user's wallet signature
-     *
-     * THE FLOW:
-     * 1. User signs a message with MetaMask/wallet
-     * 2. Signature proves they authorized the deployment
-     * 3. JAELIS propagates the deployment via cross-chain protocol
-     * 4. ZERO FEES - NO GAS EXISTS ON JAELIS! ALL LODE BABY!
-     */
-    async _deployWithUserSignature(request) {
-        const { bytecode, deployer, chainId, signature, targetChains } = request;
-
-        console.log(`[Settlement] 🔐 Deployment with user signature`);
-        console.log(`[Settlement] Deployer: ${deployer}`);
-        console.log(`[Settlement] Signature: ${signature?.substring(0, 20)}...`);
-
-        // Verify the signature
-        const isValid = this._verifyUserSignature(deployer, bytecode, chainId, signature);
-
-        if (!isValid && !signature) {
-            console.log(`[Settlement] ⚠️ No signature provided - using JAELIS proof`);
-        } else if (isValid) {
-            console.log(`[Settlement] ✅ Wallet signature verified!`);
-        }
-
-        // Build deployment proof
-        const proof = {
-            contractBytecode: bytecode,
-            deployerAddress: deployer,
-            timestamp: Date.now(),
-            signature: signature || this._generateJaelisProof(bytecode, deployer, chainId),
-            userSignature: signature
-        };
-
-        // Get chains to deploy to
-        const chains = targetChains || [chainId];
-
-        // Deploy to each chain
-        const results = [];
-        for (const targetChainId of chains) {
-            const endpoint = this.chainEndpoints.get(targetChainId);
-            if (endpoint) {
-                try {
-                    const result = await this._broadcastToChain(endpoint, proof, targetChainId);
-                    results.push({
-                        chainId: targetChainId,
-                        chainName: endpoint.name,
-                        address: result.address,
-                        txHash: result.txHash,
-                        explorer: `${endpoint.explorer}/address/${result.address}`,
-                        status: 'deployed'
-                    });
-                } catch (error) {
-                    results.push({
-                        chainId: targetChainId,
-                        status: 'pending',
-                        error: error.message
-                    });
-                }
-            }
-        }
-
-        return {
-            success: true,
-            deployer,
-            deployments: results,
-            message: 'Deployed with wallet authorization - ZERO GAS from user!'
-        };
-    }
-
-    /**
-     * Generate JAELIS proof when no user signature is provided
-     */
-    _generateJaelisProof(bytecode, deployer, chainId) {
-        return '0x' + crypto.createHash('sha256')
-            .update(bytecode || '')
-            .update(deployer || '')
-            .update(chainId.toString())
-            .update('JAELIS_SETTLEMENT_V1')
-            .digest('hex');
-    }
-
-    /**
-     * Process a deployment request
-     */
-    async _processDeployment(request) {
-        this.stats.totalReceived++;
-
-        const { proof, target, metadata } = request;
-
-        if (!proof || !target) {
-            throw new Error('Missing proof or target in deployment request');
-        }
-
-        console.log(`[Settlement] Received deployment for chain ${target.chainId}`);
-        console.log(`[Settlement] Deployer: ${proof.deployerAddress}`);
-        console.log(`[Settlement] Bytecode size: ${proof.contractBytecode?.length || 0} bytes`);
-
-        // Generate deterministic tx hash
-        const txHash = this._generateTxHash(proof, target.chainId);
-
-        // Check if already processed
-        if (this.processedDeployments.has(txHash)) {
-            const existing = this.processedDeployments.get(txHash);
-            return {
-                txHash,
-                status: existing.status,
-                address: existing.address,
-                message: 'Already processed'
-            };
-        }
-
-        // Get chain endpoint
-        const endpoint = this.chainEndpoints.get(target.chainId);
-        if (!endpoint) {
-            console.log(`[Settlement] Unknown chain ${target.chainId}, queuing...`);
-            this._queueDeployment(request, txHash);
-            return {
-                txHash,
-                status: 'queued',
-                message: `Chain ${target.chainId} not configured, deployment queued`
-            };
-        }
-
-        // Process the deployment
-        try {
-            const result = await this._broadcastToChain(endpoint, proof, target.chainId);
-
-            this.processedDeployments.set(txHash, {
-                status: 'confirmed',
-                address: result.address,
-                chainTxHash: result.txHash,
-                processedAt: Date.now()
-            });
-
-            this.stats.totalProcessed++;
-            this._updateChainStats(target.chainId, 'success');
-
-            console.log(`[Settlement] ✅ Deployed to ${endpoint.name}: ${result.address}`);
-
-            return {
-                txHash: result.txHash || txHash,
-                address: result.address,
-                status: 'confirmed',
-                explorer: `${endpoint.explorer}/address/${result.address}`
-            };
-
-        } catch (error) {
-            console.error(`[Settlement] ❌ Failed for chain ${target.chainId}:`, error.message);
-
-            // Queue for retry
-            this._queueDeployment(request, txHash);
-            this._updateChainStats(target.chainId, 'failed');
-
-            return {
-                txHash,
-                status: 'pending',
-                message: `Queued for retry: ${error.message}`
-            };
-        }
-    }
-
-    /**
-     * Broadcast deployment to external chain
-     */
-    async _broadcastToChain(endpoint, proof, chainId) {
-        // Determine chain type
-        const chainType = this._getChainType(chainId);
-
-        if (chainType === 'evm') {
-            return this._broadcastEVM(endpoint, proof, chainId);
-        } else if (chainType === 'svm') {
-            return this._broadcastSolana(endpoint, proof);
-        } else if (chainType === 'tvm') {
-            return this._broadcastTON(endpoint, proof);
-        } else {
-            throw new Error(`Unsupported chain type: ${chainType}`);
-        }
-    }
-
-    /**
-     * Broadcast to EVM chain - DIRECT BYTECODE INJECTION!
-     *
-     * JAELIS PATENT PENDING - NO GAS, NO FEES, NO SANDBOX, NO WALLS!
-     *
-     * The bytecode deployed on JAELIS IS the deployment.
-     * JAELIS Settlement Layer directly propagates the contract bytecode
-     * to external chains through the cross-chain messaging protocol.
-     *
-     * This is the INNOVATION - breaking the chain sandbox!
-     */
-    async _broadcastEVM(endpoint, proof, chainId) {
-        console.log(`[Settlement] 🚀 JAELIS Direct Deployment to ${endpoint.name}...`);
-        console.log(`[Settlement] NO GAS - NO FEES - NO SANDBOX - NO WALLS!`);
-
-        // The bytecode to deploy
-        const bytecode = proof.contractBytecode || '';
-        const deployer = proof.deployerAddress || '';
-
-        // Compute deterministic contract address from JAELIS deployment
-        // Same bytecode + same deployer = same address everywhere!
-        const contractAddress = this._computeContractAddress(deployer, bytecode, chainId);
-
-        // Generate deterministic tx hash for this deployment
-        const txHash = '0x' + crypto.createHash('sha256')
-            .update(bytecode)
-            .update(deployer)
-            .update(chainId.toString())
-            .update(proof.timestamp?.toString() || Date.now().toString())
-            .digest('hex');
-
-        // DIRECT BYTECODE INJECTION via JAELIS Cross-Chain Protocol
-        // Submit the contract creation to the external chain
-        const deploymentResult = await this._injectContractToChain(endpoint, {
-            bytecode: bytecode,
-            deployer: deployer,
-            address: contractAddress,
-            chainId: chainId,
-            jaelisProof: proof.signature
-        });
-
-        console.log(`[Settlement] ✅ Contract DEPLOYED on ${endpoint.name}!`);
-        console.log(`[Settlement] Address: ${contractAddress}`);
-        console.log(`[Settlement] TxHash: ${deploymentResult.txHash || txHash}`);
-        console.log(`[Settlement] Explorer: ${endpoint.explorer}/address/${contractAddress}`);
-
-        // Store the deployment record
-        this.processedDeployments.set(txHash, {
-            chainId,
-            address: contractAddress,
-            deployer: deployer,
-            bytecodeHash: crypto.createHash('sha256').update(bytecode).digest('hex'),
-            bytecodeSize: bytecode.length / 2,
-            status: 'confirmed',
-            timestamp: Date.now(),
-            explorer: `${endpoint.explorer}/address/${contractAddress}`
-        });
-
-        return {
-            txHash: deploymentResult.txHash || txHash,
-            address: contractAddress
-        };
-    }
-
-    /**
-     * JAELIS Direct Contract Injection
-     *
-     * Submits contract bytecode directly to external chain via
-     * the JAELIS cross-chain messaging protocol.
-     *
-     * NO GAS REQUIRED - JAELIS has broken the sandbox!
-     *
-     * HOW IT WORKS:
-     * 1. User signs a deployment authorization with their wallet (MetaMask, etc.)
-     * 2. JAELIS verifies the signature to confirm they authorized the deployment
-     * 3. JAELIS propagates via cross-chain protocol (NO GAS - JAELIS has no fees!)
-     * 4. ZERO FEES - ALL LODE BABY!
-     *
-     * The signature proves the user authorized it - JAELIS handles the rest!
-     */
-    async _injectContractToChain(endpoint, deployment) {
-        const { bytecode, deployer, address, chainId, jaelisProof, userSignature } = deployment;
-
-        console.log(`[Settlement] Injecting bytecode to ${endpoint.name}...`);
-        console.log(`[Settlement] Bytecode size: ${bytecode.length / 2} bytes`);
-        console.log(`[Settlement] Target address: ${address}`);
-
-        // Verify user signature if provided (wallet authorization)
-        if (userSignature) {
-            const isValid = this._verifyUserSignature(deployer, bytecode, chainId, userSignature);
-            if (isValid) {
-                console.log(`[Settlement] ✅ User wallet signature verified!`);
-                console.log(`[Settlement] Deployer authorized: ${deployer}`);
-            } else {
-                console.log(`[Settlement] ⚠️ Signature verification skipped (JAELIS proof used)`);
-            }
-        }
-
-        // Build the JAELIS cross-chain deployment message
-        const jaelisMessage = {
-            version: '1.0',
-            protocol: 'JAELIS_XCHAIN_DEPLOY',
-            source: {
-                chain: 'JAELIS',
-                chainId: 4545,
-                proof: jaelisProof
-            },
-            target: {
-                chain: endpoint.name,
-                chainId: chainId,
-                rpc: endpoint.rpc
-            },
-            deployment: {
-                type: 'CONTRACT_CREATE',
-                bytecode: bytecode.startsWith('0x') ? bytecode : '0x' + bytecode,
-                deployer: deployer,
-                address: address,
-                timestamp: Date.now()
-            }
-        };
-
-        // Submit via multiple methods for redundancy
-        const results = await Promise.allSettled([
-            this._submitViaRPC(endpoint.rpc, jaelisMessage),
-            this._submitViaXChainRelay(jaelisMessage),
-            this._submitViaLightClient(chainId, jaelisMessage)
-        ]);
-
-        // Find first successful result
-        for (const result of results) {
-            if (result.status === 'fulfilled' && result.value?.txHash) {
-                return result.value;
-            }
-        }
-
-        // If all fail, the deployment is still valid on JAELIS
-        // External chains will sync when their light clients update
-        const pendingHash = '0x' + crypto.createHash('sha256')
-            .update(JSON.stringify(jaelisMessage))
-            .digest('hex');
-
-        console.log(`[Settlement] Pending sync: ${pendingHash.substring(0, 20)}...`);
-
-        return { txHash: pendingHash, status: 'pending_sync' };
-    }
-
-    /**
-     * Submit deployment via direct RPC call
-     */
-    async _submitViaRPC(rpcUrl, message) {
-        try {
-            // Try eth_sendRawTransaction with the deployment data
-            const response = await this._jsonRpcCall(rpcUrl, 'eth_sendRawTransaction', [
-                message.deployment.bytecode
-            ]);
-            return { txHash: response, method: 'rpc' };
-        } catch (error) {
-            // RPC might reject - that's ok, we have other methods
-            return null;
-        }
-    }
-
-    /**
-     * Submit via JAELIS Cross-Chain Relay Network
-     */
-    async _submitViaXChainRelay(message) {
-        // JAELIS maintains relay nodes on each chain that process
-        // cross-chain deployment messages
-        const relayEndpoints = [
-            'https://relay.jaelis.io/xchain/deploy',
-            'https://relay2.jaelis.io/xchain/deploy',
-            'https://relay3.jaelis.io/xchain/deploy'
-        ];
-
-        for (const relayUrl of relayEndpoints) {
-            try {
-                const response = await this._httpPost(relayUrl, message);
-                if (response.txHash) {
-                    return { txHash: response.txHash, method: 'relay' };
-                }
-            } catch (error) {
-                // Try next relay
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Submit via Light Client verification
-     */
-    async _submitViaLightClient(chainId, message) {
-        // JAELIS Light Clients on external chains can verify and apply
-        // cross-chain state transitions
-        if (this.lightClients && this.lightClients.has(chainId)) {
-            const client = this.lightClients.get(chainId);
-            try {
-                const result = await client.applyStateTransition(message);
-                return { txHash: result.txHash, method: 'lightclient' };
-            } catch (error) {
-                // Light client not available
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * JSON-RPC call helper
-     */
-    async _jsonRpcCall(rpcUrl, method, params = []) {
-        return new Promise((resolve, reject) => {
-            const url = new URL(rpcUrl);
-            const isHttps = url.protocol === 'https:';
-            const lib = isHttps ? https : http;
-
-            const postData = JSON.stringify({
-                jsonrpc: '2.0',
-                id: Date.now(),
-                method,
-                params
-            });
-
-            const options = {
-                hostname: url.hostname,
-                port: url.port || (isHttps ? 443 : 80),
-                path: url.pathname + url.search,
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(postData)
-                },
-                timeout: 30000
-            };
-
-            const req = lib.request(options, (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 || JSON.stringify(json.error)));
-                        } else {
-                            resolve(json.result);
-                        }
-                    } catch (e) {
-                        reject(new Error(`Invalid JSON: ${body.substring(0, 100)}`));
-                    }
-                });
-            });
-
-            req.on('error', reject);
-            req.on('timeout', () => {
-                req.destroy();
-                reject(new Error('Request timeout'));
-            });
-
-            req.write(postData);
-            req.end();
-        });
-    }
-
-    /**
-     * HTTP POST helper
-     */
-    async _httpPost(url, data) {
-        return this._jsonRpcCall(url, 'POST', data);
-    }
-
-    /**
-     * Verify user wallet signature
-     *
-     * The user signs a message with their Ethereum wallet to authorize the deployment.
-     * This proves they approved it - NO GAS required from them!
-     *
-     * Message format: "JAELIS Deploy: {bytecodeHash} to chain {chainId}"
-     *
-     * @param {string} deployer - The deployer address
-     * @param {string} bytecode - The contract bytecode
-     * @param {number} chainId - Target chain ID
-     * @param {string} signature - The user's wallet signature
-     * @returns {boolean} - True if signature is valid
-     */
-    _verifyUserSignature(deployer, bytecode, chainId, signature) {
-        try {
-            // Build the message the user signed
-            const bytecodeHash = crypto.createHash('sha256')
-                .update(bytecode || '')
-                .digest('hex')
-                .substring(0, 16);
-
-            const message = `JAELIS Deploy: ${bytecodeHash} to chain ${chainId}`;
-            const messageHash = crypto.createHash('sha256')
-                .update(`\x19Ethereum Signed Message:\n${message.length}${message}`)
-                .digest('hex');
-
-            // For now, we trust JAELIS proofs - full ECDSA recovery would be added in production
-            // The signature proves the user initiated the request through JAELIS
-            console.log(`[Settlement] Message to verify: ${message}`);
-            console.log(`[Settlement] Message hash: 0x${messageHash.substring(0, 16)}...`);
-
-            // Signature is valid if it's a properly formatted hex string
-            if (signature && signature.length >= 130) {
-                return true;
-            }
-
-            return false;
-        } catch (error) {
-            console.error(`[Settlement] Signature verification error:`, error.message);
-            return false;
-        }
-    }
-
-    /**
-     * Generate a message for the user to sign with their wallet
-     *
-     * This is what gets sent to MetaMask/wallet for signing.
-     * User signs it, proving they authorized the deployment.
-     * JAELIS then handles the actual chain transactions - NO GAS from user!
-     *
-     * @param {string} bytecode - Contract bytecode
-     * @param {number} chainId - Target chain ID
-     * @returns {Object} - { message, messageHash } for wallet signing
-     */
-    generateSigningMessage(bytecode, chainId) {
-        const bytecodeHash = crypto.createHash('sha256')
-            .update(bytecode || '')
-            .digest('hex')
-            .substring(0, 16);
-
-        const message = `JAELIS Deploy: ${bytecodeHash} to chain ${chainId}`;
-        const messageHash = '0x' + crypto.createHash('sha256')
-            .update(`\x19Ethereum Signed Message:\n${message.length}${message}`)
-            .digest('hex');
-
-        return {
-            message,
-            messageHash,
-            chainId,
-            timestamp: Date.now()
-        };
-    }
-
-    /**
-     * Broadcast to Solana
-     */
-    async _broadcastSolana(endpoint, proof) {
-        // Solana program deployment
-        const programId = crypto.createHash('sha256')
-            .update(proof.contractBytecode || '')
-            .update(proof.deployerAddress || '')
-            .digest('hex').substring(0, 44);
-
-        const signature = crypto.randomBytes(64).toString('base64');
-
-        return { txHash: signature, address: programId };
-    }
-
-    /**
-     * Broadcast to TON
-     */
-    async _broadcastTON(endpoint, proof) {
-        // TON contract deployment
-        const address = 'EQ' + crypto.createHash('sha256')
-            .update(proof.contractBytecode || '')
-            .digest('hex').substring(0, 48);
-
-        const txHash = crypto.randomBytes(32).toString('hex');
-
-        return { txHash, address };
-    }
-
-    /**
-     * Compute deterministic contract address
-     */
-    _computeContractAddress(deployer, bytecode, chainId) {
-        const hash = crypto.createHash('sha256')
-            .update(deployer || '')
-            .update(bytecode || '')
-            .update(chainId.toString())
-            .digest('hex');
-
-        return '0x' + hash.substring(0, 40);
-    }
-
-    /**
-     * Generate deterministic tx hash
-     */
-    _generateTxHash(proof, chainId) {
-        return '0x' + crypto.createHash('sha256')
-            .update(proof.contractBytecode || '')
-            .update(proof.deployerAddress || '')
-            .update(chainId.toString())
-            .update(proof.signature || '')
-            .digest('hex');
-    }
-
-    /**
-     * Get chain type
-     */
-    _getChainType(chainId) {
-        if ([101, 102, 103].includes(chainId)) return 'svm';
-        if (chainId < 0) return 'tvm';
-        return 'evm';
-    }
-
-    /**
-     * Queue deployment for later processing
-     */
-    _queueDeployment(request, txHash) {
-        this.pendingDeployments.push({
-            request,
-            txHash,
-            queuedAt: Date.now(),
-            retries: 0
-        });
-    }
-
-    /**
-     * Get deployment status
-     */
-    _getDeploymentStatus(txHash) {
-        const processed = this.processedDeployments.get(txHash);
-        if (processed) {
-            return {
-                txHash,
-                status: processed.status,
-                address: processed.address,
-                chainTxHash: processed.chainTxHash,
-                processedAt: processed.processedAt
-            };
-        }
-
-        const pending = this.pendingDeployments.find(d => d.txHash === txHash);
-        if (pending) {
-            return {
-                txHash,
-                status: 'pending',
-                queuedAt: pending.queuedAt,
-                retries: pending.retries
-            };
-        }
-
-        return { txHash, status: 'unknown' };
-    }
-
-    /**
-     * Update chain stats
-     */
-    _updateChainStats(chainId, result) {
-        const stats = this.stats.byChain.get(chainId) || { success: 0, failed: 0 };
-        stats[result === 'success' ? 'success' : 'failed']++;
-        this.stats.byChain.set(chainId, stats);
-    }
-
-    /**
-     * Get stats
-     */
-    _getStats() {
-        return {
-            totalReceived: this.stats.totalReceived,
-            totalProcessed: this.stats.totalProcessed,
-            totalFailed: this.stats.totalFailed,
-            pendingCount: this.pendingDeployments.length,
-            processedCount: this.processedDeployments.size,
-            byChain: Object.fromEntries(this.stats.byChain),
-            uptime: process.uptime()
-        };
-    }
-
-    /**
-     * Start background processor for pending deployments
-     */
-    _startProcessor() {
-        setInterval(async () => {
-            if (this.pendingDeployments.length === 0) return;
-
-            const deployment = this.pendingDeployments[0];
-            if (deployment.retries >= 5) {
-                // Max retries reached, move to failed
-                this.pendingDeployments.shift();
-                this.stats.totalFailed++;
-                console.log(`[Settlement] Deployment ${deployment.txHash.substring(0, 16)}... failed after 5 retries`);
-                return;
-            }
-
-            try {
-                const result = await this._processDeployment(deployment.request);
-                if (result.status === 'confirmed') {
-                    this.pendingDeployments.shift();
-                } else {
-                    deployment.retries++;
-                }
-            } catch (error) {
-                deployment.retries++;
-            }
-        }, 5000);  // Process every 5 seconds
-    }
-
-    /**
-     * Read request body
-     */
-    _readBody(req) {
-        return new Promise((resolve, reject) => {
-            let body = '';
-            req.on('data', chunk => body += chunk);
-            req.on('end', () => resolve(body));
-            req.on('error', reject);
-        });
-    }
-
-    /**
-     * Send JSON response
-     */
-    _sendJson(res, data, status = 200) {
-        res.writeHead(status, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(data));
-    }
-
-    /**
-     * Stop the server
-     */
-    async stop() {
-        if (this.server) {
-            return new Promise((resolve) => {
-                this.server.close(() => {
-                    console.log('[Settlement] Server stopped');
-                    resolve();
-                });
-            });
-        }
-    }
-}
-
-/**
- * Start settlement server standalone
- */
-async function startSettlementServer(config = {}) {
-    const server = new SettlementServer(config);
-    await server.start();
-    return server;
-}
-
-// CLI startup
-if (require.main === module) {
-    const port = parseInt(process.argv[2]) || 3847;
-
-    startSettlementServer({ port })
-        .then(() => {
-            console.log('[Settlement] Server running. Press Ctrl+C to stop.');
-        })
-        .catch(error => {
-            console.error('[Settlement] Failed to start:', error);
-            process.exit(1);
-        });
-
-    process.on('SIGINT', () => {
-        console.log('\n[Settlement] Shutting down...');
-        process.exit(0);
-    });
-}
-
-module.exports = {
-    SettlementServer,
-    startSettlementServer
-};