jaelis-node 1.3.2 → 1.5.0

package/README.md

@@ -13,7 +13,36 @@ JAELIS is a next-generation blockchain with a **Universal Virtual Machine** that
 
 ## Universal VM - Core Innovation
 
-The JAELIS Universal VM executes contracts from multiple ecosystems natively:
+JAELIS provides **TWO deployment systems** for maximum flexibility:
+
+### Option 1: Unified VM (Cross-Language Magic)
+
+Compile **MULTIPLE contracts from MULTIPLE languages** into **ONE unified bytecode bundle** with **ONE ABI**:
+
+```javascript
+// Deploy unified bundle - ALL languages compile to ONE bytecode!
+const result = await jaelis.deployUnified({
+    from: '0x...',
+    sources: [
+        { code: solidityCode, language: 'solidity', name: 'Token' },
+        { code: rustCode, language: 'rust', name: 'DeFi' },
+        { code: moveCode, language: 'move', name: 'NFT' }
+    ]
+});
+// ALL contracts share memory and can call each other DIRECTLY!
+```
+
+### Option 2: Multi-VM (Native Compatibility)
+
+Deploy to **native VMs** for exact compatibility with original chain behavior:
+
+```javascript
+await jaelis.deploySolanaProgram({ bytecode, programId, owner });  // → SVM
+await jaelis.deployMoveModule({ bytecode, moduleName, owner });    // → MoveVM
+await jaelis.deployTonContract({ code, data, owner });             // → TVM
+```
+
+### Language Support Matrix
 
 | Language | Ecosystem | Status |
 |----------|-----------|--------|
@@ -24,12 +53,10 @@ The JAELIS Universal VM executes contracts from multiple ecosystems natively:
 | **Cairo** | StarkNet | Production |
 | **Vyper** | Ethereum (Python-like) | Production |
 
-### Cross-Language Contract Calls
-
-A Solidity contract can call a Rust contract. A Move module can interact with FunC. All native, all on-chain:
+### Cross-Language Contract Calls (NO BRIDGES!)
 
 ```javascript
-// Solidity contract calling a Rust program
+// Solidity → Rust call - DIRECT, no bridges needed!
 await jaelis.crossContractCall({
     from: solidityContract,
     to: rustProgram,
@@ -148,9 +175,10 @@ Your node exposes standard JSON-RPC plus JAELIS-specific methods:
 | Method | Description |
 |--------|-------------|
 | `jaelis_getSupportedLanguages` | Returns: `['solidity', 'rust', 'move', 'func', 'cairo', 'vyper']` |
-| `jaelis_deployContract` | Deploy contract in any supported language |
+| `jaelis_deployUnified` | Deploy unified bundle (multiple languages → ONE bytecode!) |
+| `jaelis_deployContract` | Deploy single contract in any supported language |
 | `jaelis_executeContract` | Execute contract method |
-| `jaelis_crossContractCall` | Call between contracts of different languages |
+| `jaelis_crossContractCall` | Call between contracts of different languages (NO BRIDGES!) |
 
 ### Cross-Chain Settlement Methods
 | Method | Description |
@@ -172,7 +200,11 @@ Your node exposes standard JSON-RPC plus JAELIS-specific methods:
 | `jaelis_validateAddressSafety` | Anti-phishing check |
 | `jaelis_checkDustAttacks` | Detect address poisoning |
 
-### Standard Ethereum-Compatible Methods
+### Multi-Ecosystem Compatibility Layers
+
+JAELIS nodes support RPC methods from **every major blockchain ecosystem**. Developers can use their familiar method names - they all proxy to native `jaelis_*` methods under the hood.
+
+#### Ethereum (eth_*)
 | Method | Description |
 |--------|-------------|
 | `eth_blockNumber` | Get latest block number |
@@ -181,6 +213,58 @@ Your node exposes standard JSON-RPC plus JAELIS-specific methods:
 | `eth_call` | Call contract (read-only) |
 | `eth_getTransactionReceipt` | Get transaction receipt |
 
+#### Solana (solana_*)
+| Method | Description |
+|--------|-------------|
+| `solana_getBalance` | Get account balance (lamports format) |
+| `solana_getSlot` | Get current slot (block height) |
+| `solana_getLatestBlockhash` | Get recent blockhash |
+| `solana_getHealth` | Check node health |
+
+#### Bitcoin (btc_*)
+| Method | Description |
+|--------|-------------|
+| `btc_getbalance` | Get balance (BTC decimals) |
+| `btc_getblockcount` | Get block height |
+| `btc_getblock` | Get block by hash |
+| `btc_gettransaction` | Get transaction |
+| `btc_getblockchaininfo` | Chain info |
+| `btc_estimatesmartfee` | Returns 0 (zero fees!) |
+
+#### Move/Aptos/Sui (move_*)
+| Method | Description |
+|--------|-------------|
+| `move_getLedgerInfo` | Get ledger info |
+| `move_getAccountResource` | Get account resource |
+| `move_getAccountModule` | Get account module |
+
+#### TON/Telegram (ton_*)
+| Method | Description |
+|--------|-------------|
+| `ton_getAddressBalance` | Get balance |
+| `ton_getMasterchainInfo` | Get masterchain info |
+| `ton_getAccountState` | Get account state |
+| `ton_runGetMethod` | Run get method |
+
+#### WASM/CosmWasm (wasm_*)
+| Method | Description |
+|--------|-------------|
+| `wasm_call` | Call contract |
+| `wasm_query` | Query contract state |
+| `wasm_deploy` | Deploy WASM contract |
+| `wasm_execute` | Execute contract |
+| `wasm_getCode` | Get contract code |
+
+#### StarkNet/Cairo (starknet_*)
+| Method | Description |
+|--------|-------------|
+| `starknet_chainId` | Get chain ID |
+| `starknet_blockNumber` | Get block number |
+| `starknet_call` | Call contract |
+| `starknet_estimateFee` | Returns 0 (zero fees!) |
+| `starknet_getTransactionByHash` | Get transaction |
+| `starknet_addInvokeTransaction` | Send invoke transaction |
+
 ## Programmatic Usage
 
 ```javascript
