jaelis-node 1.10.0 → 2.1.0

package/lib/index.js

@@ -1,2863 +1,54 @@
 /**
- * JAELIS Node Library
- * Core node implementation for the JAELIS blockchain
+ * JAELIS External Node
  *
- * This module provides the JaelisNode class which wraps the core blockchain
- * implementation for easy deployment as a standalone node.
+ * A lightweight node that connects to the JAELIS network, syncs blocks,
+ * and exposes local RPC for dApps. Like running geth light mode.
  *
- * ═══════════════════════════════════════════════════════════════════════════════
- * RPC ARCHITECTURE (v1.4.0+)
- * ═══════════════════════════════════════════════════════════════════════════════
+ * Architecture:
+ * - WebSocket connection to JAELIS main network
+ * - Local LevelDB for block/state storage
+ * - JSON-RPC server for local dApp access
+ * - NO internal JAELIS code - just network protocol
  *
- * LAYER 1 - NATIVE JAELIS (PRIMARY):
- *   jaelis_*   Native JAELIS methods - rich responses, zero-gas semantics
- *
- * LAYER 2 - COMPATIBILITY (PROXIES):
- *   eth_*      Ethereum JSON-RPC compat (MetaMask, ethers.js, web3.js)
- *   solana_*   Solana-compatible methods (Rust/SPL developers)
- *   move_*     Move-compatible methods (Aptos/Sui developers)
- *   ton_*      TON-compatible methods (FunC/Telegram developers)
- *
- * All compatibility methods PROXY to native jaelis_* implementations.
- * This follows Solana/Cosmos/Polkadot patterns for multi-ecosystem support.
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * @version 1.9.0
- * @author JAELIS Foundation
- */
-
-const path = require('path');
-const fs = require('fs');
-const crypto = require('crypto');
-const EventEmitter = require('events');
-
-// ═══════════════════════════════════════════════════════════════════════════
-// MULTI-CHAIN ADDRESS UTILITIES
-// Supports: EVM (0x...), Solana (base58), Bitcoin (P2PKH/bech32), etc.
-// JAELIS accepts ANY chain's address format - TRUE multi-chain!
-// ═══════════════════════════════════════════════════════════════════════════
-
-const ADDRESS_FORMATS = {
-    // EVM chains (Ethereum, Polygon, Arbitrum, etc.)
-    evm: {
-        pattern: /^0x[a-fA-F0-9]{40}$/,
-        name: 'EVM (Ethereum, Polygon, etc.)',
-        example: '0x742d35Cc6634C0532925a3b844Bc9e7595f...'
-    },
-    // Solana (base58)
-    solana: {
-        pattern: /^[1-9A-HJ-NP-Za-km-z]{32,44}$/,
-        name: 'Solana',
-        example: '7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZ...'
-    },
-    // Bitcoin P2PKH (starts with 1 or 3)
-    bitcoin_legacy: {
-        pattern: /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/,
-        name: 'Bitcoin (Legacy)',
-        example: '1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2'
-    },
-    // Bitcoin bech32 (starts with bc1)
-    bitcoin_bech32: {
-        pattern: /^bc1[a-z0-9]{39,59}$/,
-        name: 'Bitcoin (SegWit)',
-        example: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq'
-    },
-    // TON (base64url)
-    ton: {
-        pattern: /^[A-Za-z0-9_-]{48}$/,
-        name: 'TON',
-        example: 'EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N'
-    },
-    // Aptos/Sui (hex with 0x, 64 chars)
-    move: {
-        pattern: /^0x[a-fA-F0-9]{64}$/,
-        name: 'Move (Aptos/Sui)',
-        example: '0x1234567890abcdef...'
-    },
-    // JAELIS native (same as EVM for now, but could be extended)
-    jaelis: {
-        pattern: /^0x[a-fA-F0-9]{40}$/,
-        name: 'JAELIS Native',
-        example: '0x742d35Cc6634C0532925a3b844Bc9e7595f...'
-    }
-};
-
-/**
- * Detect the chain type from an address
- */
-function detectAddressType(address) {
-    if (!address || typeof address !== 'string') {
-        return null;
-    }
-
-    // Check each format
-    for (const [type, config] of Object.entries(ADDRESS_FORMATS)) {
-        if (config.pattern.test(address)) {
-            return { type, ...config };
-        }
-    }
-
-    return null;
-}
-
-/**
- * Validate any chain address
+ * @version 2.0.0
+ * @license MIT
  */
-function validateAddress(address) {
-    const detected = detectAddressType(address);
-    if (!detected) {
-        return {
-            valid: false,
-            error: 'Unknown address format',
-            supportedFormats: Object.keys(ADDRESS_FORMATS)
-        };
-    }
-    return {
-        valid: true,
-        type: detected.type,
-        name: detected.name
-    };
-}
-
-/**
- * Convert any address to canonical form for internal storage
- * EVM addresses are lowercased, others kept as-is
- */
-function toCanonicalAddress(address) {
-    const detected = detectAddressType(address);
-    if (!detected) {
-        throw new Error('Invalid address format');
-    }
-
-    // EVM addresses are case-insensitive, normalize to lowercase
-    if (detected.type === 'evm' || detected.type === 'jaelis') {
-        return address.toLowerCase();
-    }
-
-    // Other formats are case-sensitive
-    return address;
-}
 
-// ═══════════════════════════════════════════════════════════════════════════
-// NODE WALLET CONFIGURATION (Like Geth --suggested-fee-recipient)
-// Stores the node operator's wallet for receiving rewards
-// NO STAKING REQUIRED - JAELIS doesn't hold your funds!
-// ═══════════════════════════════════════════════════════════════════════════
-
-class NodeWalletConfig {
-    constructor(dataDir) {
-        this.dataDir = dataDir;
-        this.configPath = path.join(dataDir, 'node-wallet.json');
-        this.config = null;
-    }
-
-    /**
-     * Load wallet configuration from disk
-     */
-    load() {
-        try {
-            if (fs.existsSync(this.configPath)) {
-                const data = fs.readFileSync(this.configPath, 'utf8');
-                this.config = JSON.parse(data);
-                return this.config;
-            }
-        } catch (e) {
-            console.warn('[WALLET] Failed to load wallet config:', e.message);
-        }
-        return null;
-    }
-
-    /**
-     * Save wallet configuration to disk
-     */
-    save() {
-        try {
-            // Ensure directory exists
-            if (!fs.existsSync(this.dataDir)) {
-                fs.mkdirSync(this.dataDir, { recursive: true });
-            }
-            fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
-            return true;
-        } catch (e) {
-            console.error('[WALLET] Failed to save wallet config:', e.message);
-            return false;
-        }
-    }
-
-    /**
-     * Set the reward recipient wallet (ANY chain address!)
-     * Like Geth's --suggested-fee-recipient
-     */
-    setRewardRecipient(address) {
-        const validation = validateAddress(address);
-        if (!validation.valid) {
-            throw new Error(`Invalid address: ${validation.error}`);
-        }
-
-        if (!this.config) {
-            this.config = { createdAt: Date.now() };
-        }
-
-        this.config.rewardRecipient = {
-            address: toCanonicalAddress(address),
-            originalFormat: address,
-            type: validation.type,
-            typeName: validation.name,
-            setAt: Date.now()
-        };
-
-        this.save();
-        console.log(`[WALLET] Reward recipient set: ${address} (${validation.name})`);
-        return this.config.rewardRecipient;
-    }
-
-    /**
-     * Get the reward recipient address
-     */
-    getRewardRecipient() {
-        if (!this.config) this.load();
-        return this.config?.rewardRecipient || null;
-    }
-
-    /**
-     * Add an additional wallet (for multi-wallet nodes)
-     */
-    addWallet(name, address, options = {}) {
-        const validation = validateAddress(address);
-        if (!validation.valid) {
-            throw new Error(`Invalid address: ${validation.error}`);
-        }
-
-        if (!this.config) {
-            this.config = { createdAt: Date.now() };
-        }
-
-        if (!this.config.wallets) {
-            this.config.wallets = [];
-        }
-
-        // Check for duplicates
-        const existing = this.config.wallets.find(w =>
-            toCanonicalAddress(w.address) === toCanonicalAddress(address)
-        );
-        if (existing) {
-            throw new Error(`Wallet already exists: ${existing.name}`);
-        }
-
-        const wallet = {
-            name,
-            address: toCanonicalAddress(address),
-            originalFormat: address,
-            type: validation.type,
-            typeName: validation.name,
-            purpose: options.purpose || 'general',
-            addedAt: Date.now()
-        };
-
-        this.config.wallets.push(wallet);
-        this.save();
-        console.log(`[WALLET] Added wallet: ${name} (${validation.name})`);
-        return wallet;
-    }
-
-    /**
-     * Remove a wallet by name or address
-     */
-    removeWallet(nameOrAddress) {
-        if (!this.config?.wallets) {
-            throw new Error('No wallets configured');
-        }
-
-        const canonical = nameOrAddress.startsWith('0x') || nameOrAddress.startsWith('bc1')
-            ? toCanonicalAddress(nameOrAddress)
-            : null;
-
-        const index = this.config.wallets.findIndex(w =>
-            w.name === nameOrAddress ||
-            (canonical && toCanonicalAddress(w.address) === canonical)
-        );
-
-        if (index === -1) {
-            throw new Error(`Wallet not found: ${nameOrAddress}`);
-        }
-
-        const removed = this.config.wallets.splice(index, 1)[0];
-        this.save();
-        console.log(`[WALLET] Removed wallet: ${removed.name}`);
-        return removed;
-    }
-
-    /**
-     * List all configured wallets
-     */
-    listWallets() {
-        if (!this.config) this.load();
-        return {
-            rewardRecipient: this.config?.rewardRecipient || null,
-            wallets: this.config?.wallets || []
-        };
-    }
-
-    /**
-     * Get node identity (generates one if not exists)
-     * Like Solana's identity keypair
-     */
-    getNodeIdentity() {
-        if (!this.config) this.load();
-        if (!this.config) {
-            this.config = { createdAt: Date.now() };
-        }
-
-        if (!this.config.nodeIdentity) {
-            // Generate a node identity (not a wallet, just an ID)
-            const nodeId = crypto.randomBytes(32).toString('hex');
-            this.config.nodeIdentity = {
-                id: nodeId,
-                publicKey: '0x' + crypto.createHash('sha256').update(nodeId).digest('hex').slice(0, 40),
-                createdAt: Date.now()
-            };
-            this.save();
-            console.log(`[WALLET] Generated node identity: ${this.config.nodeIdentity.publicKey}`);
-        }
-
-        return this.config.nodeIdentity;
-    }
+'use strict';
 
-    /**
-     * Get full configuration
-     */
-    getConfig() {
-        if (!this.config) this.load();
-        return this.config;
-    }
-}
+const { JaelisNode } = require('./node');
+const { SyncManager } = require('./sync');
+const { RPCServer } = require('./rpc');
+const { Storage } = require('./storage');
 
