jaelis-node 1.3.2 → 1.4.1

package/lib/JAELIS-VM/test/vm.test.js

@@ -0,0 +1,599 @@
+/**
+ * JAELIS UNIVERSAL VM TEST SUITE
+ *
+ * Tests for cross-chain bytecode execution
+ *
+ * @version 0.1.0
+ * @author Mario Papaleo - JAELIS Foundation
+ */
+
+const { JaelisUniversalVM } = require('../lib/index');
+
+// Test utilities
+let testsPassed = 0;
+let testsFailed = 0;
+
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+
+function assertEqual(actual, expected, message) {
+    if (actual !== expected) {
+        throw new Error(`${message}: expected ${expected}, got ${actual}`);
+    }
+}
+
+async function test(name, fn) {
+    try {
+        await fn();
+        console.log(`  ✓ ${name}`);
+        testsPassed++;
+    } catch (error) {
+        console.log(`  ✗ ${name}`);
+        console.log(`    Error: ${error.message}`);
+        testsFailed++;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// VM INITIALIZATION TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function testVMInitialization() {
+    console.log('\n📦 VM Initialization Tests');
+    console.log('─'.repeat(50));
+
+    await test('VM should initialize with default config', async () => {
+        const vm = new JaelisUniversalVM();
+        assert(vm !== null, 'VM should not be null');
+        assert(vm.config.executionMode === 'interpreter', 'Default mode should be interpreter');
+    });
+
+    await test('VM should accept custom config', async () => {
+        const vm = new JaelisUniversalVM({
+            executionMode: 'aot',
+            maxMemory: 512 * 1024 * 1024,
+            serializer: 'msgpack'
+        });
+        assertEqual(vm.config.executionMode, 'aot', 'Execution mode');
+        assertEqual(vm.config.serializer, 'msgpack', 'Serializer');
+    });
+
+    await test('VM should list all supported VMs', async () => {
+        const vm = new JaelisUniversalVM();
+        const supported = Object.keys(vm.supportedVMs);
+        assert(supported.includes('evm'), 'Should support EVM');
+        assert(supported.includes('svm'), 'Should support SVM');
+        assert(supported.includes('move'), 'Should support Move');
+        assert(supported.includes('tvm'), 'Should support TVM');
+        assert(supported.includes('wasm'), 'Should support WASM');
+        assert(supported.includes('cairo'), 'Should support Cairo');
+        assert(supported.includes('bitcoin'), 'Should support Bitcoin');
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// COMPILER TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function testCompiler() {
+    console.log('\n🔧 Compiler Tests');
+    console.log('─'.repeat(50));
+
+    const vm = new JaelisUniversalVM();
+
+    await test('Should compile simple EVM source code', async () => {
+        const source = `
+            contract SimpleStorage {
+                uint256 public value;
+
+                function setValue(uint256 _value) public {
+                    value = _value;
+                }
+
+                function getValue() public view returns (uint256) {
+                    return value;
+                }
+            }
+        `;
+
+        const result = await vm.compile(source, 'evm');
+        assert(result.moduleId, 'Should have module ID');
+        assert(result.jir, 'Should have JIR');
+        assert(result.jir.bytecode, 'Should have bytecode');
+        assert(result.sourceVM === 'evm', 'Source VM should be evm');
+    });
+
+    await test('Should compile Solana Anchor source', async () => {
+        const source = `
+            #[program]
+            pub mod counter {
+                use super::*;
+
+                pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
+                    let counter = &mut ctx.accounts.counter;
+                    counter.count = 0;
+                    Ok(())
+                }
+
+                pub fn increment(ctx: Context<Increment>) -> Result<()> {
+                    let counter = &mut ctx.accounts.counter;
+                    counter.count += 1;
+                    Ok(())
+                }
+            }
+        `;
+
+        const result = await vm.compile(source, 'svm');
+        assert(result.moduleId, 'Should have module ID');
+        assert(result.jir, 'Should have JIR');
+    });
+
+    await test('Should compile Move source', async () => {
+        const source = `
+            module 0x1::counter {
+                struct Counter has key {
+                    value: u64
+                }
+
+                public fun increment(counter: &mut Counter) {
+                    counter.value = counter.value + 1;
+                }
+
+                public fun get_value(counter: &Counter): u64 {
+                    counter.value
+                }
+            }
+        `;
+
+        const result = await vm.compile(source, 'move');
+        assert(result.moduleId, 'Should have module ID');
+    });
+
+    await test('Should reject unsupported VM', async () => {
+        let error = null;
+        try {
+            await vm.compile('code', 'unsupported_vm');
+        } catch (e) {
+            error = e;
+        }
+        assert(error !== null, 'Should throw error for unsupported VM');
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// SERIALIZATION TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function testSerialization() {
+    console.log('\n📦 Serialization Tests');
+    console.log('─'.repeat(50));
+
+    const vm = new JaelisUniversalVM({ serializer: 'cbor' });
+
+    await test('Should serialize/deserialize primitives', async () => {
+        const testData = {
+            number: 42,
+            string: 'hello',
+            boolean: true,
+            array: [1, 2, 3]
+        };
+
+        const serialized = vm.serializer.serialize(testData);
+        assert(Buffer.isBuffer(serialized), 'Should return buffer');
+
+        const deserialized = vm.serializer.deserialize(serialized);
+        assertEqual(deserialized.number, testData.number, 'Number');
+        assertEqual(deserialized.string, testData.string, 'String');
+        assertEqual(deserialized.boolean, testData.boolean, 'Boolean');
+        assertEqual(deserialized.array.length, testData.array.length, 'Array length');
+    });
+
+    await test('Should handle BigInt values', async () => {
+        const testData = {
+            bigValue: 12345678901234567890n
+        };
+
+        const serialized = vm.serializer.serialize(testData);
+        const deserialized = vm.serializer.deserialize(serialized);
+
+        assert(deserialized.bigValue === testData.bigValue, 'BigInt should match');
+    });
+
+    await test('Should serialize transactions', async () => {
+        const tx = {
+            from: '0x1234567890123456789012345678901234567890',
+            to: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+            value: 1000000000000000000n,
+            nonce: 0,
+            chainId: 4545,
+            gasLimit: 21000
+        };
+
+        const serialized = vm.serializer.serializeTransaction(tx);
+        assert(Buffer.isBuffer(serialized), 'Should return buffer');
+
+        const deserialized = vm.serializer.deserializeTransaction(serialized);
+        assertEqual(deserialized.nonce, tx.nonce, 'Nonce');
+        assertEqual(deserialized.chainId, tx.chainId, 'Chain ID');
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// BYTECODE TRANSLATION TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function testBytecodeTranslation() {
+    console.log('\n🔄 Bytecode Translation Tests');
+    console.log('─'.repeat(50));
+
+    const vm = new JaelisUniversalVM();
+
+    await test('Should translate simple EVM bytecode', async () => {
+        // Simple EVM bytecode: PUSH1 0x60 PUSH1 0x40 MSTORE
+        const evmBytecode = Buffer.from([0x60, 0x60, 0x60, 0x40, 0x52]);
+
+        const jir = await vm.translator.translateToJIR(evmBytecode, 'evm');
+
+        assert(jir.magic.equals(Buffer.from([0x4A, 0x49, 0x52, 0x00])), 'Should have JIR magic');
+        assert(jir.sourceVM === 'evm', 'Source VM should be evm');
+        assert(jir.bytecode.length > 0, 'Should have bytecode');
+    });
+
+    await test('Should translate EVM opcodes correctly', async () => {
+        // EVM: ADD, SUB, MUL, DIV
+        const evmBytecode = Buffer.from([0x01, 0x03, 0x02, 0x04, 0x00]);
+
+        const jir = await vm.translator.translateToJIR(evmBytecode, 'evm');
+        assert(jir.bytecode.includes(0x39) || jir.bytecode.includes(0x34), 'Should have I64_ADD or I32_ADD');
+    });
+
+    await test('Should translate Solana BPF bytecode', async () => {
+        // Simple BPF instruction (ADD_IMM)
+        const bpfBytecode = Buffer.alloc(16);
+        bpfBytecode[0] = 0x07;  // ADD_IMM
+        bpfBytecode.writeInt32LE(100, 4);  // immediate value
+
+        const jir = await vm.translator.translateToJIR(bpfBytecode, 'svm');
+        assert(jir.sourceVM === 'svm', 'Source VM should be svm');
+    });
+
+    await test('Should translate Bitcoin Script', async () => {
+        // OP_1 OP_2 OP_ADD OP_3 OP_EQUAL
+        const script = Buffer.from([0x51, 0x52, 0x93, 0x53, 0x87]);
+
+        const jir = await vm.translator.translateToJIR(script, 'bitcoin');
+        assert(jir.sourceVM === 'bitcoin', 'Source VM should be bitcoin');
+    });
+
+    await test('Should cache translations', async () => {
+        const bytecode = Buffer.from([0x60, 0x01, 0x60, 0x02, 0x01]);
+
+        await vm.translator.translateToJIR(bytecode, 'evm');
+        const stats1 = vm.translator.getStats();
+
+        await vm.translator.translateToJIR(bytecode, 'evm');
+        const stats2 = vm.translator.getStats();
+
+        assert(stats2.cacheHits > stats1.cacheHits, 'Should hit cache on second call');
+    });
+
+    await test('Should translate arguments between VMs', async () => {
+        // EVM address (20 bytes) to Solana (32 bytes)
+        const evmAddress = '0x1234567890abcdef1234567890abcdef12345678';
+
+        const translated = await vm.translator.translateArguments(
+            [evmAddress],
+            'evm',
+            'svm'
+        );
+
+        assert(translated[0].length > evmAddress.length, 'Should pad address for Solana');
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// STATE MANAGER TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function testStateManager() {
+    console.log('\n💾 State Manager Tests');
+    console.log('─'.repeat(50));
+
+    const vm = new JaelisUniversalVM();
+
+    await test('Should create and retrieve accounts', async () => {
+        const address = '0x1234567890123456789012345678901234567890';
+
+        await vm.state.setBalance(address, 1000000000000000000n);
+        const balance = await vm.state.getBalance(address);
+
+        assertEqual(balance, 1000000000000000000n, 'Balance');
+    });
+
+    await test('Should handle contract storage', async () => {
+        const address = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd';
+
+        await vm.state.setStorage(address, 0, 42n);
+        const value = await vm.state.getStorage(address, 0);
+
+        assertEqual(value, 42n, 'Storage value');
+    });
+
+    await test('Should store and retrieve contracts', async () => {
+        const address = '0x1111111111111111111111111111111111111111';
+        const bytecode = Buffer.from([0x60, 0x60, 0x60, 0x40, 0x52]);
+
+        await vm.state.storeContract(address, {
+            jir: { bytecode: Buffer.from([0x00]) },
+            sourceVM: 'evm',
+            bytecode,
+            deployer: '0x0000000000000000000000000000000000000000'
+        });
+
+        const contract = await vm.state.getContract(address);
+        assert(contract !== null, 'Contract should exist');
+        assertEqual(contract.sourceVM, 'evm', 'Source VM');
+    });
+
+    await test('Should support checkpoints and rollback', async () => {
+        const address = '0x2222222222222222222222222222222222222222';
+
+        await vm.state.setStorage(address, 0, 100n);
+
+        const checkpoint = vm.state.checkpoint();
+
+        await vm.state.setStorage(address, 0, 200n);
+        assertEqual(await vm.state.getStorage(address, 0), 200n, 'Value after change');
+
+        await vm.state.revert(checkpoint);
+        assertEqual(await vm.state.getStorage(address, 0), 100n, 'Value after revert');
+    });
+
+    await test('Should get state root', async () => {
+        const root = vm.state.getStateRoot();
+        assert(typeof root === 'string', 'Should return string');
+        assert(root.startsWith('0x') || root.length === 64, 'Should be hex');
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// EXECUTION ENGINE TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function testExecutionEngine() {
+    console.log('\n⚙️ Execution Engine Tests');
+    console.log('─'.repeat(50));
+
+    const vm = new JaelisUniversalVM({ executionMode: 'interpreter' });
+
+    await test('Should execute simple JIR bytecode', async () => {
+        // Simple JIR: push 1, push 2, add, return
+        const jir = {
+            magic: Buffer.from([0x4A, 0x49, 0x52, 0x00]),
+            version: [0, 1, 0],
+            sourceVM: 'evm',
+            functions: [{
+                name: 'main',
+                params: [],
+                returns: [{ type: 'i64' }],
+                code: [
+                    0x30, 1, 0, 0, 0,  // I32_CONST 1
+                    0x30, 2, 0, 0, 0,  // I32_CONST 2
+                    0x34,              // I32_ADD
+                    0x08               // RETURN
+                ]
+            }],
+            memory: { initial: 1, maximum: 16 },
+            exports: [{ name: 'main', kind: 'function', index: 0 }],
+            bytecode: Buffer.from([
+                0x4A, 0x49, 0x52, 0x00,
+                0x30, 1, 0, 0, 0,
+                0x30, 2, 0, 0, 0,
+                0x34,
+                0x08,
+                0xFF
+            ])
+        };
+
+        const result = await vm.engine.execute(jir, 'main', [], {
+            caller: '0x0000000000000000000000000000000000000000'
+        });
+
+        assert(result.success, 'Execution should succeed');
+        assert(result.instructionsUsed > 0, 'Should use instructions');
+    });
+
+    await test('Should handle context correctly', async () => {
+        const jir = {
+            magic: Buffer.from([0x4A, 0x49, 0x52, 0x00]),
+            version: [0, 1, 0],
+            sourceVM: 'evm',
+            functions: [{
+                name: 'getCaller',
+                params: [],
+                returns: [],
+                code: [0x90, 0x08, 0xFF]  // CALLER, RETURN, HALT
+            }],
+            memory: { initial: 1 },
+            exports: [{ name: 'getCaller', kind: 'function', index: 0 }],
+            bytecode: Buffer.from([0x4A, 0x49, 0x52, 0x00, 0x90, 0x08, 0xFF])
+        };
+
+        const caller = '0x1234567890123456789012345678901234567890';
+        const result = await vm.engine.execute(jir, 'getCaller', [], { caller });
+
+        assert(result.success, 'Should succeed');
+    });
+
+    await test('Should respect gas limits', async () => {
+        const jir = {
+            magic: Buffer.from([0x4A, 0x49, 0x52, 0x00]),
+            version: [0, 1, 0],
+            sourceVM: 'evm',
+            functions: [{
+                name: 'infinite',
+                params: [],
+                returns: [],
+                code: [0x02, 0x00, 0x06, 0]  // LOOP, NOP, BR 0
+            }],
+            memory: { initial: 1 },
+            exports: [{ name: 'infinite', kind: 'function', index: 0 }],
+            bytecode: Buffer.from([0x4A, 0x49, 0x52, 0x00, 0x02, 0x00, 0x06, 0, 0xFF])
+        };
+
+        let error = null;
+        try {
+            await vm.engine.execute(jir, 'infinite', [], { gasLimit: 100 });
+        } catch (e) {
+            error = e;
+        }
+
+        assert(error !== null, 'Should throw out of gas error');
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// ADAPTER TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function testAdapters() {
+    console.log('\n🔌 Adapter Tests');
+    console.log('─'.repeat(50));
+
+    const vm = new JaelisUniversalVM();
+    const { AdapterFactory } = require('../lib/adapters');
+    const factory = new AdapterFactory(vm);
+
+    await test('Should create EVM adapter', async () => {
+        const adapter = factory.getAdapter('evm');
+        assert(adapter !== null, 'Adapter should exist');
+        assert(typeof adapter.getFunctionSelector === 'function', 'Should have getFunctionSelector');
+    });
+
+    await test('EVM adapter should encode function selector', async () => {
+        const adapter = factory.getAdapter('evm');
+        const selector = adapter.getFunctionSelector('transfer(address,uint256)');
+
+        assert(Buffer.isBuffer(selector), 'Should return buffer');
+        assertEqual(selector.length, 4, 'Selector should be 4 bytes');
+    });
+
+    await test('EVM adapter should encode parameters', async () => {
+        const adapter = factory.getAdapter('evm');
+        const encoded = adapter.encodeParameters(
+            ['address', 'uint256'],
+            ['0x1234567890123456789012345678901234567890', 1000n]
+        );
+
+        assertEqual(encoded.length, 64, 'Should be 64 bytes (2 x 32)');
+    });
+
+    await test('Should create SVM adapter', async () => {
+        const adapter = factory.getAdapter('svm');
+        assert(adapter !== null, 'Adapter should exist');
+        assert(typeof adapter.findProgramAddress === 'function', 'Should have findProgramAddress');
+    });
+
+    await test('SVM adapter should find PDA', async () => {
+        const adapter = factory.getAdapter('svm');
+        const result = adapter.findProgramAddress(
+            [Buffer.from('seed')],
+            '11111111111111111111111111111111'
+        );
+
+        assert(result.address, 'Should have address');
+        assert(typeof result.bump === 'number', 'Should have bump');
+    });
+
+    await test('Should create Move adapter', async () => {
+        const adapter = factory.getAdapter('move');
+        assert(adapter !== null, 'Adapter should exist');
+    });
+
+    await test('Should create Bitcoin adapter', async () => {
+        const adapter = factory.getAdapter('bitcoin');
+        assert(adapter !== null, 'Adapter should exist');
+
+        const p2pkh = adapter.createP2PKH(Buffer.alloc(20));
+        assert(p2pkh.length > 0, 'Should create P2PKH script');
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// CROSS-VM TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function testCrossVM() {
+    console.log('\n🌐 Cross-VM Tests');
+    console.log('─'.repeat(50));
+
+    const vm = new JaelisUniversalVM();
+
+    await test('Should map addresses across VMs', async () => {
+        const evmAddress = '0x1234567890123456789012345678901234567890';
+        const solanaAddress = '7nxQB1G2SJFXrNt8xLdwLLMQVDx9x2fKVrCzHWJNbmVf';
+
+        await vm.state.mapAddress('evm', evmAddress, 'svm', solanaAddress);
+
+        const mapped = await vm.state.getMappedAddress('evm', evmAddress, 'svm');
+        assertEqual(mapped, solanaAddress, 'Mapped address');
+    });
+
+    await test('Should translate values between VMs', async () => {
+        const evmValue = '0x1234567890123456789012345678901234567890';
+
+        const translated = await vm.translator.translateArguments(
+            [evmValue],
+            'evm',
+            'svm'
+        );
+
+        assert(translated[0].length >= evmValue.length, 'Should translate address');
+    });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// RUN ALL TESTS
+// ═══════════════════════════════════════════════════════════════
+
+async function runAllTests() {
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('   JAELIS UNIVERSAL VM - TEST SUITE');
+    console.log('═══════════════════════════════════════════════════════════════');
+
+    const startTime = Date.now();
+
+    try {
+        await testVMInitialization();
+        await testCompiler();
+        await testSerialization();
+        await testBytecodeTranslation();
+        await testStateManager();
+        await testExecutionEngine();
+        await testAdapters();
+        await testCrossVM();
+    } catch (error) {
+        console.error('\n❌ Test suite crashed:', error.message);
+        testsFailed++;
+    }
+
+    const elapsed = Date.now() - startTime;
+
+    console.log('\n═══════════════════════════════════════════════════════════════');
+    console.log('   TEST RESULTS');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log(`   ✓ Passed: ${testsPassed}`);
+    console.log(`   ✗ Failed: ${testsFailed}`);
+    console.log(`   Total:   ${testsPassed + testsFailed}`);
+    console.log(`   Time:    ${elapsed}ms`);
+    console.log('═══════════════════════════════════════════════════════════════');
+
+    if (testsFailed > 0) {
+        process.exit(1);
+    }
+}
+
+runAllTests().catch(console.error);