jaelis-node 1.10.0 → 2.1.0

package/lib/vm/index.js

@@ -1,397 +0,0 @@
-/**
- * JAELIS UNIFIED VM INTEGRATION
- *
- * Wires the UnifiedJaelisVM (NO BRIDGES, NO ADAPTERS!) into the JAELIS blockchain
- * for smart contract execution.
- *
- * This is THE execution engine - all contracts from ALL languages run here:
- * - Solidity (EVM)
- * - Rust (Solana)
- * - Move (Aptos/Sui)
- * - FunC (TON)
- * - Cairo (Starknet)
- *
- * Key Features:
- * - TRUE cross-chain interoperability (NO BRIDGES!)
- * - Dynamic contracts (auto-update when VMs change)
- * - JAELIS ABI (ONE encoding for all)
- * - ZERO FEES (ENE system)
- *
- * @version 1.0.0
- * @author Mario Papaleo - JAELIS Foundation
- * @patent PATENT PENDING - Unified Cross-Chain Virtual Machine
- */
-
-const path = require('path');
-const EventEmitter = require('events');
-
-// Import the Unified VM from JAELIS-VM
-let UnifiedJaelisVM, JaelisABI, DynamicContractManager;
-
-try {
-    const vmPath = path.resolve(__dirname, '../../../JAELIS-VM/lib/unified');
-    const unified = require(vmPath);
-    UnifiedJaelisVM = unified.UnifiedJaelisVM;
-    JaelisABI = unified.JaelisABI;
-    DynamicContractManager = unified.DynamicContractManager;
-} catch (e) {
-    console.warn('[JAELIS-VM] Could not load UnifiedJaelisVM from relative path, trying npm...');
-    try {
-        const unified = require('jaelis-vm/lib/unified');
-        UnifiedJaelisVM = unified.UnifiedJaelisVM;
-        JaelisABI = unified.JaelisABI;
-        DynamicContractManager = unified.DynamicContractManager;
-    } catch (e2) {
-        console.warn('[JAELIS-VM] UnifiedJaelisVM not available, using fallback');
-    }
-}
-
-/**
- * VMExecutor - Executes smart contracts on the JAELIS blockchain
- *
- * This wraps the UnifiedJaelisVM and provides blockchain-specific functionality:
- * - Transaction processing
- * - State commitment to blockchain
- * - Event emission for block inclusion
- * - Gas-less execution (ENE system)
- */
-class VMExecutor extends EventEmitter {
-    constructor(blockchain, options = {}) {
-        super();
-
-        this.blockchain = blockchain;
-        this.options = options;
-
-        // Initialize the Unified VM (NO BRIDGES!)
-        if (UnifiedJaelisVM) {
-            this.vm = new UnifiedJaelisVM({
-                ...options,
-                enableLogging: options.debug || false
-            });
-            console.log('[VMExecutor] Unified VM initialized - NO BRIDGES, NO ADAPTERS!');
-        } else {
-            this.vm = null;
-            console.log('[VMExecutor] Running in light mode (no VM)');
-        }
-
-        // Contract address mapping
-        this.contracts = new Map();
-
-        // Pending state changes (committed on block finalization)
-        this.pendingStateChanges = [];
-
-        // Transaction receipts
-        this.receipts = new Map();
-
-        // Stats
-        this.stats = {
-            contractsDeployed: 0,
-            transactionsExecuted: 0,
-            crossContractCalls: 0,
-            totalGasUsed: 0  // Always 0 - ZERO FEES!
-        };
-    }
-
-    /**
-     * Deploy a smart contract
-     *
-     * Supports ANY language:
-     * - Solidity, Vyper (EVM)
-     * - Rust/Anchor (Solana)
-     * - Move (Aptos/Sui)
-     * - FunC (TON)
-     * - Cairo (Starknet)
-     */
-    async deployContract(source, language, options = {}) {
-        if (!this.vm) {
-            throw new Error('VM not available - run in full node mode');
-        }
-
-        const deployer = options.from || options.deployer || '0x0';
-
-        console.log(`[VMExecutor] Deploying ${language} contract...`);
-
-        // Deploy through Unified VM
-        const result = await this.vm.deploy(source, language, {
-            ...options,
-            deployer
-        });
-
-        // Store in local registry
-        this.contracts.set(result.address, {
-            address: result.address,
-            language,
-            deployedAt: Date.now(),
-            deployer,
-            bytecodeHash: result.bytecode ?
-                require('crypto').createHash('sha256').update(result.bytecode).digest('hex') : null
-        });
-
-        this.stats.contractsDeployed++;
-
-        // Emit event for block inclusion
-        this.emit('contractDeployed', {
-            address: result.address,
-            language,
-            deployer,
-            blockNumber: this.blockchain?.getHeight?.() || 0
-        });
-
-        console.log(`[VMExecutor] Contract deployed: ${result.address.substring(0, 20)}...`);
-
-        return {
-            address: result.address,
-            abi: result.abi,
-            language,
-            gasUsed: 0  // ZERO FEES!
-        };
-    }
-
-    /**
-     * Execute a contract call
-     */
-    async executeCall(to, functionName, args = [], options = {}) {
-        if (!this.vm) {
-            throw new Error('VM not available');
-        }
-
-        const from = options.from || '0x0';
-        const value = options.value || 0;
-
-        console.log(`[VMExecutor] Executing ${functionName} on ${to.substring(0, 16)}...`);
-
-        // Execute through Unified VM
-        const result = await this.vm.execute(to, functionName, args, {
-            from,
-            value,
-            blockNumber: this.blockchain?.getHeight?.() || 0,
-            timestamp: Date.now()
-        });
-
-        this.stats.transactionsExecuted++;
-
-        // Create receipt
-        const receipt = {
-            transactionHash: this._generateTxHash(to, functionName, args, from),
-            blockNumber: this.blockchain?.getHeight?.() || 0,
-            from,
-            to,
-            status: result.success ? 1 : 0,
-            gasUsed: 0,  // ZERO FEES!
-            logs: result.logs || [],
-            returnValue: result.returnValue
-        };
-
-        this.receipts.set(receipt.transactionHash, receipt);
-
-        // Emit for block inclusion
-        this.emit('transactionExecuted', receipt);
-
-        return receipt;
-    }
-
-    /**
-     * Cross-contract call (NO BRIDGES!)
-     *
-     * This is THE key innovation - contracts from ANY VM can call each other DIRECTLY
-     */
-    async crossContractCall(fromContract, toContract, functionName, args = [], options = {}) {
-        if (!this.vm) {
-            throw new Error('VM not available');
-        }
-
-        console.log(`[VMExecutor] Cross-call: ${fromContract.substring(0, 10)}... → ${toContract.substring(0, 10)}...::${functionName}`);
-        console.log(`[VMExecutor] NO BRIDGE! NO ADAPTER! Direct execution.`);
-
-        // Execute through Unified VM's cross-call
-        const result = await this.vm.crossCall(fromContract, toContract, functionName, args);
-
-        this.stats.crossContractCalls++;
-
-        // Emit event
-        this.emit('crossContractCall', {
-            from: fromContract,
-            to: toContract,
-            function: functionName,
-            success: result.success,
-            blockNumber: this.blockchain?.getHeight?.() || 0
-        });
-
-        return result;
-    }
-
-    /**
-     * Process a transaction
-     *
-     * This is called by the blockchain when a new transaction arrives
-     */
-    async processTransaction(tx) {
-        // Validate transaction
-        if (!tx.to && !tx.data) {
-            throw new Error('Invalid transaction: no target or data');
-        }
-
-        // Contract deployment (no 'to' address)
-        if (!tx.to && tx.data) {
-            // Detect language from data or metadata
-            const language = tx.language || this._detectLanguage(tx.data);
-            return this.deployContract(tx.data, language, {
-                from: tx.from,
-                value: tx.value
-            });
-        }
-
-        // Contract call
-        if (tx.to && tx.data) {
-            const { functionName, args } = this._decodeCalldata(tx.data);
-            return this.executeCall(tx.to, functionName, args, {
-                from: tx.from,
-                value: tx.value
-            });
-        }
-
-        // Simple transfer (no data)
-        return this._processTransfer(tx);
-    }
-
-    /**
-     * Get contract information
-     */
-    getContract(address) {
-        return this.contracts.get(address) || null;
-    }
-
-    /**
-     * Get all deployed contracts
-     */
-    getAllContracts() {
-        return Array.from(this.contracts.values());
-    }
-
-    /**
-     * Get transaction receipt
-     */
-    getReceipt(txHash) {
-        return this.receipts.get(txHash) || null;
-    }
-
-    /**
-     * Get VM stats
-     */
-    getStats() {
-        const vmStats = this.vm?.getStats?.() || {};
-        return {
-            ...this.stats,
-            ...vmStats,
-            vmAvailable: !!this.vm
-        };
-    }
-
-    /**
-     * Encode function call using JAELIS ABI
-     */
-    encodeCall(functionName, args, types) {
-        if (JaelisABI) {
-            return JaelisABI.encodeFunctionCall(functionName, args, types);
-        }
-        // Fallback encoding
-        return Buffer.from(JSON.stringify({ functionName, args }));
-    }
-
-    /**
-     * Decode function call
-     */
-    decodeCall(data) {
-        if (JaelisABI) {
-            return JaelisABI.decodeFunctionCall(data);
-        }
-        // Fallback decoding
-        try {
-            return JSON.parse(data.toString());
-        } catch {
-            return { functionName: 'unknown', args: [] };
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // PRIVATE METHODS
-    // ═══════════════════════════════════════════════════════════════
-
-    _generateTxHash(to, functionName, args, from) {
-        const crypto = require('crypto');
-        return '0x' + crypto.createHash('sha256')
-            .update(JSON.stringify({ to, functionName, args, from, timestamp: Date.now() }))
-            .digest('hex');
-    }
-
-    _detectLanguage(data) {
-        const code = typeof data === 'string' ? data : data.toString();
-
-        // Detect by patterns
-        if (code.includes('contract ') && code.includes('function ')) return 'solidity';
-        if (code.includes('#[program]') || code.includes('pub mod ')) return 'rust';
-        if (code.includes('module ') && code.includes('public fun ')) return 'move';
-        if (code.includes('recv_internal') || code.includes('method_id')) return 'func';
-        if (code.includes('#[contract]') && code.includes('fn ')) return 'cairo';
-
-        return 'solidity';  // Default
-    }
-
-    _decodeCalldata(data) {
-        // If it's already JSON
-        if (typeof data === 'object' && data.functionName) {
-            return data;
-        }
-
-        // Try JAELIS ABI decode
-        if (JaelisABI && Buffer.isBuffer(data)) {
-            try {
-                return JaelisABI.decodeFunctionCall(data);
-            } catch {
-                // Fall through
-            }
-        }
-
-        // Try JSON
-        try {
-            return JSON.parse(data.toString());
-        } catch {
-            return { functionName: 'fallback', args: [] };
-        }
-    }
-
-    async _processTransfer(tx) {
-        // Simple value transfer (no contract execution)
-        const receipt = {
-            transactionHash: this._generateTxHash(tx.to, 'transfer', [tx.value], tx.from),
-            blockNumber: this.blockchain?.getHeight?.() || 0,
-            from: tx.from,
-            to: tx.to,
-            value: tx.value,
-            status: 1,
-            gasUsed: 0  // ZERO FEES!
-        };
-
-        this.receipts.set(receipt.transactionHash, receipt);
-        this.emit('transfer', receipt);
-
-        return receipt;
-    }
-}
-
-/**
- * Factory function to create VM executor
- */
-function createVMExecutor(blockchain, options = {}) {
-    return new VMExecutor(blockchain, options);
-}
-
-module.exports = {
-    VMExecutor,
-    createVMExecutor,
-
-    // Re-export VM components
-    UnifiedJaelisVM,
-    JaelisABI,
-    DynamicContractManager
-};