-// JAELIS Network Endpoints - users connect here automatically
-// Bootstrap nodes use libp2p multiaddr format: /dns4/host/tcp/port/p2p/PEER_ID
-// External nodes connect via DNS which resolves to the main node's public IP
-//
-// IMPORTANT: Peer ID is required for libp2p dialing!
-// The peer ID is generated on first run and persisted to disk.
-// Main node logs bootstrap info on startup - update this when it changes.
-const JAELIS_NETWORKS = {
+// Network configurations (public endpoints only)
+const NETWORKS = Object.freeze({
     testnet: {
         name: 'JAELIS Testnet',
         chainId: 4545,
         symbol: 'tJAELIS',
-        rpcUrl: 'https://rpc.jaelis.io',
-        wsUrl: 'wss://rpc.jaelis.io/ws',
-        explorerUrl: 'https://explorer.jaelis.io',
-        // Testnet uses port 30304 (mainnet uses 30303)
-        // Peer ID will be added after main node first run
-        // For now, P2P will fallback to RPC sync until peer ID is configured
-        bootstrapNodes: [
-            // Format: /dns4/rpc.jaelis.io/tcp/30304/p2p/PEER_ID
-            // The main node outputs this on startup - update here when available
-        ]
+        rpcEndpoint: 'https://rpc.jaelis.io',
+        wsEndpoint: 'wss://rpc.jaelis.io/ws',
+        explorerUrl: 'https://explorer.jaelis.io'
     },
     mainnet: {
         name: 'JAELIS Mainnet',
         chainId: 4547,
         symbol: 'JAELIS',
-        rpcUrl: 'https://mainnet.jaelis.io',
-        wsUrl: 'wss://mainnet.jaelis.io/ws',
-        explorerUrl: 'https://explorer.jaelis.io',
-        bootstrapNodes: [],
-        status: 'coming-soon'
-    }
-};
-
-/**
- * JaelisNode - Main node class for running a JAELIS blockchain node
- */
-class JaelisNode extends EventEmitter {
-    constructor(options = {}) {
-        super();
-
-        // Get network config - defaults to testnet
-        const networkName = options.network || 'testnet';
-        const networkConfig = JAELIS_NETWORKS[networkName] || JAELIS_NETWORKS.testnet;
-
-        this.options = {
-            network: networkName,
-            networkConfig: networkConfig,
-            chainId: networkConfig.chainId,
-            rpcPort: options.rpcPort || 8545,
-            rpcHost: options.rpcHost || '0.0.0.0',
-            p2pPort: options.p2pPort || 30303,
-            dataDir: options.dataDir || './jaelis-data',
-            syncMode: options.syncMode || 'full',
-            enableRpc: options.enableRpc !== false,
-            enableP2p: options.enableP2p !== false,
-            bootstrapNodes: options.bootstrapNodes || networkConfig.bootstrapNodes,
-            maxPeers: options.maxPeers || 50,
-            // Remote RPC to sync from
-            remoteRpc: options.remoteRpc || networkConfig.rpcUrl,
-            ...options
-        };
-
-        this.blockchain = null;
-        this.network = null;
-        this.rpcServer = null;
-        this.isRunning = false;
-        this.startTime = null;
-        this.peerCount = 0;
-
-        // Initialize wallet configuration (like Geth's keystore)
-        this.walletConfig = new NodeWalletConfig(this.options.dataDir);
-        this.walletConfig.load();
-
-        // Set reward recipient if provided via options (like --suggested-fee-recipient)
-        if (options.rewardRecipient) {
-            this.walletConfig.setRewardRecipient(options.rewardRecipient);
-        }
-    }
-
-    /**
-     * Get the wallet configuration manager
-     */
-    getWalletConfig() {
-        return this.walletConfig;
-    }
-
-    /**
-     * Set the reward recipient address (ANY chain format!)
-     * Like Geth's --suggested-fee-recipient
-     */
-    setRewardRecipient(address) {
-        return this.walletConfig.setRewardRecipient(address);
-    }
-
-    /**
-     * Get the reward recipient address
-     */
-    getRewardRecipient() {
-        return this.walletConfig.getRewardRecipient();
-    }
-
-    /**
-     * Add a wallet to this node
-     */
-    addWallet(name, address, options = {}) {
-        return this.walletConfig.addWallet(name, address, options);
-    }
-
-    /**
-     * Remove a wallet from this node
-     */
-    removeWallet(nameOrAddress) {
-        return this.walletConfig.removeWallet(nameOrAddress);
-    }
-
-    /**
-     * List all configured wallets
-     */
-    listWallets() {
-        return this.walletConfig.listWallets();
-    }
-
-    /**
-     * Get node identity
-     */
-    getNodeIdentity() {
-        return this.walletConfig.getNodeIdentity();
-    }
-
-    /**
-     * Start the node
-     */
-    async start() {
-        if (this.isRunning) {
-            throw new Error('Node is already running');
-        }
-
-        console.log(`[JAELIS] Starting node on ${this.options.network}...`);
-
-        // Ensure data directory exists
-        if (!fs.existsSync(this.options.dataDir)) {
-            fs.mkdirSync(this.options.dataDir, { recursive: true });
-        }
-
-        try {
-            // Try to load from JAELIS core
-            await this._loadCore();
-
-            // Initialize blockchain
-            await this._initBlockchain();
-
-            // Start P2P networking
-            if (this.options.enableP2p) {
-                await this._initNetwork();
-            }
-
-            // Start RPC server
-            if (this.options.enableRpc) {
-                await this._initRpcServer();
-            }
-
-            // Start Settlement Server for cross-chain deployments
-            await this._initSettlementServer();
-
-            this.isRunning = true;
-            this.startTime = Date.now();
-
-            // Register with the JAELIS network for tracking
-            await this._registerWithNetwork();
-
-            // Start heartbeat to keep registration alive
-            this._startHeartbeat();
-
-            this.emit('started', {
-                network: this.options.network,
-                chainId: this.options.chainId,
-                rpcPort: this.options.rpcPort,
-                p2pPort: this.options.p2pPort
-            });
-
-            console.log(`[JAELIS] Node started successfully`);
-
-            // Check for updates (non-blocking)
-            this._checkForUpdates();
-
-        } catch (error) {
-            console.error(`[JAELIS] Failed to start node: ${error.message}`);
-            throw error;
-        }
-    }
-
-    /**
-     * Stop the node
-     */
-    async stop() {
-        if (!this.isRunning) {
-            return;
-        }
-
-        console.log('[JAELIS] Stopping node...');
-
-        // Stop heartbeat first
-        this._stopHeartbeat();
-
-        // Stop Settlement server
-        if (this.settlementServer) {
-            await this._stopSettlementServer();
-        }
-
-        // Stop RPC server
-        if (this.rpcServer) {
-            await this._stopRpcServer();
-        }
-
-        // Stop P2P network
-        if (this.network) {
-            await this._stopNetwork();
-        }
-
-        // Save blockchain state
-        if (this.blockchain) {
-            await this._saveState();
-        }
-
-        this.isRunning = false;
-        this.emit('stopped');
-
-        console.log('[JAELIS] Node stopped');
-    }
-
-    /**
-     * Initialize node modules - connects to JAELIS network
-     */
-    async _loadCore() {
-        console.log(`[JAELIS] Connecting to ${this.options.networkConfig.name}...`);
-        console.log(`[JAELIS] RPC: ${this.options.remoteRpc}`);
-
-        // Use embedded light client that syncs from remote RPC
-        this.JaelisBlockchain = EmbeddedBlockchain;
-        this.JaelisNetwork = EmbeddedNetwork;
-        this.JaelisRpcServer = EmbeddedRpcServer;
-        this.JaelisStorage = EmbeddedStorage;
-    }
-
-    /**
-     * Initialize blockchain
-     */
-    async _initBlockchain() {
-        console.log('[JAELIS] Initializing blockchain...');
-
-        const storagePath = path.join(this.options.dataDir, 'blockchain');
-
-        if (this.JaelisBlockchain) {
-            this.blockchain = new this.JaelisBlockchain({
-                chainId: this.options.chainId,
-                dataDir: storagePath,
-                network: this.options.network
-            });
-
-            if (this.blockchain.initialize) {
-                await this.blockchain.initialize();
-            }
-        }
-
-        console.log(`[JAELIS] Blockchain initialized (Chain ID: ${this.options.chainId})`);
-    }
-
-    /**
-     * Initialize P2P network
-     */
-    async _initNetwork() {
-        console.log('[JAELIS] Initializing P2P network...');
-
-        if (this.JaelisNetwork) {
-            this.network = new this.JaelisNetwork({
-                port: this.options.p2pPort,
-                maxPeers: this.options.maxPeers,
-                bootstrapNodes: this.options.bootstrapNodes,
-                blockchain: this.blockchain,
-                remoteRpc: this.options.remoteRpc
-            });
-
-            if (this.network.start) {
-                await this.network.start();
-            }
-
-            // Track peer count
-            if (this.network.on) {
-                this.network.on('peer:connect', () => {
-                    this.peerCount++;
-                    this.emit('peer:connect', this.peerCount);
-                });
-
-                this.network.on('peer:disconnect', () => {
-                    this.peerCount = Math.max(0, this.peerCount - 1);
-                    this.emit('peer:disconnect', this.peerCount);
-                });
-            }
-        }
-
-        console.log(`[JAELIS] P2P network started on port ${this.options.p2pPort}`);
-    }
-
-    /**
-     * Initialize RPC server
-     */
-    async _initRpcServer() {
-        console.log('[JAELIS] Initializing RPC server...');
-
-        if (this.JaelisRpcServer) {
-            // 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();
-            } else if (this.rpcServer.listen) {
-                await this.rpcServer.listen(this.options.rpcPort, this.options.rpcHost);
-            }
-        }
-
-        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
-     */
-    async _stopRpcServer() {
-        if (this.rpcServer && this.rpcServer.stop) {
-            await this.rpcServer.stop();
-        }
-    }
-
-    /**
-     * Stop P2P network
-     */
-    async _stopNetwork() {
-        if (this.network && this.network.stop) {
-            await this.network.stop();
-        }
-    }
-
-    /**
-     * Save blockchain state
-     */
-    async _saveState() {
-        if (this.blockchain && this.blockchain.save) {
-            await this.blockchain.save();
-        }
-    }
-
-    /**
-     * Register this node with the JAELIS network for tracking
-     * Mario can see all nodes that connect! Lifetime tracking!
-     */
-    async _registerWithNetwork() {
-        try {
-            const https = require('https');
-            const http = require('http');
-
-            const identity = this.walletConfig.getNodeIdentity();
-            const rewardRecipient = this.walletConfig.getRewardRecipient();
-
-            const packageJson = require('../package.json');
-            const nodeInfo = {
-                nodeId: identity.id,
-                publicKey: identity.publicKey,
-                network: this.options.network,
-                chainId: this.options.chainId,
-                version: packageJson.version,
-                rewardAddress: rewardRecipient?.address || null,
-                rewardChainType: rewardRecipient?.type || null,
-                capabilities: ['full-node', 'rpc'],
-                p2pPort: this.options.p2pPort,
-                rpcPort: this.options.rpcPort
-            };
-
-            // Store for heartbeat
-            this._nodeInfo = nodeInfo;
-
-            const data = JSON.stringify({
-                jsonrpc: '2.0',
-                method: 'jaelis_node_register',
-                params: [nodeInfo],
-                id: 1
-            });
-
-            const url = new URL(this.options.remoteRpc);
-            const protocol = url.protocol === 'https:' ? https : http;
-
-            const options = {
-                hostname: url.hostname,
-                port: url.port || (url.protocol === 'https:' ? 443 : 80),
-                path: url.pathname || '/',
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(data),
-                    'User-Agent': `JAELIS-Node/${packageJson.version}`  // Identifies us as a node - gets priority treatment
-                }
-            };
-
-            await new Promise((resolve) => {
-                const req = protocol.request(options, (res) => {
-                    let body = '';
-                    res.on('data', chunk => body += chunk);
-                    res.on('end', () => {
-                        try {
-                            const result = JSON.parse(body);
-                            if (result.result?.registered) {
-                                console.log(`[JAELIS] Node registered with network (ID: ${identity.publicKey.slice(0, 12)}...)`);
-                            }
-                        } catch (e) {
-                            // Silent - registration is best-effort
-                        }
-                        resolve();
-                    });
-                });
-
-                req.on('error', () => resolve()); // Silent fail - will retry on heartbeat
-                req.write(data);
-                req.end();
-            });
-
-        } catch (error) {
-            // Registration is best-effort, don't fail node startup
-            console.log('[JAELIS] Network registration pending (will retry)');
-        }
-    }
-
-    /**
-     * Start heartbeat to keep node registration alive
-     * Sends heartbeat every 60 seconds
-     */
-    _startHeartbeat() {
-        const HEARTBEAT_INTERVAL = 60000; // 60 seconds
-        const packageJson = require('../package.json');
-
-        this._heartbeatInterval = setInterval(async () => {
-            if (!this.isRunning || !this._nodeInfo) return;
-
-            try {
-                const https = require('https');
-                const http = require('http');
-
-                const data = JSON.stringify({
-                    jsonrpc: '2.0',
-                    method: 'jaelis_node_heartbeat',
-                    params: [this._nodeInfo.nodeId],
-                    id: 1
-                });
-
-                const url = new URL(this.options.remoteRpc);
-                const protocol = url.protocol === 'https:' ? https : http;
-
-                const options = {
-                    hostname: url.hostname,
-                    port: url.port || (url.protocol === 'https:' ? 443 : 80),
-                    path: url.pathname || '/',
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Content-Length': Buffer.byteLength(data),
-                        'User-Agent': `JAELIS-Node/${packageJson.version}`  // Identifies us as a node - gets priority treatment
-                    }
-                };
-
-                const req = protocol.request(options, () => {});
-                req.on('error', () => {}); // Silent
-                req.write(data);
-                req.end();
-
-            } catch (e) {
-                // Silent - heartbeat is best-effort
-            }
-        }, HEARTBEAT_INTERVAL);
-
-        console.log('[JAELIS] Heartbeat started (60s interval)');
-    }
-
-    /**
-     * Check for updates from npm registry
-     * Non-blocking - just notifies if a new version is available
-     */
-    async _checkForUpdates() {
-        try {
-            const https = require('https');
-            const packageJson = require('../package.json');
-            const currentVersion = packageJson.version;
-
-            const options = {
-                hostname: 'registry.npmjs.org',
-                path: '/jaelis-node/latest',
-                method: 'GET',
-                headers: {
-                    'Accept': 'application/json',
-                    'User-Agent': `JAELIS-Node/${currentVersion}`
-                },
-                timeout: 5000
-            };
-
-            const req = https.request(options, (res) => {
-                let body = '';
-                res.on('data', chunk => body += chunk);
-                res.on('end', () => {
-                    try {
-                        const data = JSON.parse(body);
-                        const latestVersion = data.version;
-
-                        if (latestVersion && this._isNewerVersion(currentVersion, latestVersion)) {
-                            console.log('');
-                            console.log('╔════════════════════════════════════════════════════════════════╗');
-                            console.log('║  📦 UPDATE AVAILABLE                                           ║');
-                            console.log('╠════════════════════════════════════════════════════════════════╣');
-                            console.log(`║  Current: v${currentVersion.padEnd(10)} → Latest: v${latestVersion.padEnd(20)}║`);
-                            console.log('║                                                                ║');
-                            console.log('║  Run: npm update -g jaelis-node                                ║');
-                            console.log('║  Or:  npx jaelis-node@latest start                             ║');
-                            console.log('╚════════════════════════════════════════════════════════════════╝');
-                            console.log('');
-                        }
-                    } catch (e) {
-                        // Silent - update check is best-effort
-                    }
-                });
-            });
-
-            req.on('error', () => {}); // Silent fail
-            req.on('timeout', () => req.destroy());
-            req.end();
-
-        } catch (error) {
-            // Update check is non-critical, fail silently
-        }
-    }
-
-    /**
-     * Compare semver versions
-     * @returns true if latest > current
-     */
-    _isNewerVersion(current, latest) {
-        const currentParts = current.split('.').map(Number);
-        const latestParts = latest.split('.').map(Number);
-
-        for (let i = 0; i < 3; i++) {
-            const c = currentParts[i] || 0;
-            const l = latestParts[i] || 0;
-            if (l > c) return true;
-            if (l < c) return false;
-        }
-        return false;
-    }
-
-    /**
-     * Stop heartbeat
-     */
-    _stopHeartbeat() {
-        if (this._heartbeatInterval) {
-            clearInterval(this._heartbeatInterval);
-            this._heartbeatInterval = null;
-        }
-    }
-
-    /**
-     * Get node status
-     */
-    getStatus() {
-        const packageJson = require('../package.json');
-        const uptimeMs = this.startTime ? Date.now() - this.startTime : 0;
-
-        return {
-            healthy: this.isRunning,
-            running: this.isRunning,
-            version: packageJson.version,
-            network: this.options.network,
-            chainId: this.options.chainId,
-            uptime: uptimeMs,
-            uptimeHuman: this._formatUptime(uptimeMs),
-            peers: this.peerCount,
-            rpcPort: this.options.rpcPort,
-            p2pPort: this.options.p2pPort,
-            syncMode: this.options.syncMode,
-            blockHeight: this.blockchain?.getHeight?.() || 0,
-            nodeId: this._nodeInfo?.nodeId?.slice(0, 16) + '...' || null
-        };
-    }
-
-    /**
-     * Format uptime in human readable format
-     */
-    _formatUptime(ms) {
-        const seconds = Math.floor(ms / 1000);
-        const minutes = Math.floor(seconds / 60);
-        const hours = Math.floor(minutes / 60);
-        const days = Math.floor(hours / 24);
-
-        if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
-        if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-        if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
-        return `${seconds}s`;
-    }
-}
-
-/**
- * BootstrapNode - Lightweight node for peer discovery
- */
-class BootstrapNode extends EventEmitter {
-    constructor(options = {}) {
-        super();
-        this.port = options.port || 30305;
-        this.network = options.network || 'testnet';
-        this.peers = new Map();
-        this.server = null;
-    }
-
-    async start() {
-        console.log(`[BOOTSTRAP] Starting on port ${this.port}...`);
-
-        // Simple TCP server for peer discovery
-        const net = require('net');
-
-        this.server = net.createServer((socket) => {
-            const peerId = `${socket.remoteAddress}:${socket.remotePort}`;
-            this.peers.set(peerId, { socket, connectedAt: Date.now() });
-
-            console.log(`[BOOTSTRAP] Peer connected: ${peerId} (${this.peers.size} total)`);
-
-            socket.on('data', (data) => {
-                // Handle peer discovery requests
-                try {
-                    const msg = JSON.parse(data.toString());
-                    if (msg.type === 'getPeers') {
-                        const peerList = Array.from(this.peers.keys());
-                        socket.write(JSON.stringify({ type: 'peers', peers: peerList }));
-                    }
-                } catch (e) {
-                    // Ignore invalid messages
-                }
-            });
-
-            socket.on('close', () => {
-                this.peers.delete(peerId);
-                console.log(`[BOOTSTRAP] Peer disconnected: ${peerId} (${this.peers.size} remaining)`);
-            });
-
-            socket.on('error', () => {
-                this.peers.delete(peerId);
-            });
-        });
-
-        return new Promise((resolve, reject) => {
-            this.server.listen(this.port, '0.0.0.0', () => {
-                console.log(`[BOOTSTRAP] Listening on port ${this.port}`);
-                resolve();
-            });
-
-            this.server.on('error', reject);
-        });
-    }
-
-    async stop() {
-        if (this.server) {
-            this.server.close();
-        }
-    }
-
-    getPeerCount() {
-        return this.peers.size;
-    }
-}
-
-// ============================================================
-// EMBEDDED IMPLEMENTATIONS WITH UNIFIED VM
-// ============================================================
-
-// Import VM Executor (UnifiedJaelisVM integration)
-let VMExecutor;
-try {
-    VMExecutor = require('./vm').VMExecutor;
-} catch (e) {
-    console.log('[JAELIS] VM module not loaded - running in light mode');
-}
-
-class EmbeddedBlockchain {
-    constructor(options = {}) {
-        this.chainId = options.chainId || 4545;
-        this.chain = [];
-        this.state = new Map();
-        this.pendingTransactions = [];
-
-        // Initialize VM Executor (UnifiedJaelisVM - NO BRIDGES!)
-        this.vmExecutor = null;
-    }
-
-    async initialize() {
-        // Create genesis block if needed
-        if (this.chain.length === 0) {
-            this.chain.push({
-                number: 0,
-                hash: '0x' + '0'.repeat(64),
-                parentHash: '0x' + '0'.repeat(64),
-                timestamp: Date.now(),
-                transactions: [],
-                stateRoot: '0x' + '0'.repeat(64)
-            });
-        }
-
-        // Initialize the Unified VM
-        if (VMExecutor) {
-            this.vmExecutor = new VMExecutor(this, {
-                debug: false
-            });
-            console.log('[BLOCKCHAIN] Unified VM initialized - TRUE cross-chain interop!');
-        }
-    }
-
-    getHeight() {
-        return this.chain.length - 1;
-    }
-
-    getLatestBlock() {
-        return this.chain[this.chain.length - 1];
-    }
-
-    getBlock(numberOrHash) {
-        if (typeof numberOrHash === 'number') {
-            return this.chain[numberOrHash];
-        }
-        return this.chain.find(b => b.hash === numberOrHash);
-    }
-
-    /**
-     * Deploy a smart contract (ANY language!)
-     */
-    async deployContract(source, language, options = {}) {
-        if (!this.vmExecutor) {
-            throw new Error('VM not available - initialize blockchain first');
-        }
-        return this.vmExecutor.deployContract(source, language, options);
+        rpcEndpoint: 'https://mainnet.jaelis.io',
+        wsEndpoint: 'wss://mainnet.jaelis.io/ws',
+        explorerUrl: 'https://explorer.jaelis.io'
     }
+});
 
