jaelis-node 1.3.2 → 1.4.1

package/lib/JAELIS-VM/test/cross-chain-test.js

@@ -0,0 +1,470 @@
+/**
+ * JAELIS CROSS-CHAIN STATE - Integration Test Suite
+ *
+ * Tests all cross-chain settlement features:
+ * - Chain-ID namespaced storage slots
+ * - Light client verification
+ * - Cross-chain state settlement
+ * - State diff detection
+ * - Cross-chain opcodes
+ *
+ * Run: node test/cross-chain-test.js
+ */
+
+const {
+    UnifiedJaelisVM,
+    CrossChainStateStore,
+    CrossChainSettlementManager,
+    EVMLightClient,
+    SVMLightClient,
+    CHAIN_REGISTRY,
+    CROSS_CHAIN_OPCODES
+} = require('../lib/unified');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('   JAELIS CROSS-CHAIN STATE - INTEGRATION TESTS');
+console.log('═══════════════════════════════════════════════════════════════');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+    try {
+        fn();
+        console.log(`✓ ${name}`);
+        passed++;
+    } catch (error) {
+        console.log(`✗ ${name}`);
+        console.log(`  Error: ${error.message}`);
+        failed++;
+    }
+}
+
+async function asyncTest(name, fn) {
+    try {
+        await fn();
+        console.log(`✓ ${name}`);
+        passed++;
+    } catch (error) {
+        console.log(`✗ ${name}`);
+        console.log(`  Error: ${error.message}`);
+        failed++;
+    }
+}
+
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'Assertion failed');
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// TEST 1: CHAIN REGISTRY
+// ═══════════════════════════════════════════════════════════════
+
+console.log('\n--- Chain Registry Tests ---');
+
+test('ChainRegistry: JAELIS Testnet defined (LIVE)', () => {
+    assert(CHAIN_REGISTRY.JAELIS_TESTNET, 'JAELIS_TESTNET should be defined');
+    assert(CHAIN_REGISTRY.JAELIS_TESTNET.id === 4545, `Expected 4545, got ${CHAIN_REGISTRY.JAELIS_TESTNET.id}`);
+    assert(CHAIN_REGISTRY.JAELIS_TESTNET.type === 'native', 'JAELIS should be native type');
+    assert(CHAIN_REGISTRY.JAELIS_TESTNET.status === 'live', 'JAELIS Testnet should be live');
+});
+
+test('ChainRegistry: JAELIS Mainnet defined (upcoming)', () => {
+    assert(CHAIN_REGISTRY.JAELIS_MAINNET, 'JAELIS_MAINNET should be defined');
+    assert(CHAIN_REGISTRY.JAELIS_MAINNET.id === 4547, `Expected 4547, got ${CHAIN_REGISTRY.JAELIS_MAINNET.id}`);
+    assert(CHAIN_REGISTRY.JAELIS_MAINNET.status === 'upcoming', 'JAELIS Mainnet should be upcoming');
+});
+
+test('ChainRegistry: Ethereum mainnet defined', () => {
+    assert(CHAIN_REGISTRY.ETH_MAINNET, 'ETH_MAINNET should be defined');
+    assert(CHAIN_REGISTRY.ETH_MAINNET.id === 1, `Expected 1, got ${CHAIN_REGISTRY.ETH_MAINNET.id}`);
+    assert(CHAIN_REGISTRY.ETH_MAINNET.type === 'evm', 'ETH should be EVM type');
+});
+
+test('ChainRegistry: Solana defined', () => {
+    assert(CHAIN_REGISTRY.SOLANA_MAINNET, 'SOLANA_MAINNET should be defined');
+    assert(CHAIN_REGISTRY.SOLANA_MAINNET.id === 101, `Expected 101, got ${CHAIN_REGISTRY.SOLANA_MAINNET.id}`);
+    assert(CHAIN_REGISTRY.SOLANA_MAINNET.type === 'svm', 'Solana should be SVM type');
+    assert(CHAIN_REGISTRY.SOLANA_MAINNET.cluster === 'mainnet-beta', 'Should have correct cluster');
+});
+
+test('ChainRegistry: All major chains present', () => {
+    const requiredChains = ['JAELIS_TESTNET', 'JAELIS_MAINNET', 'ETH_MAINNET', 'POLYGON', 'ARBITRUM_ONE', 'SOLANA_MAINNET', 'APTOS_MAINNET', 'TON_MAINNET'];
+    for (const chain of requiredChains) {
+        assert(CHAIN_REGISTRY[chain], `${chain} should be defined`);
+    }
+});
+
+// ═══════════════════════════════════════════════════════════════
+// TEST 2: CHAIN-ID NAMESPACED STORAGE SLOTS
+// ═══════════════════════════════════════════════════════════════
+
+console.log('\n--- Storage Slot Computation Tests ---');
+
+test('StorageSlot: Same contract, different chains = different slots', () => {
+    const store = new CrossChainStateStore();
+
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+    const varName = 'balances';
+
+    const ethSlot = store.computeSlot(1, contractAddr, varName);       // Ethereum (chain ID 1)
+    const jaelisSlot = store.computeSlot(4545, contractAddr, varName); // JAELIS Testnet (chain ID 4545)
+    const solSlot = store.computeSlot(101, contractAddr, varName);     // Solana (chain ID 101)
+
+    assert(!ethSlot.equals(jaelisSlot), 'ETH and JAELIS slots should be different');
+    assert(!ethSlot.equals(solSlot), 'ETH and SOL slots should be different');
+    assert(!jaelisSlot.equals(solSlot), 'JAELIS and SOL slots should be different');
+});
+
+test('StorageSlot: Same chain, same contract, different vars = different slots', () => {
+    const store = new CrossChainStateStore();
+
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+
+    const balanceSlot = store.computeSlot(1, contractAddr, 'balances');
+    const ownerSlot = store.computeSlot(1, contractAddr, 'owner');
+    const supplySlot = store.computeSlot(1, contractAddr, 'totalSupply');
+
+    assert(!balanceSlot.equals(ownerSlot), 'balance and owner slots should be different');
+    assert(!balanceSlot.equals(supplySlot), 'balance and supply slots should be different');
+});
+
+test('StorageSlot: Deterministic - same inputs = same output', () => {
+    const store = new CrossChainStateStore();
+
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+
+    const slot1 = store.computeSlot(1, contractAddr, 'test');
+    const slot2 = store.computeSlot(1, contractAddr, 'test');
+
+    assert(slot1.equals(slot2), 'Same inputs should produce same slot');
+});
+
+test('StorageSlot: Mapping slot computation', () => {
+    const store = new CrossChainStateStore();
+
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+    const userAddr = '0xaabbccdd00112233aabbccdd00112233aabbccdd';
+
+    const slot = store.computeMappingSlot(1, contractAddr, 'balances', userAddr);
+    assert(Buffer.isBuffer(slot), 'Mapping slot should be a buffer');
+    assert(slot.length === 32, 'Slot should be 32 bytes');
+});
+
+// ═══════════════════════════════════════════════════════════════
+// TEST 3: CROSS-CHAIN STATE READ/WRITE
+// ═══════════════════════════════════════════════════════════════
+
+console.log('\n--- Cross-Chain State Read/Write Tests ---');
+
+test('StateRW: Write and read native chain state', () => {
+    const store = new CrossChainStateStore(4545); // JAELIS Testnet (live)
+
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+    const value = Buffer.alloc(32);
+    value.writeBigUInt64LE(1000000n, 0);
+
+    // Write
+    store.writeChainState(4545, contractAddr, 'balance', value);
+
+    // Read
+    const readValue = store.readChainState(4545, contractAddr, 'balance');
+    assert(readValue.readBigUInt64LE(0) === 1000000n, 'Value should match');
+});
+
+test('StateRW: Cannot directly write to external chain', () => {
+    const store = new CrossChainStateStore(4545); // JAELIS Testnet
+
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+    const value = Buffer.alloc(32);
+
+    try {
+        store.writeChainState(1, contractAddr, 'balance', value); // Try to write to ETH
+        assert(false, 'Should have thrown');
+    } catch (error) {
+        assert(error.message.includes('Cannot directly write'), 'Should get access error');
+    }
+});
+
+test('StateRW: Read returns zero for unset state', () => {
+    const store = new CrossChainStateStore(4545);
+
+    const value = store.readChainState(1, '0xdeadbeef', 'nonexistent');
+    assert(value.every(b => b === 0), 'Unset state should be zero');
+});
+
+// ═══════════════════════════════════════════════════════════════
+// TEST 4: LIGHT CLIENT VERIFICATION
+// ═══════════════════════════════════════════════════════════════
+
+console.log('\n--- Light Client Tests ---');
+
+asyncTest('LightClient: EVM light client setup', async () => {
+    const client = new EVMLightClient(1); // Ethereum mainnet
+
+    assert(client.chainId === 1, 'Chain ID should be 1');
+    assert(client.lastVerifiedBlock === 0, 'Initial block should be 0');
+});
+
+asyncTest('LightClient: Update headers', async () => {
+    const client = new EVMLightClient(1);
+
+    const headers = [
+        {
+            number: 1000,
+            hash: Buffer.alloc(32, 1),
+            parentHash: Buffer.alloc(32, 0),
+            stateRoot: Buffer.alloc(32, 2),
+            timestamp: Date.now()
+        }
+    ];
+
+    await client.updateHeaders(headers);
+    assert(client.lastVerifiedBlock === 1000, 'Block should be updated');
+});
+
+asyncTest('LightClient: Verify state proof structure', async () => {
+    const client = new EVMLightClient(1);
+
+    // Add a header first
+    const stateRoot = Buffer.alloc(32, 0xab);
+    await client.updateHeaders([{
+        number: 1000,
+        hash: Buffer.alloc(32, 1),
+        parentHash: Buffer.alloc(32, 0),
+        stateRoot: stateRoot,
+        timestamp: Date.now()
+    }]);
+
+    // Create a proof
+    const proof = Buffer.alloc(100);
+    proof.writeBigUInt64LE(1000n, 0);  // Block number
+    stateRoot.copy(proof, 8);           // State root
+
+    const slot = Buffer.alloc(32);
+    const value = Buffer.alloc(32);
+
+    const isValid = await client.verifyStateProof(proof, slot, value);
+    assert(isValid === true, 'Valid proof structure should verify');
+});
+
+// ═══════════════════════════════════════════════════════════════
+// TEST 5: CROSS-CHAIN SETTLEMENT
+// ═══════════════════════════════════════════════════════════════
+
+console.log('\n--- Cross-Chain Settlement Tests ---');
+
+asyncTest('Settlement: Settle external state with proof', async () => {
+    const manager = new CrossChainSettlementManager({ nativeChainId: 4545 });
+
+    // Get the light client and update it
+    const ethClient = manager.stateStore.lightClients.get(1);
+    const stateRoot = Buffer.alloc(32, 0xab);
+    await ethClient.updateHeaders([{
+        number: 1000,
+        hash: Buffer.alloc(32, 1),
+        parentHash: Buffer.alloc(32, 0),
+        stateRoot: stateRoot,
+        timestamp: Date.now()
+    }]);
+
+    // Create proof
+    const proof = Buffer.alloc(100);
+    proof.writeBigUInt64LE(1000n, 0);
+    stateRoot.copy(proof, 8);
+
+    // Settle state
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+    const value = Buffer.alloc(32);
+    value.writeBigUInt64LE(5000n, 0);
+
+    const result = await manager.settle(1, contractAddr, 'balance', value, proof);
+    assert(result.settlement, 'Should have settlement record');
+    assert(result.settlement.chainId === 1, 'Chain ID should be 1');
+});
+
+asyncTest('Settlement: Read settled state', async () => {
+    const manager = new CrossChainSettlementManager({ nativeChainId: 4545 });
+
+    // Setup and settle
+    const ethClient = manager.stateStore.lightClients.get(1);
+    const stateRoot = Buffer.alloc(32, 0xcd);
+    await ethClient.updateHeaders([{
+        number: 2000,
+        hash: Buffer.alloc(32, 2),
+        parentHash: Buffer.alloc(32, 1),
+        stateRoot: stateRoot,
+        timestamp: Date.now()
+    }]);
+
+    const proof = Buffer.alloc(100);
+    proof.writeBigUInt64LE(2000n, 0);
+    stateRoot.copy(proof, 8);
+
+    const contractAddr = '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef';
+    const value = Buffer.alloc(32);
+    value.writeBigUInt64LE(99999n, 0);
+
+    await manager.settle(1, contractAddr, 'totalSupply', value, proof);
+
+    // Read it back
+    const readValue = manager.readState(1, contractAddr, 'totalSupply');
+    assert(readValue.readBigUInt64LE(0) === 99999n, 'Settled value should be readable');
+});
+
+// ═══════════════════════════════════════════════════════════════
+// TEST 6: UNIFIED VM INTEGRATION
+// ═══════════════════════════════════════════════════════════════
+
+console.log('\n--- Unified VM Cross-Chain Integration Tests ---');
+
+asyncTest('UnifiedVM: Has cross-chain manager', async () => {
+    const vm = new UnifiedJaelisVM({ chainId: 4545 });
+
+    assert(vm.crossChainManager, 'Should have cross-chain manager');
+    assert(vm.chainId === 4545, 'Chain ID should be 4545 (testnet)');
+});
+
+asyncTest('UnifiedVM: Compute cross-chain slots', async () => {
+    const vm = new UnifiedJaelisVM({ chainId: 4545 });
+
+    const ethSlot = vm.computeCrossChainSlot(1, '0x1234', 'balance');
+    const jaelisSlot = vm.computeCrossChainSlot(4545, '0x1234', 'balance');
+
+    assert(!ethSlot.equals(jaelisSlot), 'Different chains = different slots');
+});
+
+asyncTest('UnifiedVM: Get chain info', async () => {
+    const vm = new UnifiedJaelisVM();
+
+    const ethInfo = vm.getChainInfo(1);
+    assert(ethInfo.name === 'Ethereum Mainnet', 'Should get ETH info');
+
+    const solInfo = vm.getChainInfo(101);
+    assert(solInfo.name === 'Solana Mainnet', 'Should get SOL info');
+});
+
+asyncTest('UnifiedVM: Get all chains', async () => {
+    const vm = new UnifiedJaelisVM();
+
+    const chains = vm.getAllChains();
+    assert(Object.keys(chains).length > 20, 'Should have many chains');
+    assert(chains.JAELIS_TESTNET, 'Should have JAELIS Testnet');
+    assert(chains.JAELIS_MAINNET, 'Should have JAELIS Mainnet');
+    assert(chains.ETH_MAINNET, 'Should have ETH');
+});
+
+asyncTest('UnifiedVM: Stats include cross-chain', async () => {
+    const vm = new UnifiedJaelisVM();
+
+    const stats = vm.getStats();
+    assert(stats.crossChain, 'Should have crossChain stats');
+    assert(stats.crossChainSettlements === 0, 'Should start at 0 settlements');
+});
+
+// ═══════════════════════════════════════════════════════════════
+// TEST 7: CROSS-CHAIN OPCODES
+// ═══════════════════════════════════════════════════════════════
+
+console.log('\n--- Cross-Chain Opcode Tests ---');
+
+test('Opcodes: All cross-chain opcodes defined', () => {
+    const requiredOpcodes = [
+        'XCHAIN_SLOAD', 'XCHAIN_SSTORE', 'XCHAIN_SETTLE',
+        'XCHAIN_ID', 'XCHAIN_EXISTS', 'XCHAIN_TYPE',
+        'XCHAIN_VERIFY', 'XCHAIN_QUEUE', 'XCHAIN_FLUSH',
+        'XCHAIN_DIFF', 'XCHAIN_UPDATE', 'XCHAIN_HEIGHT'
+    ];
+
+    for (const op of requiredOpcodes) {
+        assert(CROSS_CHAIN_OPCODES[op] !== undefined, `${op} should be defined`);
+    }
+});
+
+test('Opcodes: Opcodes are in extended range (0xE0-0xEF)', () => {
+    for (const [name, code] of Object.entries(CROSS_CHAIN_OPCODES)) {
+        assert(code >= 0xE0 && code <= 0xEF, `${name} (0x${code.toString(16)}) should be in 0xE0-0xEF range`);
+    }
+});
+
+test('Opcodes: No duplicate opcode values', () => {
+    const values = Object.values(CROSS_CHAIN_OPCODES);
+    const unique = new Set(values);
+    assert(values.length === unique.size, 'All opcode values should be unique');
+});
+
+// ═══════════════════════════════════════════════════════════════
+// TEST 8: STATE DIFF DETECTION
+// ═══════════════════════════════════════════════════════════════
+
+console.log('\n--- State Diff Detection Tests ---');
+
+test('StateDiff: Detect differences between chains', () => {
+    const store = new CrossChainStateStore(4545);
+
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+
+    // Write different values for same var on two chains (simulating settled state)
+    const ethSlot = store.computeSlot(1, contractAddr, 'price');
+    const solSlot = store.computeSlot(101, contractAddr, 'price');
+
+    const ethValue = Buffer.alloc(32);
+    ethValue.writeBigUInt64LE(100n, 0);
+    store.write(ethSlot, ethValue);
+
+    const solValue = Buffer.alloc(32);
+    solValue.writeBigUInt64LE(105n, 0);
+    store.write(solSlot, solValue);
+
+    // Check diff
+    const diff = store.getStateDiff(1, 101, contractAddr, ['price']);
+    assert(diff.length === 1, 'Should find 1 difference');
+    assert(diff[0].variableName === 'price', 'Diff should be for price');
+});
+
+test('StateDiff: No diff when values match', () => {
+    const store = new CrossChainStateStore(4545);
+
+    const contractAddr = '0x1234567890abcdef1234567890abcdef12345678';
+
+    // Write same value on both chains
+    const ethSlot = store.computeSlot(1, contractAddr, 'constant');
+    const solSlot = store.computeSlot(101, contractAddr, 'constant');
+
+    const sameValue = Buffer.alloc(32);
+    sameValue.writeBigUInt64LE(42n, 0);
+    store.write(ethSlot, sameValue);
+    store.write(solSlot, Buffer.from(sameValue)); // Copy
+
+    // Check diff
+    const diff = store.getStateDiff(1, 101, contractAddr, ['constant']);
+    assert(diff.length === 0, 'Should find no differences');
+});
+
+// ═══════════════════════════════════════════════════════════════
+// SUMMARY
+// ═══════════════════════════════════════════════════════════════
+
+(async () => {
+    // Wait for all async tests
+    await new Promise(resolve => setTimeout(resolve, 3000));
+
+    console.log('\n═══════════════════════════════════════════════════════════════');
+    console.log(`   RESULTS: ${passed} passed, ${failed} failed`);
+    console.log('═══════════════════════════════════════════════════════════════');
+
+    if (failed === 0) {
+        console.log('\n   ✓ ALL CROSS-CHAIN TESTS PASSED!');
+        console.log('   ✓ Chain-ID namespaced storage: OPERATIONAL');
+        console.log('   ✓ Light client verification: OPERATIONAL');
+        console.log('   ✓ Cross-chain settlement: OPERATIONAL');
+        console.log('   ✓ State diff detection: OPERATIONAL');
+        console.log('   ✓ JAELIS is now a UNIVERSAL SETTLEMENT LAYER!');
+    } else {
+        console.log('\n   ✗ Some tests failed. Review output above.');
+    }
+
+    console.log('\n');
+})();