jaelis-node 1.10.0 → 2.0.0

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

@@ -1,459 +0,0 @@
-/**
- * JAELIS UNIFIED VM - Integration Test Suite
- *
- * Tests all critical components:
- * - Unified Compiler (all 6 languages)
- * - Bytecode generation
- * - Cross-contract execution
- * - JAELIS ABI encoding/decoding
- * - State access control
- * - VM spec updates
- *
- * Run: node test/unified-vm-test.js
- */
-
-const { UnifiedJaelisVM, JaelisABI, JAELIS_TYPES } = require('../lib/unified');
-
-console.log('═══════════════════════════════════════════════════════════════');
-console.log('   JAELIS UNIFIED VM - 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: JAELIS ABI ENCODING/DECODING
-// ═══════════════════════════════════════════════════════════════
-
-console.log('\n--- JAELIS ABI Tests ---');
-
-test('ABI: Encode/decode U8', () => {
-    const encoded = JaelisABI.encode(42, 'U8');
-    const decoded = JaelisABI.decode(encoded);
-    assert(decoded.value === 42, `Expected 42, got ${decoded.value}`);
-    assert(decoded.type === 'U8', `Expected U8, got ${decoded.type}`);
-});
-
-test('ABI: Encode/decode U256', () => {
-    const value = 12345678901234567890n;
-    const encoded = JaelisABI.encode(value, 'U256');
-    const decoded = JaelisABI.decode(encoded);
-    assert(decoded.value === value, `Expected ${value}, got ${decoded.value}`);
-});
-
-test('ABI: Encode/decode I128 (positive)', () => {
-    const value = 170141183460469231731687303715884105727n;  // Max I128
-    const encoded = JaelisABI.encode(value, 'I128');
-    const decoded = JaelisABI.decode(encoded);
-    assert(decoded.value === value, `Expected ${value}, got ${decoded.value}`);
-});
-
-test('ABI: Encode/decode I128 (negative)', () => {
-    const value = -170141183460469231731687303715884105728n;  // Min I128
-    const encoded = JaelisABI.encode(value, 'I128');
-    const decoded = JaelisABI.decode(encoded);
-    assert(decoded.value === value, `Expected ${value}, got ${decoded.value}`);
-});
-
-test('ABI: Encode/decode BOOL', () => {
-    const encodedTrue = JaelisABI.encode(true, 'BOOL');
-    const decodedTrue = JaelisABI.decode(encodedTrue);
-    assert(decodedTrue.value === true, 'Expected true');
-
-    const encodedFalse = JaelisABI.encode(false, 'BOOL');
-    const decodedFalse = JaelisABI.decode(encodedFalse);
-    assert(decodedFalse.value === false, 'Expected false');
-});
-
-test('ABI: Encode/decode STRING', () => {
-    const value = 'Hello, JAELIS!';
-    const encoded = JaelisABI.encode(value, 'STRING');
-    const decoded = JaelisABI.decode(encoded);
-    assert(decoded.value === value, `Expected "${value}", got "${decoded.value}"`);
-});
-
-test('ABI: Encode/decode ADDRESS', () => {
-    const value = '0x1234567890abcdef1234567890abcdef12345678';
-    const encoded = JaelisABI.encode(value, 'ADDRESS');
-    const decoded = JaelisABI.decode(encoded);
-    assert(decoded.value.toLowerCase().includes('1234567890abcdef'), 'Address not preserved');
-});
-
-test('ABI: Encode/decode F64', () => {
-    const value = 3.141592653589793;
-    const encoded = JaelisABI.encode(value, 'F64');
-    const decoded = JaelisABI.decode(encoded);
-    assert(Math.abs(decoded.value - value) < 0.0001, `Expected ${value}, got ${decoded.value}`);
-});
-
-test('ABI: Function selector computation', () => {
-    const selector = JaelisABI.computeSelector('transfer', ['ADDRESS', 'U256']);
-    assert(Buffer.isBuffer(selector), 'Selector should be a buffer');
-    assert(selector.length === 4, 'Selector should be 4 bytes');
-});
-
-// ═══════════════════════════════════════════════════════════════
-// TEST 2: UNIFIED COMPILER
-// ═══════════════════════════════════════════════════════════════
-
-console.log('\n--- Unified Compiler Tests ---');
-
-asyncTest('Compiler: Parse Solidity contract', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const solidityCode = `
-        pragma solidity ^0.8.0;
-
-        contract SimpleToken {
-            mapping(address => uint256) public balances;
-
-            function transfer(address to, uint256 amount) public returns (bool) {
-                balances[msg.sender] -= amount;
-                balances[to] += amount;
-                return true;
-            }
-
-            function balanceOf(address account) public view returns (uint256) {
-                return balances[account];
-            }
-        }
-    `;
-
-    const result = await vm.compileBundle([{
-        name: 'SimpleToken',
-        code: solidityCode,
-        language: 'solidity'
-    }]);
-
-    assert(result.bytecode.length > 10, 'Bytecode should be generated');
-    assert(result.asts.length === 1, 'Should have 1 AST');
-});
-
-asyncTest('Compiler: Parse Rust/Anchor contract', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const rustCode = `
-        use anchor_lang::prelude::*;
-
-        #[program]
-        pub mod token_program {
-            pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
-                Ok(())
-            }
-
-            pub fn transfer(ctx: Context<Transfer>, amount: u64) -> Result<()> {
-                Ok(())
-            }
-        }
-    `;
-
-    const result = await vm.compileBundle([{
-        name: 'TokenProgram',
-        code: rustCode,
-        language: 'rust'
-    }]);
-
-    assert(result.bytecode.length > 10, 'Bytecode should be generated');
-});
-
-asyncTest('Compiler: Parse Move module', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const moveCode = `
-        module 0x1::token {
-            struct Token has key, store {
-                value: u64
-            }
-
-            public fun mint(amount: u64): Token {
-                Token { value: amount }
-            }
-
-            public fun transfer(from: &mut Token, to: &mut Token, amount: u64) {
-                from.value = from.value - amount;
-                to.value = to.value + amount;
-            }
-        }
-    `;
-
-    const result = await vm.compileBundle([{
-        name: 'MoveToken',
-        code: moveCode,
-        language: 'move'
-    }]);
-
-    assert(result.bytecode.length > 10, 'Bytecode should be generated');
-});
-
-asyncTest('Compiler: Parse FunC contract', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const funcCode = `
-        () recv_internal(int msg_value, cell in_msg_cell) impure {
-            ;; Handle internal message
-        }
-
-        int get_balance() method_id {
-            return 1000;
-        }
-    `;
-
-    const result = await vm.compileBundle([{
-        name: 'TonContract',
-        code: funcCode,
-        language: 'func'
-    }]);
-
-    assert(result.bytecode.length > 10, 'Bytecode should be generated');
-});
-
-asyncTest('Compiler: Parse Cairo contract', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const cairoCode = `
-        #[contract]
-        mod simple_storage {
-            #[external]
-            fn store(value: felt252) {
-            }
-
-            #[view]
-            fn get() -> felt252 {
-                return 0;
-            }
-        }
-    `;
-
-    const result = await vm.compileBundle([{
-        name: 'CairoStorage',
-        code: cairoCode,
-        language: 'cairo'
-    }]);
-
-    assert(result.bytecode.length > 10, 'Bytecode should be generated');
-});
-
-asyncTest('Compiler: Parse Vyper contract', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const vyperCode = `
-# @version ^0.3.7
-
-balances: HashMap[address, uint256]
-
-@external
-def transfer(to: address, amount: uint256) -> bool:
-    self.balances[msg.sender] -= amount
-    self.balances[to] += amount
-    return True
-
-@view
-@external
-def balanceOf(account: address) -> uint256:
-    return self.balances[account]
-    `;
-
-    const result = await vm.compileBundle([{
-        name: 'VyperToken',
-        code: vyperCode,
-        language: 'vyper'
-    }]);
-
-    assert(result.bytecode.length > 10, 'Bytecode should be generated');
-});
-
-// ═══════════════════════════════════════════════════════════════
-// TEST 3: CONTRACT DEPLOYMENT & EXECUTION
-// ═══════════════════════════════════════════════════════════════
-
-console.log('\n--- Contract Deployment Tests ---');
-
-asyncTest('Deploy: Deploy Solidity contract', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const code = `
-        contract Counter {
-            uint256 public count;
-            function increment() public { count++; }
-        }
-    `;
-
-    const result = await vm.deploy(code, 'solidity');
-    assert(result.address, 'Contract should have address');
-    assert(result.bytecode, 'Contract should have bytecode');
-    assert(result.abi.length > 0, 'Contract should have ABI');
-});
-
-asyncTest('Deploy: Deploy multiple languages', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    // Deploy Solidity
-    const sol = await vm.deploy(`contract A { function foo() public {} }`, 'solidity');
-
-    // Deploy Rust
-    const rust = await vm.deploy(`
-        #[program]
-        pub mod b {
-            pub fn bar() -> Result<()> { Ok(()) }
-        }
-    `, 'rust');
-
-    // Check both deployed
-    const contracts = vm.getContracts();
-    assert(contracts.length === 2, `Expected 2 contracts, got ${contracts.length}`);
-});
-
-// ═══════════════════════════════════════════════════════════════
-// TEST 4: CROSS-CONTRACT CALLS (NO BRIDGES!)
-// ═══════════════════════════════════════════════════════════════
-
-console.log('\n--- Cross-Contract Call Tests ---');
-
-asyncTest('CrossCall: Direct call between contracts', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    // Deploy two contracts
-    const contractA = await vm.deploy(`
-        contract TokenA {
-            function getValue() public view returns (uint256) { return 100; }
-        }
-    `, 'solidity');
-
-    const contractB = await vm.deploy(`
-        contract TokenB {
-            function getDoubleValue() public view returns (uint256) { return 200; }
-        }
-    `, 'solidity');
-
-    // Cross-call from A to B
-    const result = await vm.crossCall(
-        contractA.address,
-        contractB.address,
-        'getDoubleValue',
-        []
-    );
-
-    assert(result.success, 'Cross-call should succeed');
-    assert(vm.getStats().crossCalls >= 1, 'Cross-call should be recorded');
-});
-
-// ═══════════════════════════════════════════════════════════════
-// TEST 5: VM SPEC UPDATES
-// ═══════════════════════════════════════════════════════════════
-
-console.log('\n--- VM Spec Update Tests ---');
-
-asyncTest('VMUpdate: Update triggers contract recompile', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    // Deploy a contract
-    const contract = await vm.deploy(`
-        contract Upgradeable {
-            function version() public pure returns (uint256) { return 1; }
-        }
-    `, 'solidity');
-
-    const initialVersion = vm.contractManager.contracts.get(contract.address).version;
-
-    // Update VM spec
-    const affected = await vm.upgradeVM('evm', '0.8.25');
-
-    // Contract should be in affected list
-    assert(affected.includes(contract.address), 'Contract should be affected by upgrade');
-});
-
-// ═══════════════════════════════════════════════════════════════
-// TEST 6: STATE ACCESS CONTROL
-// ═══════════════════════════════════════════════════════════════
-
-console.log('\n--- State Access Control Tests ---');
-
-asyncTest('StateAccess: Self-access always allowed', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const contract = await vm.deploy(`contract A {}`, 'solidity');
-    const slot = Buffer.alloc(32);
-
-    // Write should succeed
-    await vm.writeState(contract.address, slot, Buffer.from('test'));
-
-    // Read should succeed
-    const value = await vm.readState(contract.address, slot);
-    assert(value, 'Should be able to read own state');
-});
-
-asyncTest('StateAccess: Cross-contract write denied by default', async () => {
-    const vm = new UnifiedJaelisVM();
-
-    const contractA = await vm.deploy(`contract A {}`, 'solidity');
-    const contractB = await vm.deploy(`contract B {}`, 'solidity');
-
-    const slot = Buffer.alloc(32);
-
-    // Try to write to A's state from B - should fail
-    try {
-        await vm.contractManager.sharedStateWrite(
-            contractA.address,
-            slot,
-            Buffer.from('hack'),
-            contractB.address
-        );
-        assert(false, 'Should have thrown');
-    } catch (error) {
-        assert(error.message.includes('Access denied'), 'Should deny access');
-    }
-});
-
-// ═══════════════════════════════════════════════════════════════
-// SUMMARY
-// ═══════════════════════════════════════════════════════════════
-
-// Run async tests
-(async () => {
-    // Wait for all async tests
-    await new Promise(resolve => setTimeout(resolve, 2000));
-
-    console.log('\n═══════════════════════════════════════════════════════════════');
-    console.log(`   RESULTS: ${passed} passed, ${failed} failed`);
-    console.log('═══════════════════════════════════════════════════════════════');
-
-    if (failed === 0) {
-        console.log('\n   ✓ ALL TESTS PASSED - UNIFIED VM IS OPERATIONAL!');
-        console.log('   ✓ NO BRIDGES. NO ADAPTERS. ONE SYSTEM.');
-        console.log('   ✓ Ready for production deployment.');
-    } else {
-        console.log('\n   ✗ Some tests failed. Review output above.');
-    }
-
-    console.log('\n');
-})();

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

