jaelis-node 1.9.0 → 2.0.0

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

@@ -1,456 +0,0 @@
-/**
- * JAELIS UNIFIED VM
- *
- * TRUE cross-chain interoperability:
- * - NO BRIDGES
- * - NO ADAPTERS
- * - NO TRANSLATION AT RUNTIME
- * - ONE ABI FOR ALL
- * - CHAIN-ID NAMESPACED STORAGE FOR UNIVERSAL SETTLEMENT
- *
- * Just... code that works together.
- *
- * @version 0.4.0
- * @author Mario Papaleo - JAELIS Foundation
- */
-
-const { UnifiedCompiler, UNIFIED_TYPES, AST_NODES } = require('./unified-compiler');
-const { DynamicContract, DynamicContractManager, ContractStateStore } = require('./dynamic-contracts');
-const { JaelisABI, JaelisABIEncoder, JaelisABIDecoder, ABIConverter, JAELIS_TYPES } = require('./jaelis-abi');
-const {
-    CrossChainStateStore,
-    CrossChainSettlementManager,
-    CrossChainExecutor,
-    LightClientInterface,
-    EVMLightClient,
-    SVMLightClient,
-    CHAIN_REGISTRY,
-    CROSS_CHAIN_OPCODES
-} = require('./cross-chain-state');
-
-// Cross-Chain Deployment Manager (OUTBOUND propagation!)
-const { CrossChainDeployManager } = require('./cross-chain-deploy');
-
-/**
- * Unified JAELIS VM
- *
- * The next evolution - contracts from ALL languages
- * running together in ONE VM, sharing state DIRECTLY.
- *
- * NO ADAPTERS. NO BRIDGES. ONE SYSTEM.
- * CHAIN-ID NAMESPACED STORAGE FOR UNIVERSAL SETTLEMENT.
- */
-class UnifiedJaelisVM {
-    constructor(config = {}) {
-        this.config = config;
-
-        // Unified compiler (handles ALL languages)
-        this.compiler = new UnifiedCompiler(config);
-
-        // Dynamic contract manager
-        this.contractManager = new DynamicContractManager();
-
-        // Shared state (ALL contracts share this!)
-        this.sharedState = new ContractStateStore();
-
-        // Cross-chain settlement manager (THE KEY INNOVATION!)
-        // Default to testnet (4545) since that's what's live - mainnet is 4547
-        this.crossChainManager = new CrossChainSettlementManager({
-            nativeChainId: config.chainId || CHAIN_REGISTRY.JAELIS_TESTNET.id,
-            autoRegisterLightClients: config.autoRegisterLightClients !== false
-        });
-
-        // Cross-chain deployment manager (OUTBOUND propagation!)
-        // When you deploy on JAELIS, contracts appear on ETH/SOL/etc explorers!
-        this.deployManager = new CrossChainDeployManager({
-            nativeChainId: config.chainId || CHAIN_REGISTRY.JAELIS_TESTNET.id,
-            lightClients: this.crossChainManager.stateStore.lightClients
-        });
-
-        // JAELIS ABI (ONE ABI for all!)
-        this.abi = JaelisABI;
-
-        // Native chain ID (4545 = testnet [live], 4547 = mainnet [upcoming])
-        this.chainId = config.chainId || CHAIN_REGISTRY.JAELIS_TESTNET.id;
-
-        // Stats
-        this.stats = {
-            contractsDeployed: 0,
-            crossCalls: 0,
-            upgrades: 0,
-            crossChainSettlements: 0,
-            gasUsed: 0  // Always 0 - ZERO FEES!
-        };
-
-        console.log('═══════════════════════════════════════════════════════════════');
-        console.log('   JAELIS UNIFIED VM v0.4.0');
-        console.log('   TRUE CROSS-CHAIN INTEROPERABILITY');
-        console.log('═══════════════════════════════════════════════════════════════');
-        console.log(`   Chain ID: ${this.chainId} (${this.getChainName(this.chainId)})`);
-        console.log('   ✓ NO BRIDGES - Direct contract-to-contract calls');
-        console.log('   ✓ NO ADAPTERS - One unified system');
-        console.log('   ✓ ONE ABI - JAELIS ABI for all languages');
-        console.log('   ✓ DYNAMIC CONTRACTS - Auto-update when VMs change');
-        console.log('   ✓ SHARED STATE - All contracts, one memory space');
-        console.log('   ✓ CHAIN-ID NAMESPACED STORAGE - Universal settlement');
-        console.log('   ✓ LIGHT CLIENT VERIFICATION - Trustless external state');
-        console.log('   ✓ ZERO FEES - Always free execution');
-        console.log('   ✓ CROSS-CHAIN DEPLOY - Contracts appear on ALL explorers!');
-        console.log('═══════════════════════════════════════════════════════════════');
-    }
-
-    /**
-     * Get chain name from ID
-     */
-    getChainName(chainId) {
-        const chain = Object.values(CHAIN_REGISTRY).find(c => c.id === chainId);
-        return chain ? chain.name : 'Unknown';
-    }
-
-    /**
-     * Deploy a contract in ANY language
-     */
-    async deploy(source, language, options = {}) {
-        const result = await this.contractManager.deploy(source, language, options);
-        this.stats.contractsDeployed++;
-        return result;
-    }
-
-    /**
-     * Compile multiple contracts together
-     *
-     * The magic: They can all call each other DIRECTLY
-     */
-    async compileBundle(sources) {
-        return this.compiler.compile(sources);
-    }
-
-    /**
-     * Deploy unified contract with cross-chain propagation
-     *
-     * THE FULL FLOW:
-     * 1. Compile all sources into unified JIR bytecode
-     * 2. Deploy to JAELIS (native)
-     * 3. Propagate to target chains (ETH, SOL, etc.)
-     * 4. Return deployment info with explorer URLs
-     *
-     * @param {Object} params - Deployment parameters
-     * @param {string} params.from - Deployer address
-     * @param {Array} params.sources - [{ code, language, name }...]
-     * @param {Array<number>} params.targetChains - Chain IDs to deploy to
-     */
-    async deployUnifiedWithPropagation(params) {
-        const { from, sources, targetChains } = params;
-
-        console.log(`[UnifiedVM] Deploying unified bundle with propagation...`);
-        console.log(`[UnifiedVM] Sources: ${sources.length} contracts`);
-        console.log(`[UnifiedVM] Languages: ${[...new Set(sources.map(s => s.language))].join(', ')}`);
-        console.log(`[UnifiedVM] Target chains: ${targetChains?.length || 0}`);
-
-        // Step 1: Compile all sources
-        const compiled = await this.compileBundle(sources);
-
-        // Step 2: Deploy with cross-chain propagation
-        const deployment = await this.deployManager.deployToChains({
-            from,
-            bytecode: compiled.bytecode,
-            abi: compiled.abi || [],
-            targetChains: targetChains || [],
-            metadata: {
-                sources: sources.map(s => ({ name: s.name, language: s.language })),
-                compiledAt: Date.now(),
-                version: '1.0.0'
-            }
-        });
-
-        this.stats.contractsDeployed++;
-
-        // Build explorer URLs for each chain
-        const explorerUrls = {};
-        for (const chainDeploy of deployment.deployments) {
-            const url = this.deployManager.getExplorerUrl(chainDeploy.chainId, chainDeploy.address);
-            if (url) {
-                explorerUrls[chainDeploy.chainId] = url;
-            }
-        }
-
-        console.log(`[UnifiedVM] Deployment complete!`);
-        console.log(`[UnifiedVM] JAELIS address: ${deployment.jaelisAddress}`);
-        console.log(`[UnifiedVM] Chain deployments: ${deployment.deployments.length}`);
-
-        return {
-            address: deployment.jaelisAddress,
-            bytecode: compiled.bytecode?.toString('hex'),
-            abi: compiled.abi || [],
-            deployments: deployment.deployments,
-            explorerUrls,
-            metadata: deployment.metadata,
-            gasUsed: 0  // ZERO FEES!
-        };
-    }
-
-    /**
-     * Execute a function on ANY contract
-     */
-    async execute(address, functionName, args = [], context = {}) {
-        const contract = this.contractManager.contracts.get(address);
-        if (!contract) {
-            throw new Error(`Contract not found: ${address}`);
-        }
-
-        // Get function
-        const func = contract.interface.functions.get(functionName);
-        if (!func) {
-            throw new Error(`Function not found: ${functionName}`);
-        }
-
-        console.log(`[UnifiedVM] Executing ${address.substring(0, 10)}...::${functionName}`);
-
-        // Encode args using JAELIS ABI (ONE encoding for all!)
-        const encodedArgs = args.length > 0
-            ? JaelisABI.encodeMultiple(args, func.params?.map(p => p.type) || [])
-            : Buffer.alloc(0);
-
-        // Execute (would run actual bytecode)
-        return {
-            success: true,
-            returnValue: null,
-            gasUsed: 0,  // ZERO FEES!
-            logs: []
-        };
-    }
-
-    /**
-     * Direct cross-contract call (NO BRIDGES! NO ADAPTERS!)
-     *
-     * This is THE key innovation - contracts talk directly
-     */
-    async crossCall(fromAddress, toAddress, functionName, args = []) {
-        this.stats.crossCalls++;
-
-        console.log(`[UnifiedVM] Cross-call: ${fromAddress.substring(0, 10)}... → ${toAddress.substring(0, 10)}...::${functionName}`);
-        console.log(`[UnifiedVM] NO BRIDGE! NO ADAPTER! Direct execution.`);
-
-        return this.contractManager.crossContractCall(fromAddress, toAddress, functionName, args);
-    }
-
-    /**
-     * Encode function call using JAELIS ABI
-     */
-    encodeCall(functionName, args, argTypes) {
-        return JaelisABI.encodeFunctionCall(functionName, args, argTypes);
-    }
-
-    /**
-     * Decode return value using JAELIS ABI
-     */
-    decodeReturn(buffer) {
-        return JaelisABI.decode(buffer);
-    }
-
-    /**
-     * Get function selector
-     */
-    getSelector(functionName, argTypes = []) {
-        return JaelisABI.computeSelector(functionName, argTypes);
-    }
-
-    /**
-     * Update VM specs (triggers auto-upgrade of affected contracts)
-     */
-    async upgradeVM(vm, newVersion) {
-        const affected = await this.contractManager.updateVMSpec(vm, newVersion);
-        this.stats.upgrades += affected.length;
-        return affected;
-    }
-
-    /**
-     * Read shared state
-     */
-    async readState(address, slot) {
-        return this.contractManager.sharedStateRead(address, slot);
-    }
-
-    /**
-     * Write shared state
-     */
-    async writeState(address, slot, value, caller) {
-        return this.contractManager.sharedStateWrite(address, slot, value, caller);
-    }
-
-    /**
-     * Get all deployed contracts
-     */
-    getContracts() {
-        return this.contractManager.getAllContracts();
-    }
-
-    /**
-     * Get dependency graph
-     */
-    getDependencyGraph() {
-        return this.contractManager.getDependencyGraph();
-    }
-
-    /**
-     * Get stats
-     */
-    getStats() {
-        return {
-            ...this.stats,
-            contracts: this.contractManager.contracts.size,
-            vmSpecs: this.contractManager.vmSpecs,
-            crossChain: this.crossChainManager.getStats()
-        };
-    }
-
-    /**
-     * Convert from other ABI formats to JAELIS ABI
-     */
-    static convertABI(abi, format) {
-        switch (format) {
-            case 'solidity':
-            case 'evm':
-                return ABIConverter.fromSolidityABI(abi);
-            case 'anchor':
-            case 'solana':
-            case 'svm':
-                return ABIConverter.fromAnchorIDL(abi);
-            case 'move':
-            case 'aptos':
-            case 'sui':
-                return ABIConverter.fromMoveABI(abi);
-            default:
-                return abi;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // CROSS-CHAIN SETTLEMENT API
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Compute chain-namespaced storage slot
-     *
-     * Formula: sha256(chainId || contractAddress || variableName)
-     *
-     * This enables state from different chains to coexist without collision
-     */
-    computeCrossChainSlot(chainId, contractAddress, variableName) {
-        return this.crossChainManager.computeSlot(chainId, contractAddress, variableName);
-    }
-
-    /**
-     * Settle external chain state with proof
-     *
-     * This is THE KEY OPERATION for cross-chain interop:
-     * 1. User provides state proof from external chain (ETH, SOL, etc.)
-     * 2. Light client verifies the proof
-     * 3. State is written to JAELIS with chain ID namespace
-     * 4. Now JAELIS contracts can use external chain state!
-     *
-     * @param {number} chainId - External chain ID (1 for ETH, 501 for SOL, etc.)
-     * @param {string} contractAddress - Contract address on external chain
-     * @param {string} variableName - Variable/slot name
-     * @param {Buffer} value - State value
-     * @param {Buffer} proof - Merkle proof from external chain
-     */
-    async settleExternalState(chainId, contractAddress, variableName, value, proof) {
-        const result = await this.crossChainManager.settle(chainId, contractAddress, variableName, value, proof);
-        this.stats.crossChainSettlements++;
-        return result;
-    }
-
-    /**
-     * Read cross-chain state
-     *
-     * Can read state from any chain that has been settled
-     */
-    readCrossChainState(chainId, contractAddress, variableName) {
-        return this.crossChainManager.readState(chainId, contractAddress, variableName);
-    }
-
-    /**
-     * Write cross-chain state (native chain only)
-     */
-    writeCrossChainState(contractAddress, variableName, value) {
-        return this.crossChainManager.writeState(contractAddress, variableName, value);
-    }
-
-    /**
-     * Update light client for external chain
-     *
-     * Relayers call this to keep the light client up to date
-     */
-    async updateLightClient(chainId, headers) {
-        return this.crossChainManager.updateLightClient(chainId, headers);
-    }
-
-    /**
-     * Get chain info
-     */
-    getChainInfo(chainId) {
-        return this.crossChainManager.getChainInfo(chainId);
-    }
-
-    /**
-     * Get all registered chains
-     */
-    getAllChains() {
-        return this.crossChainManager.getAllChains();
-    }
-
-    /**
-     * Get state diff between same contract on two chains
-     *
-     * Useful for: arbitrage detection, reconciliation, sync verification
-     */
-    getCrossChainStateDiff(chainId1, chainId2, contractAddress, variableNames) {
-        return this.crossChainManager.stateStore.getStateDiff(chainId1, chainId2, contractAddress, variableNames);
-    }
-
-    /**
-     * Get cross-chain opcodes for compiler integration
-     */
-    getCrossChainOpcodes() {
-        return CROSS_CHAIN_OPCODES;
-    }
-
-    /**
-     * Get cross-chain executor for bytecode integration
-     */
-    getCrossChainExecutor() {
-        return this.crossChainManager.getExecutor();
-    }
-}
-
-module.exports = {
-    UnifiedJaelisVM,
-    UnifiedCompiler,
-    DynamicContract,
-    DynamicContractManager,
-
-    // JAELIS ABI (THE unified encoding)
-    JaelisABI,
-    JaelisABIEncoder,
-    JaelisABIDecoder,
-    ABIConverter,
-
-    // Cross-Chain Settlement (INBOUND - reading external state)
-    CrossChainStateStore,
-    CrossChainSettlementManager,
-    CrossChainExecutor,
-    LightClientInterface,
-    EVMLightClient,
-    SVMLightClient,
-    CHAIN_REGISTRY,
-    CROSS_CHAIN_OPCODES,
-
-    // Cross-Chain Deployment (OUTBOUND - propagating to external chains!)
-    CrossChainDeployManager,
-
-    // Types
-    UNIFIED_TYPES,
-    JAELIS_TYPES,
-    AST_NODES
-};