jaelis-node 1.10.0 → 2.0.0

package/lib/JAELIS-VM/lib/state/state-manager.js

@@ -1,1116 +0,0 @@
-/**
- * JAELIS STATE MANAGER (VM Layer)
- *
- * Unified state management across all VMs with DIRECT LevelDB persistence.
- * This is the VM-side StateManager that delegates to Core's StateManager for storage.
- *
- * Architecture (Patent Claim 7d - Unified State Manager):
- *   VM Operations → JAELIS-VM StateManager → Core StateManager → LevelDB
- *
- * NO IN-MEMORY MAPS - All state is persisted to LevelDB through Core.
- * The in-memory caches in Core StateManager provide fast access.
- *
- * Features:
- * - Account model (Ethereum/Aptos) vs UTXO (Bitcoin)
- * - Contract storage (EVM 256-bit slots, Solana account data)
- * - Cross-VM state access
- * - State trie with Merkle proofs
- * - Direct LevelDB persistence (no data loss on restart)
- *
- * @version 2.0.0 - Unified with Core StateManager
- * @author Mario Papaleo - JAELIS Foundation
- */
-
-const crypto = require('crypto');
-const EventEmitter = require('events');
-
-/**
- * Account abstraction - works for all VM types
- */
-class Account {
-    constructor(address, options = {}) {
-        this.address = address;
-        this.nonce = options.nonce || 0n;
-        this.balance = options.balance || 0n;
-        this.codeHash = options.codeHash || null;
-        this.storageRoot = options.storageRoot || null;
-
-        // VM-specific data
-        this.vmType = options.vmType || 'evm';
-        this.owner = options.owner || null;       // Solana: owner program
-        this.data = options.data || Buffer.alloc(0);  // Solana: account data
-        this.lamports = options.lamports || 0n;   // Solana: lamports
-        this.executable = options.executable || false;  // Solana: is program
-
-        // Move resources
-        this.resources = options.resources || new Map();
-
-        // TON
-        this.workchain = options.workchain || 0;
-        this.stateInit = options.stateInit || null;
-    }
-
-    toJSON() {
-        return {
-            address: this.address,
-            nonce: this.nonce.toString(),
-            balance: this.balance.toString(),
-            codeHash: this.codeHash,
-            storageRoot: this.storageRoot,
-            vmType: this.vmType,
-            owner: this.owner,
-            executable: this.executable,
-            lamports: this.lamports?.toString() || '0',
-            workchain: this.workchain
-        };
-    }
-
-    static fromJSON(json) {
-        return new Account(json.address, {
-            nonce: BigInt(json.nonce || 0),
-            balance: BigInt(json.balance || 0),
-            codeHash: json.codeHash,
-            storageRoot: json.storageRoot,
-            vmType: json.vmType || 'evm',
-            owner: json.owner,
-            executable: json.executable,
-            lamports: json.lamports ? BigInt(json.lamports) : 0n,
-            workchain: json.workchain || 0
-        });
-    }
-
-    /**
-     * Convert to Core StateManager format
-     */
-    toCoreFormat() {
-        return {
-            address: this.address,
-            balance: this.balance.toString(),
-            nonce: Number(this.nonce),
-            codeHash: this.codeHash,
-            storageRoot: this.storageRoot,
-            isContract: !!this.codeHash,
-            vmType: this.vmType,
-            owner: this.owner,
-            executable: this.executable,
-            lamports: this.lamports?.toString() || '0',
-            workchain: this.workchain,
-            lastUpdated: Date.now()
-        };
-    }
-
-    /**
-     * Create Account from Core StateManager format
-     */
-    static fromCoreFormat(coreAccount) {
-        return new Account(coreAccount.address, {
-            nonce: BigInt(coreAccount.nonce || 0),
-            balance: BigInt(coreAccount.balance || 0),
-            codeHash: coreAccount.codeHash,
-            storageRoot: coreAccount.storageRoot,
-            vmType: coreAccount.vmType || 'evm',
-            owner: coreAccount.owner,
-            executable: coreAccount.executable,
-            lamports: coreAccount.lamports ? BigInt(coreAccount.lamports) : 0n,
-            workchain: coreAccount.workchain || 0
-        });
-    }
-}
-
-/**
- * Contract storage abstraction (in-memory working copy)
- * Synced to LevelDB through Core StateManager
- */
-class ContractStorage {
-    constructor(address, coreState = null) {
-        this.address = address;
-        this._coreState = coreState;
-        this._slots = new Map();      // Local cache for batch operations
-        this.data = null;             // Solana account data
-        this.resources = new Map();   // Move resources
-    }
-
-    // EVM-style slot access
-    async getSlot(slot) {
-        const key = typeof slot === 'bigint' ? slot.toString(16) : slot;
-
-        // Try Core StateManager first (LevelDB)
-        if (this._coreState) {
-            try {
-                const value = await this._coreState.getContractStorage(this.address, key);
-                if (value && value !== '0x0') {
-                    return BigInt(value);
-                }
-            } catch (e) {
-                // Fall through to local cache
-            }
-        }
-
-        return this._slots.get(key) || 0n;
-    }
-
-    async setSlot(slot, value) {
-        const key = typeof slot === 'bigint' ? slot.toString(16) : slot;
-        this._slots.set(key, value);
-
-        // Persist to Core StateManager (LevelDB)
-        if (this._coreState) {
-            await this._coreState.setContractStorage(this.address, key, value.toString());
-        }
-    }
-
-    // Sync getSlot for compatibility
-    getSlotSync(slot) {
-        const key = typeof slot === 'bigint' ? slot.toString(16) : slot;
-        return this._slots.get(key) || 0n;
-    }
-
-    setSlotSync(slot, value) {
-        const key = typeof slot === 'bigint' ? slot.toString(16) : slot;
-        this._slots.set(key, value);
-        // Note: Won't persist until Core is connected
-    }
-
-    // Solana-style data access
-    getData(offset, length) {
-        if (!this.data) return Buffer.alloc(length);
-        return this.data.slice(offset, offset + length);
-    }
-
-    setData(offset, data) {
-        if (!this.data) {
-            this.data = Buffer.alloc(Math.max(offset + data.length, 1024));
-        }
-        if (offset + data.length > this.data.length) {
-            const newData = Buffer.alloc(offset + data.length);
-            this.data.copy(newData);
-            this.data = newData;
-        }
-        data.copy(this.data, offset);
-    }
-
-    // Move-style resource access
-    getResource(type) {
-        return this.resources.get(type);
-    }
-
-    setResource(type, value) {
-        this.resources.set(type, value);
-    }
-
-    hasResource(type) {
-        return this.resources.has(type);
-    }
-
-    // Get slots map for compatibility
-    get slots() {
-        return this._slots;
-    }
-}
-
-/**
- * Merkle Patricia Trie for state commitments
- * Delegates root calculation to Core StateManager
- */
-class StateTrie {
-    constructor(coreState = null) {
-        this._coreState = coreState;
-        this.root = null;
-        this._nodes = new Map(); // Local cache only
-    }
-
-    get(key) {
-        return this._nodes.get(this._hashKey(key));
-    }
-
-    put(key, value) {
-        const hash = this._hashKey(key);
-        this._nodes.set(hash, value);
-        this._updateRoot();
-    }
-
-    delete(key) {
-        const hash = this._hashKey(key);
-        this._nodes.delete(hash);
-        this._updateRoot();
-    }
-
-    getProof(key) {
-        return {
-            key,
-            value: this.get(key),
-            proof: []
-        };
-    }
-
-    verifyProof(key, value, proof) {
-        return true;
-    }
-
-    _hashKey(key) {
-        if (typeof key === 'string') {
-            return crypto.createHash('sha256').update(key).digest('hex');
-        }
-        if (Buffer.isBuffer(key)) {
-            return crypto.createHash('sha256').update(key).digest('hex');
-        }
-        return crypto.createHash('sha256').update(key.toString()).digest('hex');
-    }
-
-    _updateRoot() {
-        const allKeys = Array.from(this._nodes.keys()).sort();
-        const concat = allKeys.join('');
-        this.root = crypto.createHash('sha256').update(concat).digest('hex');
-    }
-
-    // Get nodes map for compatibility
-    get nodes() {
-        return this._nodes;
-    }
-}
-
-/**
- * JAELIS State Manager
- *
- * Unified state management for cross-VM execution.
- * ALL state operations delegate to Core StateManager for LevelDB persistence.
- */
-class StateManager extends EventEmitter {
-    constructor(config = {}) {
-        super();
-
-        this.config = config;
-
-        // Core StateManager reference (LevelDB backend)
-        this._coreState = null;
-        this._connected = false;
-
-        // Local caches for fast access (synced with Core/LevelDB)
-        this._accountCache = new Map();      // address → Account
-        this._contractCache = new Map();     // address → contract data
-        this._storageCache = new Map();      // address → ContractStorage
-
-        // State trie for commitments
-        this.stateTrie = new StateTrie();
-        this.storageTries = new Map();
-
-        // Cross-VM state mappings
-        this.vmAddressMappings = new Map();
-
-        // Checkpoint system for rollbacks
-        this.checkpoints = [];
-        this.journalEntries = [];
-
-        // Code cache
-        this.codeCache = new Map();
-        this.storageCache = new Map();
-
-        console.log('[State] VM StateManager initialized (LevelDB-backed)');
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // CORE STATEMANAGER CONNECTION
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    /**
-     * Connect to Core StateManager for LevelDB persistence
-     * This MUST be called before any state operations
-     */
-    connectCoreState(coreStateManager) {
-        if (!coreStateManager) {
-            throw new Error('Core StateManager is required for persistence');
-        }
-
-        this._coreState = coreStateManager;
-        this._connected = true;
-
-        // Update StateTrie reference
-        this.stateTrie._coreState = coreStateManager;
-
-        console.log('[State] ✅ Connected to Core StateManager (LevelDB)');
-        this.emit('connected', { coreState: coreStateManager });
-
-        return this;
-    }
-
-    /**
-     * Check if connected to Core StateManager
-     */
-    isConnected() {
-        return this._connected && this._coreState !== null;
-    }
-
-    /**
-     * Ensure connection before operations
-     */
-    _ensureConnected() {
-        if (!this._connected) {
-            console.warn('[State] ⚠️  Operating without Core StateManager - state will not persist!');
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // COMPATIBILITY GETTERS (For existing code that uses .accounts, .contracts)
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    /**
-     * Legacy accounts Map interface - backed by Core StateManager
-     */
-    get accounts() {
-        return new AccountsMapProxy(this);
-    }
-
-    /**
-     * Legacy contracts Map interface - backed by Core StateManager
-     */
-    get contracts() {
-        return new ContractsMapProxy(this);
-    }
-
-    /**
-     * Legacy storage Map interface - backed by Core StateManager
-     */
-    get storage() {
-        return this._storageCache;
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // ACCOUNT OPERATIONS (Persisted to LevelDB)
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    async getAccount(address) {
-        const normalized = this._normalizeAddress(address);
-
-        // Check local cache first
-        if (this._accountCache.has(normalized)) {
-            return this._accountCache.get(normalized);
-        }
-
-        // Try Core StateManager (LevelDB)
-        if (this._coreState) {
-            try {
-                const coreAccount = await this._coreState.getAccount(normalized);
-                if (coreAccount && (coreAccount.balance !== '0' || coreAccount.nonce > 0 || coreAccount.code)) {
-                    const account = Account.fromCoreFormat(coreAccount);
-                    this._accountCache.set(normalized, account);
-                    return account;
-                }
-            } catch (e) {
-                // Account doesn't exist in LevelDB
-            }
-        }
-
-        // Create new empty account
-        return new Account(normalized);
-    }
-
-    async setAccount(address, account) {
-        const normalized = this._normalizeAddress(address);
-
-        // Update local cache
-        this._accountCache.set(normalized, account);
-
-        // Persist to Core StateManager (LevelDB)
-        if (this._coreState) {
-            await this._coreState.putAccount(normalized, account.toCoreFormat());
-        }
-
-        this._journal('setAccount', { address: normalized, account: account.toJSON() });
-        this.stateTrie.put(normalized, account);
-
-        this.emit('accountUpdate', { address: normalized, account });
-    }
-
-    async accountExists(address) {
-        const normalized = this._normalizeAddress(address);
-
-        // Check local cache
-        if (this._accountCache.has(normalized)) {
-            return true;
-        }
-
-        // Check Core StateManager
-        if (this._coreState) {
-            const exists = await this._coreState.exist(normalized);
-            return exists;
-        }
-
-        return false;
-    }
-
-    async getBalance(address) {
-        const account = await this.getAccount(address);
-        return account.balance;
-    }
-
-    async setBalance(address, balance) {
-        const account = await this.getAccount(address);
-        const oldBalance = account.balance;
-        account.balance = BigInt(balance);
-        await this.setAccount(address, account);
-
-        this.emit('balanceChange', { address, oldBalance, newBalance: account.balance });
-    }
-
-    async getNonce(address) {
-        const account = await this.getAccount(address);
-        return account.nonce;
-    }
-
-    async incrementNonce(address) {
-        const account = await this.getAccount(address);
-        account.nonce++;
-        await this.setAccount(address, account);
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // CONTRACT OPERATIONS (Persisted to LevelDB)
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    async storeContract(address, contractData) {
-        const normalized = this._normalizeAddress(address);
-
-        const contractEntry = {
-            jir: contractData.jir,
-            sourceVM: contractData.sourceVM,
-            bytecode: contractData.bytecode,
-            deployedAt: contractData.deployedAt || Date.now(),
-            deployer: contractData.deployer,
-            codeHash: this._hashCode(contractData.bytecode)
-        };
-
-        // Update local cache
-        this._contractCache.set(normalized, contractEntry);
-
-        // Initialize storage with Core reference
-        const contractStorage = new ContractStorage(normalized, this._coreState);
-        this._storageCache.set(normalized, contractStorage);
-        this.storageTries.set(normalized, new StateTrie(this._coreState));
-
-        // Update account
-        const account = await this.getAccount(normalized);
-        account.codeHash = contractEntry.codeHash;
-        await this.setAccount(normalized, account);
-
-        // Persist to Core StateManager
-        if (this._coreState) {
-            // Store bytecode
-            await this._coreState.setCode(normalized, contractData.bytecode);
-
-            // Store metadata
-            if (this._coreState.setContractMetadata) {
-                await this._coreState.setContractMetadata(normalized, {
-                    sourceVM: contractData.sourceVM,
-                    deployedAt: contractEntry.deployedAt,
-                    deployer: contractData.deployer,
-                    codeHash: contractEntry.codeHash,
-                    hasJIR: !!contractData.jir
-                });
-            }
-        }
-
-        this._journal('storeContract', { address: normalized });
-
-        console.log(`[State] Contract stored: ${normalized.substring(0, 16)}... → LevelDB`);
-        this.emit('contractStored', { address: normalized, sourceVM: contractData.sourceVM });
-
-        return normalized;
-    }
-
-    async getContract(address) {
-        const normalized = this._normalizeAddress(address);
-
-        // Check local cache
-        if (this._contractCache.has(normalized)) {
-            return this._contractCache.get(normalized);
-        }
-
-        // Try Core StateManager
-        if (this._coreState) {
-            try {
-                const code = await this._coreState.getCode(normalized);
-                const metadata = this._coreState.getContractMetadata
-                    ? await this._coreState.getContractMetadata(normalized)
-                    : null;
-
-                if (code) {
-                    const contract = {
-                        bytecode: code,
-                        sourceVM: metadata?.sourceVM || 'evm',
-                        deployedAt: metadata?.deployedAt || Date.now(),
-                        deployer: metadata?.deployer,
-                        codeHash: metadata?.codeHash || this._hashCode(code)
-                    };
-
-                    this._contractCache.set(normalized, contract);
-                    return contract;
-                }
-            } catch (e) {
-                // Contract doesn't exist
-            }
-        }
-
-        return null;
-    }
-
-    async getCode(address) {
-        const normalized = this._normalizeAddress(address);
-
-        // Check local cache
-        if (this.codeCache.has(normalized)) {
-            return this.codeCache.get(normalized);
-        }
-
-        // Try Core StateManager
-        if (this._coreState) {
-            const code = await this._coreState.getCode(normalized);
-            if (code) {
-                this.codeCache.set(normalized, code);
-                return code;
-            }
-        }
-
-        const contract = await this.getContract(normalized);
-        if (contract) {
-            this.codeCache.set(normalized, contract.bytecode);
-            return contract.bytecode;
-        }
-
-        return null;
-    }
-
-    async getCodeHash(address) {
-        const account = await this.getAccount(address);
-        return account.codeHash;
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // STORAGE OPERATIONS (Persisted to LevelDB)
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    async getStorage(address, key) {
-        const normalized = this._normalizeAddress(address);
-        const normalKey = this._normalizeKey(key);
-
-        // Check local storage cache
-        const cacheKey = `${normalized}:${normalKey}`;
-        if (this.storageCache.has(cacheKey)) {
-            return this.storageCache.get(cacheKey);
-        }
-
-        // Try Core StateManager (LevelDB)
-        if (this._coreState) {
-            try {
-                const value = await this._coreState.getStorage(normalized, normalKey);
-                if (value && value !== '0x' + '0'.repeat(64)) {
-                    const bigValue = typeof value === 'string' && value.startsWith('0x')
-                        ? BigInt(value)
-                        : BigInt(value || 0);
-                    this.storageCache.set(cacheKey, bigValue);
-                    return bigValue;
-                }
-            } catch (e) {
-                // Storage slot empty
-            }
-        }
-
-        // Check ContractStorage
-        const storage = this._storageCache.get(normalized);
-        if (storage) {
-            return storage.getSlotSync(key);
-        }
-
-        return 0n;
-    }
-
-    async setStorage(address, key, value) {
-        const normalized = this._normalizeAddress(address);
-        const normalKey = this._normalizeKey(key);
-
-        // Get or create ContractStorage
-        let storage = this._storageCache.get(normalized);
-        if (!storage) {
-            storage = new ContractStorage(normalized, this._coreState);
-            this._storageCache.set(normalized, storage);
-        }
-
-        const oldValue = storage.getSlotSync(key);
-        storage.setSlotSync(key, value);
-
-        // Update storage trie
-        let storageTrie = this.storageTries.get(normalized);
-        if (!storageTrie) {
-            storageTrie = new StateTrie(this._coreState);
-            this.storageTries.set(normalized, storageTrie);
-        }
-        storageTrie.put(key.toString(), value);
-
-        // Update cache
-        const cacheKey = `${normalized}:${normalKey}`;
-        this.storageCache.set(cacheKey, value);
-
-        // Persist to Core StateManager (LevelDB)
-        if (this._coreState) {
-            const storageValue = typeof value === 'bigint' ? '0x' + value.toString(16).padStart(64, '0') : value;
-            await this._coreState.setStorage(normalized, normalKey, storageValue);
-        }
-
-        this._journal('setStorage', { address: normalized, key, oldValue, newValue: value });
-
-        this.emit('storageUpdate', { address: normalized, key, oldValue, newValue: value });
-    }
-
-    async clearStorage(address) {
-        const normalized = this._normalizeAddress(address);
-        this._storageCache.delete(normalized);
-        this.storageTries.delete(normalized);
-
-        // Clear cache entries for this address
-        for (const key of this.storageCache.keys()) {
-            if (key.startsWith(normalized)) {
-                this.storageCache.delete(key);
-            }
-        }
-    }
-
-    // Solana-style account data access
-    async getAccountData(address, offset = 0, length = -1) {
-        const normalized = this._normalizeAddress(address);
-        const storage = this._storageCache.get(normalized);
-
-        if (!storage || !storage.data) {
-            return Buffer.alloc(0);
-        }
-
-        if (length === -1) {
-            return storage.data.slice(offset);
-        }
-
-        return storage.getData(offset, length);
-    }
-
-    async setAccountData(address, offset, data) {
-        const normalized = this._normalizeAddress(address);
-
-        let storage = this._storageCache.get(normalized);
-        if (!storage) {
-            storage = new ContractStorage(normalized, this._coreState);
-            this._storageCache.set(normalized, storage);
-        }
-
-        storage.setData(offset, data);
-        this._journal('setAccountData', { address: normalized, offset, length: data.length });
-    }
-
-    // Move-style resource access
-    async getResource(address, resourceType) {
-        const normalized = this._normalizeAddress(address);
-        const storage = this._storageCache.get(normalized);
-
-        if (!storage) {
-            return null;
-        }
-
-        return storage.getResource(resourceType);
-    }
-
-    async setResource(address, resourceType, value) {
-        const normalized = this._normalizeAddress(address);
-
-        let storage = this._storageCache.get(normalized);
-        if (!storage) {
-            storage = new ContractStorage(normalized, this._coreState);
-            this._storageCache.set(normalized, storage);
-        }
-
-        storage.setResource(resourceType, value);
-        this._journal('setResource', { address: normalized, resourceType });
-    }
-
-    async hasResource(address, resourceType) {
-        const normalized = this._normalizeAddress(address);
-        const storage = this._storageCache.get(normalized);
-
-        if (!storage) {
-            return false;
-        }
-
-        return storage.hasResource(resourceType);
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // CROSS-VM STATE ACCESS
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    async mapAddress(sourceVM, sourceAddress, targetVM, targetAddress) {
-        const key = `${sourceVM}:${sourceAddress}`;
-        const value = `${targetVM}:${targetAddress}`;
-
-        this.vmAddressMappings.set(key, value);
-        this.vmAddressMappings.set(value, key);
-
-        console.log(`[State] Address mapping: ${sourceVM}:${sourceAddress.substring(0, 10)}... <-> ${targetVM}:${targetAddress.substring(0, 10)}...`);
-    }
-
-    async getMappedAddress(sourceVM, sourceAddress, targetVM) {
-        const key = `${sourceVM}:${sourceAddress}`;
-        const mapping = this.vmAddressMappings.get(key);
-
-        if (mapping && mapping.startsWith(targetVM + ':')) {
-            return mapping.substring(targetVM.length + 1);
-        }
-
-        return null;
-    }
-
-    async crossVMRead(sourceVM, targetVM, targetAddress, key) {
-        const normalized = this._normalizeAddress(targetAddress);
-        const contract = await this.getContract(normalized);
-
-        if (!contract || contract.sourceVM !== targetVM) {
-            throw new Error(`Contract ${targetAddress} is not a ${targetVM} contract`);
-        }
-
-        const translatedKey = await this._translateStorageKey(key, sourceVM, targetVM);
-
-        return this.getStorage(normalized, translatedKey);
-    }
-
-    async _translateStorageKey(key, sourceVM, targetVM) {
-        if (sourceVM === targetVM) {
-            return key;
-        }
-
-        if (sourceVM === 'evm' && targetVM === 'svm') {
-            return BigInt(key) * 32n;
-        }
-
-        if (sourceVM === 'svm' && targetVM === 'evm') {
-            return BigInt(key) / 32n;
-        }
-
-        return key;
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // CHECKPOINT & ROLLBACK
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    checkpoint() {
-        const checkpointId = this.checkpoints.length;
-
-        // Use Core StateManager's snapshot if available
-        let coreSnapshotId = null;
-        if (this._coreState && this._coreState.snapshot) {
-            coreSnapshotId = this._coreState.snapshot();
-        }
-
-        this.checkpoints.push({
-            id: checkpointId,
-            coreSnapshotId,
-            journalLength: this.journalEntries.length,
-            stateRoot: this.getStateRoot(),
-            timestamp: Date.now()
-        });
-
-        console.log(`[State] Checkpoint created: ${checkpointId}`);
-        return checkpointId;
-    }
-
-    async commit(checkpointId) {
-        if (checkpointId !== this.checkpoints.length - 1) {
-            throw new Error('Can only commit latest checkpoint');
-        }
-
-        this.checkpoints.pop();
-
-        // Commit to Core StateManager
-        if (this._coreState && this._coreState.finalise) {
-            await this._coreState.finalise();
-        }
-
-        console.log(`[State] Checkpoint ${checkpointId} committed → LevelDB`);
-    }
-
-    async revert(checkpointId) {
-        const checkpoint = this.checkpoints[checkpointId];
-        if (!checkpoint) {
-            throw new Error(`Checkpoint ${checkpointId} not found`);
-        }
-
-        // Revert Core StateManager if available
-        if (this._coreState && this._coreState.revertToSnapshot && checkpoint.coreSnapshotId !== null) {
-            this._coreState.revertToSnapshot(checkpoint.coreSnapshotId);
-        }
-
-        // Replay journal in reverse to undo changes
-        const entriesToUndo = this.journalEntries.slice(checkpoint.journalLength);
-
-        for (let i = entriesToUndo.length - 1; i >= 0; i--) {
-            const entry = entriesToUndo[i];
-            await this._undoJournalEntry(entry);
-        }
-
-        this.journalEntries.length = checkpoint.journalLength;
-        this.checkpoints.length = checkpointId;
-
-        // Clear local caches (will re-fetch from Core/LevelDB)
-        this._accountCache.clear();
-        this._contractCache.clear();
-
-        console.log(`[State] Reverted to checkpoint ${checkpointId}`);
-    }
-
-    _journal(operation, data) {
-        this.journalEntries.push({
-            operation,
-            data,
-            timestamp: Date.now()
-        });
-    }
-
-    async _undoJournalEntry(entry) {
-        switch (entry.operation) {
-            case 'setStorage':
-                await this.setStorage(entry.data.address, entry.data.key, entry.data.oldValue);
-                break;
-
-            case 'setAccount':
-                // Would restore previous account state
-                break;
-
-            case 'storeContract':
-                this._contractCache.delete(entry.data.address);
-                break;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // STATE ROOTS & PROOFS
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    getStateRoot() {
-        // Use Core StateManager's state root if available
-        if (this._coreState && this._coreState._stateRoot) {
-            return this._coreState._stateRoot;
-        }
-        return this.stateTrie.root || '0x0000000000000000000000000000000000000000000000000000000000000000';
-    }
-
-    getStorageRoot(address) {
-        const normalized = this._normalizeAddress(address);
-        const storageTrie = this.storageTries.get(normalized);
-        return storageTrie?.root || '0x0000000000000000000000000000000000000000000000000000000000000000';
-    }
-
-    async getStateProof(address) {
-        const normalized = this._normalizeAddress(address);
-        return this.stateTrie.getProof(normalized);
-    }
-
-    async getStorageProof(address, key) {
-        const normalized = this._normalizeAddress(address);
-        const storageTrie = this.storageTries.get(normalized);
-
-        if (!storageTrie) {
-            return null;
-        }
-
-        return storageTrie.getProof(key.toString());
-    }
-
-    async verifyStateProof(address, proof) {
-        const normalized = this._normalizeAddress(address);
-        return this.stateTrie.verifyProof(normalized, proof.value, proof.proof);
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // HELPER METHODS
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    _normalizeAddress(address) {
-        if (typeof address === 'string') {
-            if (address.startsWith('0x')) {
-                return address.toLowerCase();
-            }
-            return '0x' + address.toLowerCase();
-        }
-
-        if (Buffer.isBuffer(address)) {
-            return '0x' + address.toString('hex');
-        }
-
-        if (typeof address === 'bigint') {
-            return '0x' + address.toString(16).padStart(40, '0');
-        }
-
-        return address.toString();
-    }
-
-    _normalizeKey(key) {
-        if (typeof key === 'bigint') {
-            return '0x' + key.toString(16).padStart(64, '0');
-        }
-        if (typeof key === 'string') {
-            const k = key.toLowerCase().replace('0x', '');
-            return '0x' + k.padStart(64, '0');
-        }
-        return '0x' + key.toString().padStart(64, '0');
-    }
-
-    _hashCode(code) {
-        if (!code) return null;
-
-        const buffer = Buffer.isBuffer(code) ? code : Buffer.from(code);
-        return crypto.createHash('sha256').update(buffer).digest('hex');
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════════
-    // STATS & DEBUG
-    // ═══════════════════════════════════════════════════════════════════════════
-
-    getStats() {
-        // Get Core StateManager stats if available
-        let coreStats = {};
-        if (this._coreState && this._coreState.getStats) {
-            coreStats = this._coreState.getStats();
-        }
-
-        return {
-            connected: this._connected,
-            accountsCached: this._accountCache.size,
-            contractsCached: this._contractCache.size,
-            storageCached: this._storageCache.size,
-            stateRoot: this.getStateRoot(),
-            checkpoints: this.checkpoints.length,
-            journalEntries: this.journalEntries.length,
-            codeCache: this.codeCache.size,
-            storageCache: this.storageCache.size,
-            // Core stats
-            coreAccountsCached: coreStats.accountsCached || 0,
-            coreStorageSlots: coreStats.totalStorageSlots || 0,
-            levelDBConnected: !!this._coreState?._storage
-        };
-    }
-
-    clearCaches() {
-        this.codeCache.clear();
-        this.storageCache.clear();
-        this._accountCache.clear();
-        this._contractCache.clear();
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// PROXY CLASSES FOR LEGACY COMPATIBILITY
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Accounts Map Proxy - provides Map-like interface backed by Core StateManager
- */
-class AccountsMapProxy {
-    constructor(vmState) {
-        this._vm = vmState;
-    }
-
-    get(address) {
-        return this._vm._accountCache.get(this._vm._normalizeAddress(address));
-    }
-
-    set(address, account) {
-        const normalized = this._vm._normalizeAddress(address);
-        this._vm._accountCache.set(normalized, account);
-
-        // Persist to Core (async, fire and forget for sync compatibility)
-        if (this._vm._coreState) {
-            this._vm._coreState.putAccount(normalized, account.toCoreFormat?.() || account)
-                .catch(err => console.error('[State] Account persist error:', err));
-        }
-    }
-
-    has(address) {
-        return this._vm._accountCache.has(this._vm._normalizeAddress(address));
-    }
-
-    delete(address) {
-        this._vm._accountCache.delete(this._vm._normalizeAddress(address));
-    }
-
-    get size() {
-        return this._vm._accountCache.size;
-    }
-
-    keys() {
-        return this._vm._accountCache.keys();
-    }
-
-    values() {
-        return this._vm._accountCache.values();
-    }
-
-    entries() {
-        return this._vm._accountCache.entries();
-    }
-
-    [Symbol.iterator]() {
-        return this._vm._accountCache[Symbol.iterator]();
-    }
-}
-
-/**
- * Contracts Map Proxy - provides Map-like interface backed by Core StateManager
- */
-class ContractsMapProxy {
-    constructor(vmState) {
-        this._vm = vmState;
-    }
-
-    get(address) {
-        return this._vm._contractCache.get(this._vm._normalizeAddress(address));
-    }
-
-    set(address, contract) {
-        const normalized = this._vm._normalizeAddress(address);
-        this._vm._contractCache.set(normalized, contract);
-
-        // Persist to Core (async)
-        if (this._vm._coreState && contract.bytecode) {
-            this._vm._coreState.setCode(normalized, contract.bytecode)
-                .catch(err => console.error('[State] Contract persist error:', err));
-        }
-    }
-
-    has(address) {
-        return this._vm._contractCache.has(this._vm._normalizeAddress(address));
-    }
-
-    delete(address) {
-        this._vm._contractCache.delete(this._vm._normalizeAddress(address));
-    }
-
-    get size() {
-        return this._vm._contractCache.size;
-    }
-
-    keys() {
-        return this._vm._contractCache.keys();
-    }
-
-    values() {
-        return this._vm._contractCache.values();
-    }
-
-    entries() {
-        return this._vm._contractCache.entries();
-    }
-
-    [Symbol.iterator]() {
-        return this._vm._contractCache[Symbol.iterator]();
-    }
-}
-
-// Export classes
-module.exports = StateManager;
-module.exports.Account = Account;
-module.exports.ContractStorage = ContractStorage;
-module.exports.StateTrie = StateTrie;