jaelis-node 1.3.2 → 1.5.0

package/lib/index.js

@@ -5,7 +5,24 @@
  * This module provides the JaelisNode class which wraps the core blockchain
  * implementation for easy deployment as a standalone node.
  *
- * @version 1.0.0
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * RPC ARCHITECTURE (v1.4.0+)
+ * ═══════════════════════════════════════════════════════════════════════════════
+ *
+ * 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.4.0
  * @author JAELIS Foundation
  */
 
@@ -1217,15 +1234,23 @@ class EmbeddedRpcServer {
     async _handleMethod(method, params) {
         switch (method) {
             // ═══════════════════════════════════════════════════════════════
-            // STANDARD ETHEREUM-COMPATIBLE METHODS
+            // LAYER 1: NATIVE JAELIS METHODS (PRIMARY)
             // ═══════════════════════════════════════════════════════════════
-            case 'eth_chainId':
+            case 'jaelis_chainId':
                 return '0x' + (this.blockchain?.chainId || 4545).toString(16);
 
-            case 'eth_blockNumber':
             case 'jaelis_blockNumber':
                 return '0x' + (this.blockchain?.getHeight?.() || 0).toString(16);
 
+            // ═══════════════════════════════════════════════════════════════
+            // 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;
@@ -1251,11 +1276,18 @@ class EmbeddedRpcServer {
                     vmActive: !!this.blockchain?.vmExecutor
                 };
 
+            case 'jaelis_deploy':
             case 'jaelis_deployContract':
                 // Deploy contract in ANY language!
                 // params: [source, language, options]
                 return this._deployContract(params[0], params[1], params[2] || {});
 
+            case 'jaelis_deployUnified':
+                // THE KEY INNOVATION: Deploy unified contract bundle!
+                // Compile MULTIPLE contracts from MULTIPLE languages into ONE bytecode!
+                // params: [{ from, sources: [{ code, language, name }...] }]
+                return this._deployUnified(params[0]);
+
             case 'jaelis_executeContract':
                 // Execute contract call
                 // params: [to, functionName, args, options]
@@ -1320,6 +1352,217 @@ class EmbeddedRpcServer {
                 // Get cross-chain stats
                 return this._getCrossChainStats();
 
+            // ═══════════════════════════════════════════════════════════════
+            // 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}`);
         }
@@ -1353,6 +1596,69 @@ class EmbeddedRpcServer {
         };
     }
 
+    /**
+     * Deploy unified contract bundle (THE KEY INNOVATION!)
+     *
+     * Compiles MULTIPLE contracts from MULTIPLE languages into ONE bytecode bundle.
+     * All contracts share memory and can call each other DIRECTLY - no bridges!
+     *
+     * @param {Object} params - { from, sources: [{ code, language, name }...] }
+     */
+    async _deployUnified(params) {
+        if (!this.blockchain) throw new Error('Blockchain not available');
+        if (!this.blockchain.unifiedVM) throw new Error('Unified VM not available');
+
+        const { from, sources } = params;
+
+        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(', ')}`);
+
+        // Compile all sources together using the Unified Compiler
+        const compiled = await this.blockchain.unifiedVM.compileBundle(sources);
+
+        // Deploy the unified bytecode
+        const address = '0x' + require('crypto').randomBytes(20).toString('hex');
+
+        // Store the unified contract
+        if (this.blockchain.contracts) {
+            this.blockchain.contracts.set(address, {
+                bytecode: compiled.bytecode,
+                abi: compiled.abi || [],
+                sources: sources.map(s => s.name),
+                languages: [...new Set(sources.map(s => s.language))],
+                deployedAt: Date.now(),
+                deployer: from
+            });
+        }
+
+        console.log(`[RPC] Unified bundle deployed at ${address}`);
+        console.log(`[RPC] Bytecode: ${compiled.bytecode?.length || 0} bytes`);
+        console.log(`[RPC] Cross-references: ${compiled.crossReferences?.size || 0}`);
+
+        // Build contracts map for response
+        const contractsMap = {};
+        for (const source of sources) {
+            contractsMap[source.name] = {
+                address: address,  // All share the same bundle address
+                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);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jaelis-node",
-  "version": "1.3.2",
-  "description": "Official JAELIS Blockchain Node - Run a full node, validator, or bootstrap node with Cross-Chain Settlement (30+ chains!), ERC-5792 wallet capabilities, EIP-7702 account abstraction",
+  "version": "1.5.0",
+  "description": "Official JAELIS Blockchain Node - Universal VM (6 languages), LevelDB state persistence, native jaelis_* RPC, multi-ecosystem compatibility (eth/solana/move/ton/btc/wasm/starknet), Cross-Chain Settlement (30+ chains!)",
   "main": "lib/index.js",
   "bin": {
     "jaelis-node": "./bin/jaelis-node.js"