-    /**
-     * Execute a contract call
-     */
-    async executeContract(to, functionName, args = [], options = {}) {
-        if (!this.vmExecutor) {
-            throw new Error('VM not available');
-        }
-        return this.vmExecutor.executeCall(to, functionName, args, options);
-    }
-
-    /**
-     * Cross-contract call (NO BRIDGES!)
-     */
-    async crossContractCall(from, to, functionName, args = []) {
-        if (!this.vmExecutor) {
-            throw new Error('VM not available');
-        }
-        return this.vmExecutor.crossContractCall(from, to, functionName, args);
-    }
-
-    /**
-     * Process a transaction
-     */
-    async processTransaction(tx) {
-        if (this.vmExecutor) {
-            return this.vmExecutor.processTransaction(tx);
-        }
-        // Fallback: just store in pending
-        this.pendingTransactions.push(tx);
-        return { status: 'pending' };
-    }
-
-    /**
-     * Create a new block with pending transactions
-     */
-    async createBlock(validator) {
-        const crypto = require('crypto');
-        const parentBlock = this.getLatestBlock();
-
-        const block = {
-            number: parentBlock.number + 1,
-            hash: null,
-            parentHash: parentBlock.hash,
-            timestamp: Date.now(),
-            validator: validator || '0x0',
-            transactions: [...this.pendingTransactions],
-            stateRoot: this._computeStateRoot(),
-            gasUsed: 0  // ZERO FEES!
-        };
-
-        // Compute block hash
-        block.hash = '0x' + crypto.createHash('sha256')
-            .update(JSON.stringify({
-                number: block.number,
-                parentHash: block.parentHash,
-                timestamp: block.timestamp,
-                stateRoot: block.stateRoot
-            }))
-            .digest('hex');
-
-        // Add to chain
-        this.chain.push(block);
-        this.pendingTransactions = [];
-
-        console.log(`[BLOCKCHAIN] Block #${block.number} created with ${block.transactions.length} txs`);
-
-        return block;
-    }
-
-    _computeStateRoot() {
-        const crypto = require('crypto');
-        const stateData = JSON.stringify(Array.from(this.state.entries()));
-        return '0x' + crypto.createHash('sha256').update(stateData).digest('hex');
-    }
-
-    /**
-     * Get VM stats
-     */
-    getVMStats() {
-        return this.vmExecutor?.getStats?.() || { vmAvailable: false };
-    }
-
-    /**
-     * Get all deployed contracts
-     */
-    getContracts() {
-        return this.vmExecutor?.getAllContracts?.() || [];
-    }
-
-    /**
-     * 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
-    }
-}
-
-class EmbeddedNetwork extends EventEmitter {
-    constructor(options = {}) {
-        super();
-        this.port = options.port || 30303;
-        this.host = options.host || '0.0.0.0';
-        this.maxPeers = options.maxPeers || 50;
-        this.bootstrapNodes = options.bootstrapNodes || [];
-        this.remoteRpc = options.remoteRpc || 'https://rpc.jaelis.io';
-        this.blockchain = options.blockchain;
-
-        this.libp2p = null;
-        this.peers = new Map();
-        this.isP2PConnected = false;
-        this.isRPCFallback = false;
-        this.syncInterval = null;
-    }
-
-    async start() {
-        // ALWAYS start RPC sync first - this is reliable through Cloudflare
-        // P2P is optional/additional for peer discovery
-        console.log(`[NETWORK] Starting RPC sync from ${this.remoteRpc}`);
-        await this._startRPCFallback();
-        this.isRPCFallback = true;
-
-        // Try P2P alongside (optional - for peer discovery when bootstrap nodes available)
-        if (this.bootstrapNodes && this.bootstrapNodes.length > 0) {
-            try {
-                await this._startLibp2p();
-                this.isP2PConnected = true;
-                console.log(`[NETWORK] P2P network also started on port ${this.port}`);
-            } catch (err) {
-                console.log(`[NETWORK] P2P unavailable (${err.message}), continuing with RPC only`);
-            }
-        } else {
-            console.log(`[NETWORK] No bootstrap nodes configured - using RPC sync only`);
-            console.log(`[NETWORK] This is fine! RPC sync is reliable and works through firewalls.`);
-        }
-    }
-
-    async _startLibp2p() {
-        // Dynamic imports for libp2p (ES modules)
-        const { createLibp2p } = await import('libp2p');
-        const { tcp } = await import('@libp2p/tcp');
-        const { noise } = await import('@chainsafe/libp2p-noise');
-        const { yamux } = await import('@chainsafe/libp2p-yamux');
-        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}`]
-            },
-            transports: [tcp()],
-            connectionEncryption: [noise()],
-            streamMuxers: [yamux()],
-            services: {
-                identify: identify()
-            }
-        };
-
-        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();
-            this.peers.set(peerId, { connectedAt: Date.now() });
-            console.log(`[P2P] Peer connected: ${peerId.slice(0, 16)}... (${this.peers.size} total)`);
-        });
-
-        this.libp2p.addEventListener('peer:disconnect', (evt) => {
-            const peerId = evt.detail.toString();
-            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() {
-        // Track sync state
-        this.syncState = {
-            localHeight: 0,
-            remoteHeight: 0,
-            syncing: false,
-            lastSync: null,
-            blocksDownloaded: 0,
-            mode: 'polling'  // 'websocket' or 'polling'
-        };
-
-        // 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 url = new URL(this.remoteRpc);
-                const protocol = url.protocol === 'https:' ? https : http;
-
-                const data = JSON.stringify({
-                    jsonrpc: '2.0',
-                    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),
-                        'User-Agent': 'JAELIS-Node/1.8.0'  // Node sync traffic
-                    }
-                }, (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();
-            });
-        };
-
-        // Fetch and add a specific block
-        const fetchBlock = async (blockNum) => {
-            const blockHex = '0x' + blockNum.toString(16);
-            const block = await rpcCall('jaelis_getBlockByNumber', [blockHex, true]);
-            if (block && this.blockchain?.addBlock) {
-                await this.blockchain.addBlock(block);
-                this.syncState.blocksDownloaded++;
-                return true;
-            }
-            return false;
-        };
-
-        // Sync missing blocks (used for both initial sync and catching up)
-        const syncMissingBlocks = async () => {
-            if (this.syncState.syncing) return;
-            this.syncState.syncing = true;
-
-            try {
-                const remoteHeightHex = await rpcCall('jaelis_blockNumber');
-                this.syncState.remoteHeight = parseInt(remoteHeightHex, 16);
-                this.syncState.localHeight = this.blockchain?.getHeight?.() || 0;
-
-                // Loop until fully synced
-                while (this.syncState.localHeight < this.syncState.remoteHeight) {
-                    const blocksToSync = this.syncState.remoteHeight - this.syncState.localHeight;
-
-                    // Batch size: larger during initial sync, smaller when near tip
-                    const batchSize = blocksToSync > 50 ? 25 : (blocksToSync > 10 ? 10 : blocksToSync);
-
-                    if (blocksToSync > 1) {
-                        console.log(`[SYNC] Syncing ${batchSize} blocks (${this.syncState.localHeight + 1} → ${this.syncState.localHeight + batchSize})`);
-                    }
-
-                    for (let i = 1; i <= batchSize; i++) {
-                        await fetchBlock(this.syncState.localHeight + i);
-                    }
-
-                    this.syncState.localHeight += batchSize;
-
-                    if (batchSize > 1) {
-                        console.log(`[SYNC] Local height: ${this.syncState.localHeight}/${this.syncState.remoteHeight}`);
-                    }
-
-                    // Re-check remote height in case new blocks arrived during sync
-                    const newRemoteHex = await rpcCall('jaelis_blockNumber');
-                    this.syncState.remoteHeight = parseInt(newRemoteHex, 16);
-                }
-
-                this.syncState.lastSync = Date.now();
-                this.emit('sync', this.syncState);
-
-            } catch (err) {
-                console.error('[SYNC] Error:', err.message);
-            } finally {
-                this.syncState.syncing = false;
-            }
-        };
-
-        // ============================================================
-        // WEBSOCKET SUBSCRIPTION (PREFERRED - like Ethereum newHeads)
-        // ============================================================
-        const tryWebSocketSync = async () => {
-            try {
-                const WebSocket = require('ws');
-                const wsUrl = this.remoteRpc.replace('https://', 'wss://').replace('http://', 'ws://') + '/ws';
-
-                console.log(`[SYNC] Trying WebSocket subscription at ${wsUrl}`);
-
-                return new Promise((resolve, reject) => {
-                    const ws = new WebSocket(wsUrl, {
-                        headers: { 'User-Agent': 'JAELIS-Node/1.8.0' }
-                    });
-
-                    const timeout = setTimeout(() => {
-                        ws.close();
-                        reject(new Error('WebSocket connection timeout'));
-                    }, 10000);
-
-                    ws.on('open', () => {
-                        clearTimeout(timeout);
-                        console.log('[SYNC] WebSocket connected! Subscribing to newHeads...');
-
-                        // Subscribe to new block headers
-                        ws.send(JSON.stringify({
-                            jsonrpc: '2.0',
-                            method: 'jaelis_subscribe',
-                            params: ['newHeads'],
-                            id: 1
-                        }));
-
-                        this.syncState.mode = 'websocket';
-                        this.wsConnection = ws;
-                        resolve(true);
-                    });
-
-                    ws.on('message', async (data) => {
-                        try {
-                            const msg = JSON.parse(data.toString());
-
-                            // Subscription confirmation
-                            if (msg.id === 1 && msg.result) {
-                                console.log(`[SYNC] ✓ Subscribed to newHeads (id: ${msg.result})`);
-                                console.log('[SYNC] Listening for new blocks via WebSocket...');
-                                return;
-                            }
-
-                            // New block notification
-                            if (msg.method === 'jaelis_subscription' && msg.params?.result) {
-                                const header = msg.params.result;
-                                const blockNum = typeof header.number === 'string'
-                                    ? parseInt(header.number, 16)
-                                    : header.number;
-
-                                // Fetch and sync the new block
-                                if (blockNum > this.syncState.localHeight) {
-                                    // If we're behind, catch up first
-                                    await syncMissingBlocks();
-                                }
-
-                                this.syncState.remoteHeight = blockNum;
-                                this.emit('newBlock', header);
-                            }
-                        } catch (e) {
-                            // Ignore parse errors
-                        }
-                    });
-
-                    ws.on('error', (err) => {
-                        clearTimeout(timeout);
-                        reject(err);
-                    });
-
-                    ws.on('close', () => {
-                        console.log('[SYNC] WebSocket disconnected, falling back to polling...');
-                        this.syncState.mode = 'polling';
-                        this.wsConnection = null;
-                        // Fall back to polling
-                        startPolling();
-                    });
-                });
-            } catch (err) {
-                // WebSocket module not available or connection failed
-                return false;
-            }
-        };
-
-        // ============================================================
-        // HTTP POLLING FALLBACK (like traditional Geth sync)
-        // ============================================================
-        const SYNCED_INTERVAL = 6000;  // Poll every 6s when synced (2x block time)
-        const CATCHUP_INTERVAL = 500;  // Fast poll during catchup
-
-        const startPolling = () => {
-            if (this.syncInterval) return; // Already polling
-
-            console.log('[SYNC] Using HTTP polling mode');
-            this.syncState.mode = 'polling';
-
-            let pollInterval = CATCHUP_INTERVAL;
-            let lastHeight = 0;
-
-            const poll = async () => {
-                await syncMissingBlocks();
-
-                // Adjust polling speed based on sync status
-                const isSynced = this.syncState.localHeight >= this.syncState.remoteHeight;
-                const heightChanged = this.syncState.remoteHeight !== lastHeight;
-
-                if (isSynced && !heightChanged && pollInterval !== SYNCED_INTERVAL) {
-                    // Synced and no new blocks - slow down
-                    pollInterval = SYNCED_INTERVAL;
-                    clearInterval(this.syncInterval);
-                    this.syncInterval = setInterval(poll, pollInterval);
-                    console.log(`[SYNC] ✓ Synced at block ${this.syncState.localHeight}. Polling every ${pollInterval/1000}s`);
-                } else if (!isSynced && pollInterval !== CATCHUP_INTERVAL) {
-                    // Falling behind - speed up
-                    pollInterval = CATCHUP_INTERVAL;
-                    clearInterval(this.syncInterval);
-                    this.syncInterval = setInterval(poll, pollInterval);
-                }
-
-                lastHeight = this.syncState.remoteHeight;
-            };
-
-            // Start polling
-            this.syncInterval = setInterval(poll, pollInterval);
-        };
-
-        // ============================================================
-        // INITIAL SYNC
-        // ============================================================
-        console.log('[SYNC] Starting sync from', this.remoteRpc);
-
-        // Do initial block sync first
-        await syncMissingBlocks();
-
-        // Try WebSocket first (like Ethereum pub/sub), fall back to polling
-        const wsSuccess = await tryWebSocketSync().catch(() => false);
-
-        if (!wsSuccess) {
-            console.log('[SYNC] WebSocket unavailable, using HTTP polling');
-            startPolling();
-        }
-    }
-
-    async stop() {
-        // Close WebSocket connection if active
-        if (this.wsConnection) {
-            this.wsConnection.close();
-            this.wsConnection = null;
-        }
-        // Stop libp2p if active
-        if (this.libp2p) {
-            await this.libp2p.stop();
-        }
-        // Stop polling interval if active
-        if (this.syncInterval) {
-            clearInterval(this.syncInterval);
-            this.syncInterval = null;
-        }
-    }
-
-    getPeerCount() {
-        return this.peers.size;
-    }
-
-    getConnectionMode() {
-        if (this.isP2PConnected) return 'p2p';
-        if (this.isRPCFallback) return 'rpc-fallback';
-        return 'disconnected';
-    }
-}
-
-class EmbeddedRpcServer {
-    constructor(blockchain, port, network = null) {
-        this.blockchain = blockchain;
-        this.port = port;
-        this.network = network;  // Reference to EmbeddedNetwork for sync status
-        this.app = null;
-    }
-
-    async start() {
-        const express = require('express');
-        const cors = require('cors');
-
-        this.app = express();
-        this.app.use(cors());
-        this.app.use(express.json({ limit: '50mb' }));  // Allow large contract deployments
-
-        // Main RPC endpoint
-        this.app.post('/', async (req, res) => {
-            const { method, params, id } = req.body;
-
-            try {
-                const result = await this._handleMethod(method, params || []);
-                res.json({ jsonrpc: '2.0', id, result });
-            } catch (error) {
-                res.json({
-                    jsonrpc: '2.0',
-                    id,
-                    error: { code: -32000, message: error.message }
-                });
-            }
-        });
-
-        // Health check
-        this.app.get('/', (req, res) => {
-            const vmStats = this.blockchain?.getVMStats?.() || {};
-            res.json({
-                status: 'online',
-                service: 'JAELIS Node',
-                chainId: this.blockchain?.chainId,
-                blockHeight: this.blockchain?.getHeight?.() || 0,
-                vm: {
-                    available: vmStats.vmAvailable || false,
-                    contractsDeployed: vmStats.contractsDeployed || 0,
-                    crossContractCalls: vmStats.crossContractCalls || 0
-                },
-                features: [
-                    'ZERO_FEES',
-                    'UNIFIED_VM',
-                    'NO_BRIDGES',
-                    'CROSS_CHAIN_INTEROP'
-                ]
-            });
-        });
-
-        return new Promise((resolve) => {
-            this.server = this.app.listen(this.port, '0.0.0.0', () => {
-                resolve();
-            });
-        });
-    }
-
-    async _handleMethod(method, params) {
-        switch (method) {
-            // ═══════════════════════════════════════════════════════════════
-            // LAYER 1: NATIVE JAELIS METHODS (PRIMARY)
-            // ═══════════════════════════════════════════════════════════════
-            case 'jaelis_chainId':
-                return '0x' + (this.blockchain?.chainId || 4545).toString(16);
-
-            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_*)
-            // ═══════════════════════════════════════════════════════════════
-            case 'eth_chainId':
-                return this._handleMethod('jaelis_chainId', params);
-
-            case 'eth_blockNumber':
-                return this._handleMethod('jaelis_blockNumber', params);
-
-            case 'eth_getBlockByNumber':
-                const blockNum = parseInt(params[0], 16);
-                return this.blockchain?.getBlock?.(blockNum) || null;
-
-            case 'eth_sendTransaction':
-            case 'eth_sendRawTransaction':
-                return this._sendTransaction(params[0]);
-
-            case 'eth_call':
-                return this._call(params[0], params[1]);
-
-            case 'eth_getTransactionReceipt':
-                return this.blockchain?.vmExecutor?.getReceipt?.(params[0]) || null;
-
-            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',
-                    chainId: this.blockchain?.chainId,
-                    blockHeight: this.blockchain?.getHeight?.() || 0,
-                    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]
-                return this._executeContract(params[0], params[1], params[2] || [], params[3] || {});
-
-            case 'jaelis_crossContractCall':
-                // Cross-contract call (NO BRIDGES!)
-                // params: [fromContract, toContract, functionName, args]
-                return this._crossContractCall(params[0], params[1], params[2], params[3] || []);
-
-            case 'jaelis_getContracts':
-                return this.blockchain?.getContracts?.() || [];
-
-            case 'jaelis_getVMStats':
-                return this.blockchain?.getVMStats?.() || { vmAvailable: false };
-
-            case 'jaelis_getSupportedLanguages':
-                return ['solidity', 'rust', 'move', 'func', 'cairo', 'vyper'];
-
-            // ═══════════════════════════════════════════════════════════════
-            // CROSS-CHAIN 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!)
-            // ═══════════════════════════════════════════════════════════════
-
-            case 'jaelis_crossChain_getChains':
-                // Get all registered chains
-                return this._getCrossChainRegistry();
-
-            case 'jaelis_crossChain_getChainInfo':
-                // Get info for specific chain ID
-                return this._getCrossChainInfo(params[0]);
-
-            case 'jaelis_crossChain_readState':
-                // Read settled state from external chain
-                // params: [chainId, contractAddress, variableName]
-                return this._readCrossChainState(params[0], params[1], params[2]);
-
-            case 'jaelis_crossChain_settleState':
-                // Settle external chain state with proof
-                // params: [chainId, contractAddress, variableName, value, proof]
-                return this._settleCrossChainState(params[0], params[1], params[2], params[3], params[4]);
-
-            case 'jaelis_crossChain_getStateDiff':
-                // Get state diff between two chains
-                // params: [chainId1, chainId2, contractAddress, variableNames]
-                return this._getCrossChainStateDiff(params[0], params[1], params[2], params[3]);
-
-            case 'jaelis_crossChain_computeSlot':
-                // Compute namespaced storage slot
-                // params: [chainId, contractAddress, variableName]
-                return this._computeCrossChainSlot(params[0], params[1], params[2]);
-
-            case 'jaelis_crossChain_getLightClientStatus':
-                // Get light client status for a chain
-                return this._getLightClientStatus(params[0]);
-
-            case 'jaelis_crossChain_getSettlements':
-                // Get all settlements for a contract
-                // params: [chainId, contractAddress]
-                return this._getSettlements(params[0], params[1]);
-
-            case 'jaelis_crossChain_getStats':
-                // Get cross-chain stats
-                return this._getCrossChainStats();
-
-            // ═══════════════════════════════════════════════════════════════
-            // 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
-            // ═══════════════════════════════════════════════════════════════
-            case 'solana_getBalance':
-                // Convert to JAELIS format then back to Solana format
-                const jaelisBalance = await this._handleMethod('jaelis_getBalance', params);
-                return { value: BigInt(jaelisBalance || '0').toString() };
-
-            case 'solana_getHealth':
-                return this._handleMethod('jaelis_getHealth', params);
-
-            case 'solana_getSlot':
-                return this.blockchain?.getHeight?.() || 0;
-
-            case 'solana_getBlockHeight':
-                return this.blockchain?.getHeight?.() || 0;
-
-            case 'solana_getVersion':
-                return { 'solana-core': '1.17.0', 'feature-set': 4545 };
-
-            case 'solana_getLatestBlockhash':
-                const block = this.blockchain?.getLatestBlock?.();
-                return { blockhash: block?.hash || '0x0', lastValidBlockHeight: block?.number || 0 };
-
-            // ═══════════════════════════════════════════════════════════════
-            // LAYER 2: MOVE COMPATIBILITY (PROXIES → jaelis_*)
-            // For Aptos/Sui developers familiar with Move
-            // ═══════════════════════════════════════════════════════════════
-            case 'move_getLedgerInfo':
-                const height = this.blockchain?.getHeight?.() || 0;
-                return {
-                    chain_id: this.blockchain?.chainId || 4545,
-                    ledger_version: height.toString(),
-                    block_height: height.toString()
-                };
-
-            case 'move_getAccountResource':
-                return this._handleMethod('jaelis_getMoveResource', params);
-
-            case 'move_getAccountModule':
-                return this._handleMethod('jaelis_getMoveModule', params);
-
-            // ═══════════════════════════════════════════════════════════════
-            // LAYER 2: TON COMPATIBILITY (PROXIES → jaelis_*)
-            // For FunC/Telegram developers (900M+ users!)
-            // ═══════════════════════════════════════════════════════════════
-            case 'ton_getAddressBalance':
-                const tonBalance = await this._handleMethod('jaelis_getBalance', params);
-                return { balance: tonBalance || '0' };
-
-            case 'ton_getMasterchainInfo':
-                const tonBlock = this.blockchain?.getLatestBlock?.();
-                return {
-                    last: {
-                        workchain: 0,
-                        seqno: tonBlock?.number || 0,
-                        root_hash: tonBlock?.hash || '0x0'
-                    }
-                };
-
-            case 'ton_getAccountState':
-                return this._handleMethod('jaelis_getTonAccount', params);
-
-            case 'ton_runGetMethod':
-                return this._handleMethod('jaelis_callTonMethod', params);
-
-            // ═══════════════════════════════════════════════════════════════
-            // LAYER 2: BITCOIN COMPATIBILITY (PROXIES → jaelis_*)
-            // For Bitcoin developers - familiar Bitcoin Core RPC methods
-            // ═══════════════════════════════════════════════════════════════
-            case 'btc_getbalance':
-                const btcBal = await this._handleMethod('jaelis_getBalance', params);
-                const satoshis = BigInt(btcBal?.jaelis || '0') / BigInt(10 ** 10);
-                return Number(satoshis) / 100000000;
-
-            case 'btc_getblockcount':
-                return this.blockchain?.getHeight?.() || 0;
-
-            case 'btc_getblockhash':
-                const btcBlock = this.blockchain?.getBlock?.(params[0]);
-                return btcBlock?.hash || null;
-
-            case 'btc_getblock':
-                const blk = this.blockchain?.getBlockByHash?.(params[0]);
-                if (!blk) return null;
-                return {
-                    hash: blk.hash,
-                    confirmations: 1,
-                    height: blk.number,
-                    version: 1,
-                    time: blk.timestamp,
-                    tx: blk.transactions?.map(t => t.hash || t) || [],
-                    previousblockhash: blk.parentHash
-                };
-
-            case 'btc_gettransaction':
-                return this._handleMethod('jaelis_getTransactionByHash', params);
-
-            case 'btc_sendrawtransaction':
-                return this._handleMethod('jaelis_sendRawTransaction', params);
-
-            case 'btc_getblockchaininfo':
-                const btcHeight = this.blockchain?.getHeight?.() || 0;
-                return {
-                    chain: (this.blockchain?.chainId || 4545) === 4545 ? 'test' : 'main',
-                    blocks: btcHeight,
-                    headers: btcHeight,
-                    bestblockhash: this.blockchain?.getLatestBlock?.()?.hash,
-                    difficulty: 1,
-                    warnings: 'JAELIS Bitcoin compatibility - zero gas fees!'
-                };
-
-            case 'btc_getnetworkinfo':
-                return {
-                    version: 250000,
-                    subversion: '/JAELIS:1.0.0/',
-                    protocolversion: 70016,
-                    warnings: 'JAELIS Bitcoin compatibility layer'
-                };
-
-            case 'btc_getmempoolinfo':
-                return { loaded: true, size: 0, mempoolminfee: 0 };
-
-            case 'btc_estimatesmartfee':
-                return { feerate: 0, blocks: params[0] || 1 }; // Zero fees!
-
-            // ═══════════════════════════════════════════════════════════════
-            // LAYER 2: WASM COMPATIBILITY (PROXIES → jaelis_*)
-            // For CosmWasm/NEAR/Polkadot WASM developers
-            // ═══════════════════════════════════════════════════════════════
-            case 'wasm_call':
-                return this._handleMethod('jaelis_call', [{ to: params[0], data: JSON.stringify({ method: params[1], args: params[2] }) }]);
-
-            case 'wasm_query':
-                return this._handleMethod('jaelis_call', [{ to: params[0], data: JSON.stringify(params[1]) }]);
-
-            case 'wasm_deploy':
-                return this._handleMethod('jaelis_deployWasmContract', params);
-
-            case 'wasm_instantiate':
-                return this._handleMethod('jaelis_deployWasmContract', [{ codeId: params[0], initMsg: params[1], label: params[2] }]);
-
-            case 'wasm_execute':
-                return this._handleMethod('jaelis_sendTransaction', [{ to: params[0], data: JSON.stringify(params[1]), value: params[2] || '0x0' }]);
-
-            case 'wasm_getCode':
-                return this._handleMethod('jaelis_getCode', params);
-
-            case 'wasm_getContractInfo':
-                const wasmCode = await this._handleMethod('jaelis_getCode', params);
-                return { address: params[0], has_code: wasmCode && wasmCode !== '0x' };
-
-            case 'wasm_getContractState':
-                return this._handleMethod('jaelis_getStorageAt', [params[0], params[1] || '0x0', 'latest']);
-
-            // ═══════════════════════════════════════════════════════════════
-            // LAYER 2: STARKNET/CAIRO COMPATIBILITY (PROXIES → jaelis_*)
-            // For StarkNet/Cairo developers
-            // ═══════════════════════════════════════════════════════════════
-            case 'starknet_chainId':
-                return this._handleMethod('jaelis_chainId', params);
-
-            case 'starknet_blockNumber':
-                return this.blockchain?.getHeight?.() || 0;
-
-            case 'starknet_getBlockWithTxHashes':
-                const snBlock = this.blockchain?.getBlock?.(params[0]?.block_number || 'latest');
-                if (!snBlock) return null;
-                return {
-                    block_hash: snBlock.hash,
-                    parent_hash: snBlock.parentHash,
-                    block_number: snBlock.number,
-                    transactions: snBlock.transactions || [],
-                    status: 'ACCEPTED_ON_L1'
-                };
-
-            case 'starknet_getBlockWithTxs':
-                return this._handleMethod('starknet_getBlockWithTxHashes', params);
-
-            case 'starknet_getTransactionByHash':
-                const snTx = await this._handleMethod('jaelis_getTransactionByHash', params);
-                if (!snTx) return null;
-                return { transaction_hash: snTx.hash, type: 'INVOKE', sender_address: snTx.from };
-
-            case 'starknet_getTransactionReceipt':
-                const snReceipt = await this._handleMethod('jaelis_getTransactionReceipt', params);
-                if (!snReceipt) return null;
-                return {
-                    transaction_hash: snReceipt.transactionHash,
-                    actual_fee: '0x0',
-                    status: snReceipt.status === '0x1' ? 'ACCEPTED_ON_L1' : 'REJECTED'
-                };
-
-            case 'starknet_call':
-                return this._handleMethod('jaelis_call', [{ to: params[0]?.contract_address, data: '0x' }]);
-
-            case 'starknet_estimateFee':
-                return { gas_consumed: '0x0', gas_price: '0x0', overall_fee: '0x0' }; // Zero fees!
-
-            case 'starknet_addInvokeTransaction':
-                return this._handleMethod('jaelis_sendTransaction', [{ from: params[0]?.sender_address, to: params[0]?.calldata?.[0], data: '0x' }]);
-
-            case 'starknet_addDeclareTransaction':
-                return this._handleMethod('jaelis_deploy', [{ data: params[0]?.contract_class, from: params[0]?.sender_address }]);
-
-            case 'starknet_getClass':
-            case 'starknet_getClassAt':
-                const cairoCode = await this._handleMethod('jaelis_getCode', [params[1] || params[0]]);
-                return { program: cairoCode, entry_points_by_type: { CONSTRUCTOR: [], EXTERNAL: [], L1_HANDLER: [] } };
-
-            default:
-                throw new Error(`Method not found: ${method}`);
-        }
-    }
-
-    async _sendTransaction(tx) {
-        if (!this.blockchain) throw new Error('Blockchain not available');
-        const result = await this.blockchain.processTransaction(tx);
-        return result.transactionHash || '0x0';
-    }
-
-    /**
-     * 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(
-            callObject.to,
-            callObject.data?.functionName || 'call',
-            callObject.data?.args || [],
-            { from: callObject.from }
-        );
-        return result.returnValue;
-    }
-
-    async _deployContract(source, language, options) {
-        if (!this.blockchain) throw new Error('Blockchain not available');
-        console.log(`[RPC] Deploying ${language} contract...`);
-        const result = await this.blockchain.deployContract(source, language, options);
-        return {
-            address: result.address,
-            language,
-            gasUsed: 0  // ZERO FEES!
-        };
-    }
-
-    /**
-     * 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);
-    }
-
-    async _crossContractCall(from, to, functionName, args) {
-        if (!this.blockchain) throw new Error('Blockchain not available');
-        console.log(`[RPC] Cross-call: ${from.substring(0, 10)}... → ${to.substring(0, 10)}...::${functionName}`);
-        return this.blockchain.crossContractCall(from, to, functionName, args);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // CROSS-CHAIN SETTLEMENT IMPLEMENTATIONS
-    // ═══════════════════════════════════════════════════════════════
-
-    _getCrossChainRegistry() {
-        // Return the VM's cross-chain registry if available
-        if (this.blockchain?.vmExecutor?.vm?.getAllChains) {
-            return this.blockchain.vmExecutor.vm.getAllChains();
-        }
-        // Fallback: return hardcoded registry
-        return {
-            JAELIS_MAINNET: { id: 4547, name: 'JAELIS Mainnet', type: 'native', status: 'upcoming' },
-            JAELIS_TESTNET: { id: 4545, name: 'JAELIS Testnet', type: 'native', status: 'live' },
-            ETH_MAINNET: { id: 1, name: 'Ethereum Mainnet', type: 'evm' },
-            ETH_SEPOLIA: { id: 11155111, name: 'Ethereum Sepolia', type: 'evm' },
-            POLYGON: { id: 137, name: 'Polygon PoS', type: 'evm' },
-            ARBITRUM_ONE: { id: 42161, name: 'Arbitrum One', type: 'evm' },
-            OPTIMISM: { id: 10, name: 'OP Mainnet', type: 'evm' },
-            BASE: { id: 8453, name: 'Base', type: 'evm' },
-            AVALANCHE_C: { id: 43114, name: 'Avalanche C-Chain', type: 'evm' },
-            BSC: { id: 56, name: 'BNB Smart Chain', type: 'evm' },
-            SOLANA_MAINNET: { id: 101, name: 'Solana Mainnet', type: 'svm', cluster: 'mainnet-beta' },
-            SOLANA_DEVNET: { id: 102, name: 'Solana Devnet', type: 'svm', cluster: 'devnet' },
-            APTOS_MAINNET: { id: 1, name: 'Aptos Mainnet', type: 'move', network: 'aptos' },
-            SUI_MAINNET: { id: 1, name: 'Sui Mainnet', type: 'move', network: 'sui' },
-            TON_MAINNET: { id: -1, name: 'TON Mainnet', type: 'tvm', workchain: -1 }
-        };
-    }
-
-    _getCrossChainInfo(chainId) {
-        const chains = this._getCrossChainRegistry();
-        const chain = Object.values(chains).find(c => c.id === chainId);
-        return chain || { error: 'Chain not found', chainId };
-    }
-
-    async _readCrossChainState(chainId, contractAddress, variableName) {
-        if (this.blockchain?.vmExecutor?.vm?.readCrossChainState) {
-            const value = this.blockchain.vmExecutor.vm.readCrossChainState(chainId, contractAddress, variableName);
-            return {
-                chainId,
-                contractAddress,
-                variableName,
-                value: value ? '0x' + value.toString('hex') : '0x0',
-                settled: value ? true : false
-            };
-        }
-        return { error: 'Cross-chain state not available', chainId, contractAddress, variableName };
-    }
-
-    async _settleCrossChainState(chainId, contractAddress, variableName, value, proof) {
-        if (this.blockchain?.vmExecutor?.vm?.settleExternalState) {
-            const valueBuffer = Buffer.from(value.replace('0x', ''), 'hex');
-            const result = await this.blockchain.vmExecutor.vm.settleExternalState(
-                chainId, contractAddress, variableName, valueBuffer, proof
-            );
-            console.log(`[RPC] Cross-chain settlement: Chain ${chainId} → ${variableName}`);
-            return {
-                success: true,
-                chainId,
-                contractAddress,
-                variableName,
-                slot: result.slot ? '0x' + result.slot.toString('hex') : null,
-                settlement: result.settlement
-            };
-        }
-        return { error: 'Cross-chain settlement not available' };
-    }
-
-    _getCrossChainStateDiff(chainId1, chainId2, contractAddress, variableNames) {
-        if (this.blockchain?.vmExecutor?.vm?.getCrossChainStateDiff) {
-            return this.blockchain.vmExecutor.vm.getCrossChainStateDiff(
-                chainId1, chainId2, contractAddress, variableNames
-            );
-        }
-        return { error: 'State diff not available', chainId1, chainId2 };
-    }
-
-    _computeCrossChainSlot(chainId, contractAddress, variableName) {
-        if (this.blockchain?.vmExecutor?.vm?.computeCrossChainSlot) {
-            const slot = this.blockchain.vmExecutor.vm.computeCrossChainSlot(chainId, contractAddress, variableName);
-            return '0x' + slot.toString('hex');
-        }
-        // Fallback: compute locally
-        const crypto = require('crypto');
-        const data = Buffer.concat([
-            Buffer.alloc(4),  // chainId placeholder
-            Buffer.from(contractAddress.replace('0x', ''), 'hex'),
-            Buffer.from(variableName, 'utf8')
-        ]);
-        data.writeUInt32LE(chainId, 0);
-        return '0x' + crypto.createHash('sha256').update(data).digest('hex');
-    }
-
-    _getLightClientStatus(chainId) {
-        if (this.blockchain?.vmExecutor?.vm?.crossChainManager?.stateStore?.lightClients) {
-            const client = this.blockchain.vmExecutor.vm.crossChainManager.stateStore.lightClients.get(chainId);
-            if (client) {
-                return {
-                    chainId,
-                    synced: client.synced || false,
-                    latestBlock: client.latestBlock || 0,
-                    stateRoot: client.latestStateRoot ? '0x' + client.latestStateRoot.toString('hex') : null
-                };
-            }
-        }
-        return { chainId, synced: false, error: 'Light client not available' };
-    }
-
-    _getSettlements(chainId, contractAddress) {
-        if (this.blockchain?.vmExecutor?.vm?.crossChainManager?.stateStore?.settlementLog) {
-            const log = this.blockchain.vmExecutor.vm.crossChainManager.stateStore.settlementLog;
-            return log.filter(s => s.chainId === chainId && s.contractAddress === contractAddress);
-        }
-        return [];
-    }
-
-    _getCrossChainStats() {
-        if (this.blockchain?.vmExecutor?.vm?.crossChainManager?.getStats) {
-            return this.blockchain.vmExecutor.vm.crossChainManager.getStats();
-        }
-        return {
-            totalSettlements: 0,
-            chainsActive: 0,
-            lightClientsRegistered: 0,
-            stateSize: 0
-        };
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // 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();
-        }
-    }
-}
-
-class EmbeddedStorage {
-    constructor() {
-        this.data = new Map();
-    }
-
-    async get(key) {
-        return this.data.get(key);
-    }
-
-    async put(key, value) {
-        this.data.set(key, value);
-    }
-}
-
-// ============================================================
-// EXPORTS
-// ============================================================
+// Version
+const VERSION = '2.0.0';
 
 module.exports = {
     JaelisNode,
-    BootstrapNode,
-    EmbeddedBlockchain,
-    EmbeddedNetwork,
-    EmbeddedRpcServer,
-    EmbeddedStorage,
-
-    // Wallet configuration (like Geth's keystore)
-    NodeWalletConfig,
-
-    // Multi-chain address utilities
-    ADDRESS_FORMATS,
-    detectAddressType,
-    validateAddress,
-    toCanonicalAddress,
-
-    // Convenience factory
-    createNode: (options) => new JaelisNode(options),
-    createBootstrap: (options) => new BootstrapNode(options)
+    SyncManager,
+    RPCServer,
+    Storage,
+    NETWORKS,
+    VERSION
 };