@@ -1,166 +0,0 @@
-/**
- * JAELIS UNIFIED VM TEST
- *
- * Testing TRUE cross-chain interop - NO BRIDGES!
- */
-
-const { UnifiedJaelisVM } = require('../lib');
-
-async function testUnifiedVM() {
-    console.log('═══════════════════════════════════════════════════════════════');
-    console.log('   UNIFIED VM TEST - NO BRIDGES, NO ADAPTERS!');
-    console.log('═══════════════════════════════════════════════════════════════\n');
-
-    const vm = new UnifiedJaelisVM();
-
-    // Test 1: Deploy a Solidity contract
-    console.log('\n📦 Test 1: Deploy Solidity Contract');
-    console.log('─'.repeat(50));
-
-    const solidityCode = `
-        contract TokenSwap {
-            mapping(address => uint256) public balances;
-
-            function deposit() public payable {
-                balances[msg.sender] += msg.value;
-            }
-
-            function swap(address token, uint256 amount) public returns (bool) {
-                require(balances[msg.sender] >= amount, "Insufficient balance");
-                balances[msg.sender] -= amount;
-                return true;
-            }
-
-            function getBalance(address user) public view returns (uint256) {
-                return balances[user];
-            }
-        }
-    `;
-
-    const evmContract = await vm.deploy(solidityCode, 'solidity');
-    console.log(`  ✓ Deployed Solidity contract: ${evmContract.address.substring(0, 20)}...`);
-    console.log(`    Version: ${evmContract.contract.version}`);
-    console.log(`    Functions: ${evmContract.abi.length}`);
-
-    // Test 2: Deploy a Rust/Anchor contract
-    console.log('\n📦 Test 2: Deploy Rust/Anchor Contract');
-    console.log('─'.repeat(50));
-
-    const rustCode = `
-        #[program]
-        pub mod liquidity_pool {
-            use super::*;
-
-            pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
-                let pool = &mut ctx.accounts.pool;
-                pool.total_liquidity = 0;
-                Ok(())
-            }
-
-            pub fn add_liquidity(ctx: Context<AddLiquidity>, amount: u64) -> Result<()> {
-                let pool = &mut ctx.accounts.pool;
-                pool.total_liquidity += amount;
-                Ok(())
-            }
-
-            pub fn get_price(ctx: Context<GetPrice>, token_a: Pubkey, token_b: Pubkey) -> Result<u64> {
-                // Calculate price
-                Ok(1000)
-            }
-        }
-    `;
-
-    const svmContract = await vm.deploy(rustCode, 'rust');
-    console.log(`  ✓ Deployed Rust/Anchor contract: ${svmContract.address.substring(0, 20)}...`);
-    console.log(`    Version: ${svmContract.contract.version}`);
-
-    // Test 3: Deploy a Move contract
-    console.log('\n📦 Test 3: Deploy Move Contract');
-    console.log('─'.repeat(50));
-
-    const moveCode = `
-        module 0x1::oracle {
-            struct PriceFeed has key {
-                price: u64,
-                timestamp: u64
-            }
-
-            public fun get_price(): u64 {
-                1500
-            }
-
-            public fun update_price(new_price: u64) {
-                // Update price
-            }
-        }
-    `;
-
-    const moveContract = await vm.deploy(moveCode, 'move');
-    console.log(`  ✓ Deployed Move contract: ${moveContract.address.substring(0, 20)}...`);
-
-    // Test 4: Cross-contract call (Solidity → Rust) - NO BRIDGE!
-    console.log('\n🔗 Test 4: Cross-Contract Call (Solidity → Rust)');
-    console.log('─'.repeat(50));
-
-    const crossResult = await vm.crossCall(
-        evmContract.address,
-        svmContract.address,
-        'get_price',
-        []
-    );
-
-    console.log(`  ✓ Direct cross-call completed!`);
-    console.log(`    From: Solidity (EVM)`);
-    console.log(`    To: Rust (Solana)`);
-    console.log(`    NO BRIDGE USED!`);
-
-    // Test 5: VM Upgrade (contracts auto-update!)
-    console.log('\n⬆️ Test 5: VM Upgrade (Auto-Update Contracts)');
-    console.log('─'.repeat(50));
-
-    console.log('  Simulating Solana VM upgrade: 1.18.0 → 1.19.0');
-    const affected = await vm.upgradeVM('svm', '1.19.0');
-    console.log(`  ✓ ${affected.length} contracts auto-upgraded!`);
-    console.log(`    Rust contract new version: ${svmContract.contract.version}`);
-
-    // Test 6: Get all contracts
-    console.log('\n📋 Test 6: All Deployed Contracts');
-    console.log('─'.repeat(50));
-
-    const contracts = vm.getContracts();
-    console.log(`  Total: ${contracts.length} contracts`);
-    for (const c of contracts) {
-        console.log(`    • ${c.address.substring(0, 16)}... (${c.language}) v${c.version}`);
-    }
-
-    // Test 7: Dependency graph
-    console.log('\n🕸️ Test 7: Dependency Graph');
-    console.log('─'.repeat(50));
-
-    const graph = vm.getDependencyGraph();
-    console.log(`  Nodes: ${graph.nodes.length}`);
-    console.log(`  Edges: ${graph.edges.length}`);
-
-    // Final stats
-    console.log('\n📊 Final Stats');
-    console.log('─'.repeat(50));
-
-    const stats = vm.getStats();
-    console.log(`  Contracts Deployed: ${stats.contractsDeployed}`);
-    console.log(`  Cross-Calls: ${stats.crossCalls}`);
-    console.log(`  Upgrades: ${stats.upgrades}`);
-    console.log(`  Gas Used: ${stats.gasUsed} (ZERO FEES!)`);
-
-    console.log('\n═══════════════════════════════════════════════════════════════');
-    console.log('   ALL TESTS PASSED - TRUE CROSS-CHAIN INTEROP!');
-    console.log('═══════════════════════════════════════════════════════════════');
-    console.log('\n   Key Achievements:');
-    console.log('   ✓ Solidity, Rust, and Move contracts deployed to SAME VM');
-    console.log('   ✓ Direct cross-contract calls (NO BRIDGES!)');
-    console.log('   ✓ Auto-upgrade when VM specs change');
-    console.log('   ✓ Shared state between all contracts');
-    console.log('   ✓ ZERO FEES on all operations');
-    console.log('\n');
-}
-
-testUnifiedVM().catch(console.error);