jaelis-node 1.3.1 → 1.4.1

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

@@ -0,0 +1,411 @@
+/**
+ * JAELIS VM ADAPTERS
+ *
+ * Provides chain-specific interfaces for the Universal VM
+ *
+ * @version 0.1.0
+ * @author Mario Papaleo - JAELIS Foundation
+ */
+
+const EVMAdapter = require('./evm-adapter');
+const SVMAdapter = require('./svm-adapter');
+
+/**
+ * Move VM Adapter (Aptos/Sui)
+ */
+class MoveAdapter {
+    constructor(vm) {
+        this.vm = vm;
+        this.modules = new Map();
+        this.resources = new Map();
+    }
+
+    async publishModule(bytecode, options = {}) {
+        const moduleAddress = options.address || this.generateModuleAddress(bytecode);
+
+        this.modules.set(moduleAddress, {
+            bytecode,
+            metadata: options.metadata || {}
+        });
+
+        return this.vm.deployBytecode(bytecode, 'move', {
+            ...options,
+            deployer: moduleAddress
+        });
+    }
+
+    async executeFunction(moduleAddress, moduleName, functionName, typeArgs = [], args = [], options = {}) {
+        const callData = this.encodeEntryFunction(moduleName, functionName, typeArgs, args);
+
+        return this.vm.execute(moduleAddress, functionName, callData, options);
+    }
+
+    encodeEntryFunction(moduleName, functionName, typeArgs, args) {
+        // BCS encoding for Move
+        const buffers = [];
+
+        // Module name
+        buffers.push(this.bcsEncodeString(moduleName));
+
+        // Function name
+        buffers.push(this.bcsEncodeString(functionName));
+
+        // Type arguments count
+        buffers.push(Buffer.from([typeArgs.length]));
+
+        // Arguments count
+        buffers.push(Buffer.from([args.length]));
+
+        // Encode each argument
+        for (const arg of args) {
+            buffers.push(this.bcsEncodeValue(arg));
+        }
+
+        return Buffer.concat(buffers);
+    }
+
+    bcsEncodeString(str) {
+        const strBuf = Buffer.from(str, 'utf8');
+        const lenBuf = Buffer.alloc(4);
+        lenBuf.writeUInt32LE(strBuf.length);
+        return Buffer.concat([lenBuf, strBuf]);
+    }
+
+    bcsEncodeValue(value) {
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            const buf = Buffer.alloc(8);
+            buf.writeBigUInt64LE(BigInt(value));
+            return buf;
+        }
+        if (typeof value === 'string') {
+            return this.bcsEncodeString(value);
+        }
+        if (typeof value === 'boolean') {
+            return Buffer.from([value ? 1 : 0]);
+        }
+        return Buffer.alloc(0);
+    }
+
+    generateModuleAddress(bytecode) {
+        const crypto = require('crypto');
+        return '0x' + crypto.createHash('sha256').update(bytecode).digest('hex').substring(0, 64);
+    }
+
+    async getResource(address, resourceType) {
+        const key = `${address}:${resourceType}`;
+        return this.resources.get(key);
+    }
+
+    async setResource(address, resourceType, value) {
+        const key = `${address}:${resourceType}`;
+        this.resources.set(key, value);
+    }
+}
+
+/**
+ * TON VM Adapter
+ */
+class TVMAdapter {
+    constructor(vm) {
+        this.vm = vm;
+        this.contracts = new Map();
+    }
+
+    async deployContract(code, data, options = {}) {
+        // TON uses code + data cells
+        const stateInit = this.createStateInit(code, data);
+        const address = this.calculateAddress(stateInit, options.workchain || 0);
+
+        return this.vm.deployBytecode(code, 'tvm', {
+            ...options,
+            address,
+            stateInit
+        });
+    }
+
+    async sendMessage(address, body, options = {}) {
+        return this.vm.execute(address, 'recv_internal', body, options);
+    }
+
+    async sendExternalMessage(address, body, options = {}) {
+        return this.vm.execute(address, 'recv_external', body, options);
+    }
+
+    createStateInit(code, data) {
+        // Simplified state init
+        return {
+            code,
+            data,
+            libraries: null,
+            splitDepth: null,
+            tickTock: null
+        };
+    }
+
+    calculateAddress(stateInit, workchain) {
+        const crypto = require('crypto');
+        const hash = crypto.createHash('sha256')
+            .update(JSON.stringify(stateInit))
+            .digest('hex');
+
+        return `${workchain}:${hash}`;
+    }
+
+    // Cell serialization (simplified)
+    createCell(data) {
+        return {
+            bits: data,
+            refs: []
+        };
+    }
+
+    parseCell(cell) {
+        return cell.bits;
+    }
+}
+
+/**
+ * WASM Adapter (Cosmos, Polkadot, NEAR)
+ */
+class WASMAdapter {
+    constructor(vm) {
+        this.vm = vm;
+        this.contracts = new Map();
+    }
+
+    async instantiate(wasmCode, initMsg, options = {}) {
+        const codeId = this.storeCode(wasmCode);
+        const address = this.generateAddress(codeId, options.salt);
+
+        // Execute instantiate
+        const result = await this.vm.deployBytecode(wasmCode, 'wasm', {
+            ...options,
+            address,
+            initMsg
+        });
+
+        this.contracts.set(address, { codeId, admin: options.admin });
+
+        return { ...result, address };
+    }
+
+    async execute(address, msg, options = {}) {
+        const msgBuffer = Buffer.from(JSON.stringify(msg));
+        return this.vm.execute(address, 'execute', msgBuffer, options);
+    }
+
+    async query(address, msg) {
+        const msgBuffer = Buffer.from(JSON.stringify(msg));
+        const result = await this.vm.execute(address, 'query', msgBuffer, {
+            readOnly: true
+        });
+
+        if (result.returnValue) {
+            try {
+                return JSON.parse(result.returnValue.toString());
+            } catch {
+                return result.returnValue;
+            }
+        }
+        return null;
+    }
+
+    storeCode(wasmCode) {
+        const crypto = require('crypto');
+        return crypto.createHash('sha256').update(wasmCode).digest('hex');
+    }
+
+    generateAddress(codeId, salt) {
+        const crypto = require('crypto');
+        const input = salt ? `${codeId}${salt}` : `${codeId}${Date.now()}`;
+        return crypto.createHash('sha256').update(input).digest('hex').substring(0, 40);
+    }
+}
+
+/**
+ * Cairo Adapter (Starknet)
+ */
+class CairoAdapter {
+    constructor(vm) {
+        this.vm = vm;
+        this.classes = new Map();
+        this.contracts = new Map();
+    }
+
+    async declareClass(sierraCode, casmCode) {
+        const crypto = require('crypto');
+        const classHash = crypto.createHash('sha256')
+            .update(sierraCode)
+            .digest('hex');
+
+        this.classes.set(classHash, { sierra: sierraCode, casm: casmCode });
+
+        return { classHash };
+    }
+
+    async deploy(classHash, constructorCalldata, options = {}) {
+        const classData = this.classes.get(classHash);
+        if (!classData) {
+            throw new Error(`Class not found: ${classHash}`);
+        }
+
+        const address = this.calculateContractAddress(classHash, constructorCalldata, options.salt);
+
+        const result = await this.vm.deployBytecode(classData.casm, 'cairo', {
+            ...options,
+            address,
+            constructorCalldata
+        });
+
+        this.contracts.set(address, { classHash });
+
+        return { ...result, address };
+    }
+
+    async invoke(address, selector, calldata, options = {}) {
+        return this.vm.execute(address, selector, calldata, options);
+    }
+
+    async call(address, selector, calldata) {
+        return this.vm.execute(address, selector, calldata, { readOnly: true });
+    }
+
+    calculateContractAddress(classHash, constructorCalldata, salt) {
+        const crypto = require('crypto');
+        const input = `${classHash}${JSON.stringify(constructorCalldata)}${salt || ''}`;
+        return '0x' + crypto.createHash('sha256').update(input).digest('hex').substring(0, 64);
+    }
+
+    // Felt252 operations
+    feltToString(felt) {
+        return BigInt(felt).toString(16);
+    }
+
+    stringToFelt(str) {
+        let result = 0n;
+        for (let i = 0; i < str.length; i++) {
+            result = result * 256n + BigInt(str.charCodeAt(i));
+        }
+        return result;
+    }
+}
+
+/**
+ * Bitcoin Script Adapter
+ */
+class BitcoinAdapter {
+    constructor(vm) {
+        this.vm = vm;
+        this.utxos = new Map();
+    }
+
+    async executeScript(script, stack = []) {
+        const result = await this.vm.execute('bitcoin', 'execute', script, {
+            stack
+        });
+
+        return {
+            success: result.returnValue !== 0,
+            stack: result.stateChanges?.stack || []
+        };
+    }
+
+    createP2PKH(pubkeyHash) {
+        // OP_DUP OP_HASH160 <pubkeyHash> OP_EQUALVERIFY OP_CHECKSIG
+        return Buffer.concat([
+            Buffer.from([0x76, 0xA9, 0x14]),  // OP_DUP OP_HASH160 PUSH20
+            pubkeyHash,
+            Buffer.from([0x88, 0xAC])  // OP_EQUALVERIFY OP_CHECKSIG
+        ]);
+    }
+
+    createP2SH(scriptHash) {
+        // OP_HASH160 <scriptHash> OP_EQUAL
+        return Buffer.concat([
+            Buffer.from([0xA9, 0x14]),  // OP_HASH160 PUSH20
+            scriptHash,
+            Buffer.from([0x87])  // OP_EQUAL
+        ]);
+    }
+
+    createP2WPKH(pubkeyHash) {
+        // OP_0 <pubkeyHash>
+        return Buffer.concat([
+            Buffer.from([0x00, 0x14]),  // OP_0 PUSH20
+            pubkeyHash
+        ]);
+    }
+
+    createMultisig(m, pubkeys) {
+        // OP_M <pubkeys...> OP_N OP_CHECKMULTISIG
+        const n = pubkeys.length;
+        const parts = [Buffer.from([0x50 + m])];  // OP_M
+
+        for (const pubkey of pubkeys) {
+            parts.push(Buffer.from([pubkey.length]));
+            parts.push(pubkey);
+        }
+
+        parts.push(Buffer.from([0x50 + n]));  // OP_N
+        parts.push(Buffer.from([0xAE]));  // OP_CHECKMULTISIG
+
+        return Buffer.concat(parts);
+    }
+}
+
+/**
+ * Adapter Factory
+ */
+class AdapterFactory {
+    constructor(vm) {
+        this.vm = vm;
+        this.adapters = new Map();
+    }
+
+    getAdapter(vmType) {
+        if (this.adapters.has(vmType)) {
+            return this.adapters.get(vmType);
+        }
+
+        let adapter;
+        switch (vmType) {
+            case 'evm':
+                adapter = new EVMAdapter(this.vm);
+                break;
+            case 'svm':
+                adapter = new SVMAdapter(this.vm);
+                break;
+            case 'move':
+                adapter = new MoveAdapter(this.vm);
+                break;
+            case 'tvm':
+                adapter = new TVMAdapter(this.vm);
+                break;
+            case 'wasm':
+                adapter = new WASMAdapter(this.vm);
+                break;
+            case 'cairo':
+                adapter = new CairoAdapter(this.vm);
+                break;
+            case 'bitcoin':
+                adapter = new BitcoinAdapter(this.vm);
+                break;
+            default:
+                throw new Error(`Unknown VM type: ${vmType}`);
+        }
+
+        this.adapters.set(vmType, adapter);
+        return adapter;
+    }
+}
+
+module.exports = {
+    EVMAdapter,
+    SVMAdapter,
+    MoveAdapter,
+    TVMAdapter,
+    WASMAdapter,
+    CairoAdapter,
+    BitcoinAdapter,
+    AdapterFactory
+};