@@ -258,6 +342,9 @@ jaelis-node status
 ```
 jaelis-data/
 ├── blockchain/       # Block and state data (LevelDB)
+│   ├── state/        # Account states, contract storage
+│   ├── blocks/       # Block headers and transactions
+│   └── index/        # Chain indexes
 ├── node-registry/    # Node tracking and statistics
 ├── wallet-config/    # Wallet configuration
 ├── peers/            # Peer database
@@ -265,6 +352,8 @@ jaelis-data/
 └── logs/             # Node logs
 ```
 
+**State Persistence:** All VM state (accounts, contracts, storage) persists to LevelDB. Your node's state survives restarts - no data loss.
+
 ## Environment Variables
 
 | Variable | Description | Default |

package/lib/JAELIS-VM/lib/adapters/evm-adapter.js

@@ -0,0 +1,454 @@
+/**
+ * EVM ADAPTER
+ *
+ * Provides EVM-compatible interface for JAELIS Universal VM
+ * Supports: Ethereum, BSC, Polygon, Arbitrum, Optimism, Base, Avalanche
+ *
+ * Features:
+ * - Solidity ABI encoding/decoding
+ * - EIP-2718 transaction types
+ * - EIP-1559 gas pricing
+ * - Precompiled contracts
+ *
+ * @version 0.1.0
+ * @author Mario Papaleo - JAELIS Foundation
+ */
+
+const crypto = require('crypto');
+
+// Solidity ABI type encodings
+const ABI_TYPES = {
+    uint256: { size: 32, dynamic: false },
+    int256: { size: 32, dynamic: false },
+    address: { size: 32, dynamic: false },
+    bool: { size: 32, dynamic: false },
+    bytes32: { size: 32, dynamic: false },
+    bytes: { size: null, dynamic: true },
+    string: { size: null, dynamic: true },
+    'uint256[]': { size: null, dynamic: true },
+    'address[]': { size: null, dynamic: true }
+};
+
+// EVM Precompiled contract addresses
+const PRECOMPILES = {
+    '0x0000000000000000000000000000000000000001': 'ecrecover',
+    '0x0000000000000000000000000000000000000002': 'sha256',
+    '0x0000000000000000000000000000000000000003': 'ripemd160',
+    '0x0000000000000000000000000000000000000004': 'identity',
+    '0x0000000000000000000000000000000000000005': 'modexp',
+    '0x0000000000000000000000000000000000000006': 'ecadd',
+    '0x0000000000000000000000000000000000000007': 'ecmul',
+    '0x0000000000000000000000000000000000000008': 'ecpairing',
+    '0x0000000000000000000000000000000000000009': 'blake2f'
+};
+
+class EVMAdapter {
+    constructor(vm) {
+        this.vm = vm;
+        this.chainId = 4545;  // JAELIS testnet
+
+        // Function signature cache
+        this.signatureCache = new Map();
+    }
+
+    /**
+     * Deploy EVM contract
+     */
+    async deploy(bytecode, constructorArgs = [], options = {}) {
+        // Encode constructor arguments
+        const encodedArgs = this.encodeParameters(
+            options.constructorTypes || [],
+            constructorArgs
+        );
+
+        const deployBytecode = Buffer.concat([
+            Buffer.from(bytecode.replace('0x', ''), 'hex'),
+            encodedArgs
+        ]);
+
+        return this.vm.deployBytecode(deployBytecode, 'evm', options);
+    }
+
+    /**
+     * Call EVM contract function
+     */
+    async call(address, functionSignature, args = [], options = {}) {
+        // Parse function signature
+        const { name, types } = this.parseFunctionSignature(functionSignature);
+
+        // Encode function call
+        const selector = this.getFunctionSelector(functionSignature);
+        const encodedArgs = this.encodeParameters(types, args);
+
+        const callData = Buffer.concat([selector, encodedArgs]);
+
+        // Execute
+        const result = await this.vm.execute(address, name, callData, {
+            ...options,
+            callData
+        });
+
+        // Decode result if return types specified
+        if (options.returnTypes) {
+            result.decoded = this.decodeParameters(options.returnTypes, result.returnValue);
+        }
+
+        return result;
+    }
+
+    /**
+     * Get function selector (4 bytes)
+     */
+    getFunctionSelector(signature) {
+        // Check cache
+        if (this.signatureCache.has(signature)) {
+            return this.signatureCache.get(signature);
+        }
+
+        // Normalize signature
+        const normalized = signature.replace(/\s/g, '');
+
+        // Keccak256 hash and take first 4 bytes
+        const hash = this.keccak256(Buffer.from(normalized));
+        const selector = hash.slice(0, 4);
+
+        this.signatureCache.set(signature, selector);
+        return selector;
+    }
+
+    /**
+     * Parse function signature
+     */
+    parseFunctionSignature(signature) {
+        const match = signature.match(/^(\w+)\((.*)\)$/);
+        if (!match) {
+            throw new Error(`Invalid function signature: ${signature}`);
+        }
+
+        const name = match[1];
+        const types = match[2] ? match[2].split(',').map(t => t.trim()) : [];
+
+        return { name, types };
+    }
+
+    /**
+     * Encode function parameters (ABI encoding)
+     */
+    encodeParameters(types, values) {
+        if (types.length !== values.length) {
+            throw new Error('Types and values length mismatch');
+        }
+
+        const heads = [];
+        const tails = [];
+        let tailOffset = types.length * 32;  // Start of dynamic data
+
+        for (let i = 0; i < types.length; i++) {
+            const type = types[i];
+            const value = values[i];
+            const typeInfo = ABI_TYPES[type];
+
+            if (!typeInfo || !typeInfo.dynamic) {
+                // Static type - encode directly in head
+                heads.push(this.encodeValue(type, value));
+            } else {
+                // Dynamic type - encode offset in head, data in tail
+                heads.push(this.encodeUint256(tailOffset));
+                const encoded = this.encodeValue(type, value);
+                tails.push(encoded);
+                tailOffset += encoded.length;
+            }
+        }
+
+        return Buffer.concat([...heads, ...tails]);
+    }
+
+    /**
+     * Decode function parameters
+     */
+    decodeParameters(types, data) {
+        const results = [];
+        let offset = 0;
+
+        for (const type of types) {
+            const typeInfo = ABI_TYPES[type];
+
+            if (!typeInfo || !typeInfo.dynamic) {
+                // Static type
+                results.push(this.decodeValue(type, data, offset));
+                offset += 32;
+            } else {
+                // Dynamic type - read offset first
+                const dataOffset = Number(this.decodeUint256(data, offset));
+                results.push(this.decodeValue(type, data, dataOffset));
+                offset += 32;
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Encode a single value
+     */
+    encodeValue(type, value) {
+        switch (type) {
+            case 'uint256':
+            case 'int256':
+                return this.encodeUint256(value);
+
+            case 'address':
+                return this.encodeAddress(value);
+
+            case 'bool':
+                return this.encodeUint256(value ? 1 : 0);
+
+            case 'bytes32':
+                return this.encodeBytes32(value);
+
+            case 'bytes':
+                return this.encodeBytes(value);
+
+            case 'string':
+                return this.encodeString(value);
+
+            case 'uint256[]':
+            case 'address[]':
+                return this.encodeArray(type.replace('[]', ''), value);
+
+            default:
+                throw new Error(`Unsupported type: ${type}`);
+        }
+    }
+
+    /**
+     * Decode a single value
+     */
+    decodeValue(type, data, offset) {
+        switch (type) {
+            case 'uint256':
+                return this.decodeUint256(data, offset);
+
+            case 'int256':
+                return this.decodeInt256(data, offset);
+
+            case 'address':
+                return this.decodeAddress(data, offset);
+
+            case 'bool':
+                return this.decodeUint256(data, offset) !== 0n;
+
+            case 'bytes32':
+                return '0x' + data.slice(offset, offset + 32).toString('hex');
+
+            case 'bytes':
+                return this.decodeBytes(data, offset);
+
+            case 'string':
+                return this.decodeString(data, offset);
+
+            default:
+                throw new Error(`Unsupported type: ${type}`);
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // ENCODING HELPERS
+    // ═══════════════════════════════════════════════════════════════
+
+    encodeUint256(value) {
+        const buf = Buffer.alloc(32);
+        let v = BigInt(value);
+        for (let i = 31; i >= 0 && v > 0n; i--) {
+            buf[i] = Number(v & 0xffn);
+            v >>= 8n;
+        }
+        return buf;
+    }
+
+    decodeUint256(data, offset = 0) {
+        let result = 0n;
+        for (let i = 0; i < 32; i++) {
+            result = (result << 8n) | BigInt(data[offset + i] || 0);
+        }
+        return result;
+    }
+
+    decodeInt256(data, offset = 0) {
+        const unsigned = this.decodeUint256(data, offset);
+        // Check sign bit
+        if (unsigned >= 2n ** 255n) {
+            return unsigned - 2n ** 256n;
+        }
+        return unsigned;
+    }
+
+    encodeAddress(address) {
+        const buf = Buffer.alloc(32);
+        const hex = address.startsWith('0x') ? address.slice(2) : address;
+        Buffer.from(hex.padStart(40, '0'), 'hex').copy(buf, 12);
+        return buf;
+    }
+
+    decodeAddress(data, offset = 0) {
+        return '0x' + data.slice(offset + 12, offset + 32).toString('hex');
+    }
+
+    encodeBytes32(value) {
+        const buf = Buffer.alloc(32);
+        const hex = value.startsWith('0x') ? value.slice(2) : value;
+        Buffer.from(hex.padEnd(64, '0'), 'hex').copy(buf);
+        return buf;
+    }
+
+    encodeBytes(value) {
+        const data = Buffer.isBuffer(value) ? value : Buffer.from(value.replace('0x', ''), 'hex');
+        const length = this.encodeUint256(data.length);
+
+        // Pad to 32-byte boundary
+        const padded = Buffer.alloc(Math.ceil(data.length / 32) * 32);
+        data.copy(padded);
+
+        return Buffer.concat([length, padded]);
+    }
+
+    decodeBytes(data, offset = 0) {
+        const length = Number(this.decodeUint256(data, offset));
+        return data.slice(offset + 32, offset + 32 + length);
+    }
+
+    encodeString(value) {
+        return this.encodeBytes(Buffer.from(value, 'utf8'));
+    }
+
+    decodeString(data, offset = 0) {
+        return this.decodeBytes(data, offset).toString('utf8');
+    }
+
+    encodeArray(elementType, values) {
+        const length = this.encodeUint256(values.length);
+        const elements = values.map(v => this.encodeValue(elementType, v));
+        return Buffer.concat([length, ...elements]);
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // CRYPTO
+    // ═══════════════════════════════════════════════════════════════
+
+    keccak256(data) {
+        // Using sha3-256 as approximation
+        // Real implementation would use keccak
+        return crypto.createHash('sha3-256').update(data).digest();
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // TRANSACTION ENCODING (EIP-2718, EIP-1559)
+    // ═══════════════════════════════════════════════════════════════
+
+    encodeTransaction(tx) {
+        // EIP-1559 transaction
+        const fields = [
+            tx.chainId || this.chainId,
+            tx.nonce || 0,
+            tx.maxPriorityFeePerGas || 0,
+            tx.maxFeePerGas || 0,
+            tx.gasLimit || 21000,
+            tx.to || '',
+            tx.value || 0,
+            tx.data || Buffer.alloc(0),
+            tx.accessList || []
+        ];
+
+        // RLP encode (simplified)
+        const encoded = this.rlpEncode(fields);
+
+        // Prepend transaction type (0x02 for EIP-1559)
+        return Buffer.concat([Buffer.from([0x02]), encoded]);
+    }
+
+    rlpEncode(input) {
+        if (Array.isArray(input)) {
+            const encoded = input.map(item => this.rlpEncode(item));
+            const concat = Buffer.concat(encoded);
+            return Buffer.concat([this.rlpEncodeLength(concat.length, 0xc0), concat]);
+        }
+
+        if (Buffer.isBuffer(input)) {
+            if (input.length === 1 && input[0] < 0x80) {
+                return input;
+            }
+            return Buffer.concat([this.rlpEncodeLength(input.length, 0x80), input]);
+        }
+
+        if (typeof input === 'number' || typeof input === 'bigint') {
+            if (input === 0 || input === 0n) {
+                return Buffer.from([0x80]);
+            }
+            const hex = input.toString(16);
+            const buf = Buffer.from(hex.length % 2 ? '0' + hex : hex, 'hex');
+            return this.rlpEncode(buf);
+        }
+
+        if (typeof input === 'string') {
+            if (input.startsWith('0x')) {
+                return this.rlpEncode(Buffer.from(input.slice(2), 'hex'));
+            }
+            return this.rlpEncode(Buffer.from(input));
+        }
+
+        return Buffer.from([0x80]);
+    }
+
+    rlpEncodeLength(length, offset) {
+        if (length < 56) {
+            return Buffer.from([offset + length]);
+        }
+        const hexLength = length.toString(16);
+        const lenOfLen = Math.ceil(hexLength.length / 2);
+        return Buffer.concat([
+            Buffer.from([offset + 55 + lenOfLen]),
+            Buffer.from(hexLength.padStart(lenOfLen * 2, '0'), 'hex')
+        ]);
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // PRECOMPILES
+    // ═══════════════════════════════════════════════════════════════
+
+    async executePrecompile(address, input) {
+        const name = PRECOMPILES[address.toLowerCase()];
+        if (!name) {
+            throw new Error(`Unknown precompile: ${address}`);
+        }
+
+        switch (name) {
+            case 'ecrecover':
+                return this._ecrecover(input);
+            case 'sha256':
+                return crypto.createHash('sha256').update(input).digest();
+            case 'ripemd160':
+                const ripemd = crypto.createHash('ripemd160').update(input).digest();
+                return Buffer.concat([Buffer.alloc(12), ripemd]);
+            case 'identity':
+                return input;
+            case 'modexp':
+                return this._modexp(input);
+            default:
+                throw new Error(`Precompile not implemented: ${name}`);
+        }
+    }
+
+    _ecrecover(input) {
+        // Extract components from input
+        // Would need actual EC recovery implementation
+        return Buffer.alloc(32);
+    }
+
+    _modexp(input) {
+        // Modular exponentiation
+        // Would need big integer implementation
+        return Buffer.alloc(32);
+    }
+}
+
+module.exports = EVMAdapter;