jaelis-node 1.3.2 → 1.5.0

package/lib/JAELIS-VM/lib/adapters/svm-adapter.js

@@ -0,0 +1,457 @@
+/**
+ * SOLANA VM (SVM) ADAPTER
+ *
+ * Provides Solana-compatible interface for JAELIS Universal VM
+ *
+ * Features:
+ * - Anchor IDL support
+ * - Account model emulation
+ * - BPF program execution
+ * - Cross-Program Invocation (CPI)
+ * - Program Derived Addresses (PDA)
+ *
+ * @version 0.1.0
+ * @author Mario Papaleo - JAELIS Foundation
+ */
+
+const crypto = require('crypto');
+
+// Solana system program addresses
+const SYSTEM_PROGRAMS = {
+    SYSTEM_PROGRAM: '11111111111111111111111111111111',
+    TOKEN_PROGRAM: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+    TOKEN_2022_PROGRAM: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+    ASSOCIATED_TOKEN_PROGRAM: 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL',
+    RENT_PROGRAM: 'SysvarRent111111111111111111111111111111111',
+    CLOCK_PROGRAM: 'SysvarC1ock11111111111111111111111111111111'
+};
+
+// Borsh serialization types
+const BORSH_TYPES = {
+    u8: { size: 1 },
+    u16: { size: 2 },
+    u32: { size: 4 },
+    u64: { size: 8 },
+    u128: { size: 16 },
+    i8: { size: 1 },
+    i16: { size: 2 },
+    i32: { size: 4 },
+    i64: { size: 8 },
+    i128: { size: 16 },
+    bool: { size: 1 },
+    pubkey: { size: 32 },
+    string: { size: null, dynamic: true },
+    vec: { size: null, dynamic: true }
+};
+
+class SVMAdapter {
+    constructor(vm) {
+        this.vm = vm;
+
+        // Program accounts
+        this.programs = new Map();
+
+        // Accounts (Solana's data model)
+        this.accounts = new Map();
+
+        // PDAs cache
+        this.pdaCache = new Map();
+    }
+
+    /**
+     * Deploy Solana program
+     */
+    async deployProgram(bytecode, options = {}) {
+        // Generate program ID
+        const programId = options.programId || this.generateProgramId(bytecode);
+
+        // Create program account
+        const programAccount = {
+            lamports: 1_000_000_000n,  // 1 SOL rent exempt
+            data: bytecode,
+            owner: SYSTEM_PROGRAMS.SYSTEM_PROGRAM,
+            executable: true,
+            rentEpoch: 0
+        };
+
+        this.programs.set(programId, {
+            bytecode,
+            idl: options.idl || null
+        });
+
+        // Store in VM
+        const result = await this.vm.deployBytecode(bytecode, 'svm', {
+            ...options,
+            deployer: programId
+        });
+
+        return {
+            ...result,
+            programId
+        };
+    }
+
+    /**
+     * Execute instruction
+     */
+    async executeInstruction(programId, instruction, accounts, signers = []) {
+        // Build transaction message
+        const message = {
+            header: {
+                numRequiredSignatures: signers.length,
+                numReadonlySignedAccounts: 0,
+                numReadonlyUnsignedAccounts: 0
+            },
+            accountKeys: accounts.map(a => a.pubkey),
+            recentBlockhash: this.getRecentBlockhash(),
+            instructions: [{
+                programIdIndex: accounts.findIndex(a => a.pubkey === programId),
+                accounts: accounts.map((_, i) => i),
+                data: instruction
+            }]
+        };
+
+        // Prepare account infos
+        const accountInfos = accounts.map(acc => ({
+            pubkey: acc.pubkey,
+            isSigner: acc.isSigner || false,
+            isWritable: acc.isWritable || false,
+            lamports: this.getAccount(acc.pubkey)?.lamports || 0n,
+            data: this.getAccount(acc.pubkey)?.data || Buffer.alloc(0),
+            owner: this.getAccount(acc.pubkey)?.owner || SYSTEM_PROGRAMS.SYSTEM_PROGRAM,
+            executable: this.getAccount(acc.pubkey)?.executable || false,
+            rentEpoch: 0
+        }));
+
+        // Execute on VM
+        const result = await this.vm.execute(programId, 'process_instruction', instruction, {
+            accounts: accountInfos,
+            signers
+        });
+
+        // Apply state changes
+        if (result.success && result.stateChanges) {
+            for (const change of result.stateChanges) {
+                if (change.type === 'account') {
+                    this.accounts.set(change.pubkey, change.data);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Anchor-style instruction execution
+     */
+    async anchorExecute(programId, methodName, args, accounts, options = {}) {
+        const program = this.programs.get(programId);
+
+        if (!program?.idl) {
+            throw new Error('Program IDL not found');
+        }
+
+        // Find instruction in IDL
+        const instruction = program.idl.instructions?.find(i => i.name === methodName);
+        if (!instruction) {
+            throw new Error(`Instruction not found: ${methodName}`);
+        }
+
+        // Encode instruction data using Anchor format
+        // First 8 bytes: instruction discriminator (sha256 of "global:method_name")[0:8]
+        const discriminator = this.getInstructionDiscriminator(methodName);
+
+        // Serialize arguments using Borsh
+        const serializedArgs = this.borshSerialize(instruction.args, args);
+
+        const instructionData = Buffer.concat([discriminator, serializedArgs]);
+
+        return this.executeInstruction(programId, instructionData, accounts, options.signers);
+    }
+
+    /**
+     * Create account
+     */
+    async createAccount(payer, newAccount, space, programOwner) {
+        const lamports = this.calculateRent(space);
+
+        this.accounts.set(newAccount, {
+            lamports,
+            data: Buffer.alloc(space),
+            owner: programOwner,
+            executable: false,
+            rentEpoch: 0
+        });
+
+        // Deduct from payer
+        const payerAccount = this.getAccount(payer);
+        if (payerAccount) {
+            payerAccount.lamports -= lamports;
+        }
+
+        return { success: true };
+    }
+
+    /**
+     * Transfer SOL
+     */
+    async transfer(from, to, amount) {
+        const fromAccount = this.getAccount(from);
+        const toAccount = this.getAccount(to) || {
+            lamports: 0n,
+            data: Buffer.alloc(0),
+            owner: SYSTEM_PROGRAMS.SYSTEM_PROGRAM,
+            executable: false,
+            rentEpoch: 0
+        };
+
+        if (!fromAccount || fromAccount.lamports < BigInt(amount)) {
+            throw new Error('Insufficient balance');
+        }
+
+        fromAccount.lamports -= BigInt(amount);
+        toAccount.lamports += BigInt(amount);
+
+        this.accounts.set(to, toAccount);
+
+        return { success: true };
+    }
+
+    /**
+     * Find Program Derived Address (PDA)
+     */
+    findProgramAddress(seeds, programId) {
+        const cacheKey = `${programId}:${seeds.map(s => s.toString('hex')).join(':')}`;
+
+        if (this.pdaCache.has(cacheKey)) {
+            return this.pdaCache.get(cacheKey);
+        }
+
+        // Try bump seeds from 255 down to 0
+        for (let bump = 255; bump >= 0; bump--) {
+            const seedsWithBump = [...seeds, Buffer.from([bump])];
+            const address = this.createProgramAddress(seedsWithBump, programId);
+
+            if (address && !this.isOnCurve(address)) {
+                const result = { address, bump };
+                this.pdaCache.set(cacheKey, result);
+                return result;
+            }
+        }
+
+        throw new Error('Unable to find PDA');
+    }
+
+    /**
+     * Create program address
+     */
+    createProgramAddress(seeds, programId) {
+        // SHA256(seeds || programId || "ProgramDerivedAddress")
+        const hash = crypto.createHash('sha256');
+
+        for (const seed of seeds) {
+            if (seed.length > 32) {
+                throw new Error('Seed too long');
+            }
+            hash.update(seed);
+        }
+
+        hash.update(Buffer.from(programId.replace('0x', ''), 'hex'));
+        hash.update(Buffer.from('ProgramDerivedAddress'));
+
+        return hash.digest('hex');
+    }
+
+    /**
+     * Check if public key is on ed25519 curve
+     */
+    isOnCurve(pubkey) {
+        // Simplified check - real implementation would verify ed25519
+        // PDAs should NOT be on the curve
+        const bytes = Buffer.from(pubkey, 'hex');
+        return bytes[0] !== 0 && bytes[31] < 0x80;
+    }
+
+    /**
+     * Get Associated Token Address
+     */
+    getAssociatedTokenAddress(mint, owner) {
+        const { address } = this.findProgramAddress(
+            [
+                Buffer.from(owner.replace('0x', ''), 'hex'),
+                Buffer.from(SYSTEM_PROGRAMS.TOKEN_PROGRAM, 'hex'),
+                Buffer.from(mint.replace('0x', ''), 'hex')
+            ],
+            SYSTEM_PROGRAMS.ASSOCIATED_TOKEN_PROGRAM
+        );
+        return address;
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // BORSH SERIALIZATION
+    // ═══════════════════════════════════════════════════════════════
+
+    borshSerialize(schema, data) {
+        const buffers = [];
+
+        for (const field of schema) {
+            const value = data[field.name];
+            buffers.push(this.borshSerializeValue(field.type, value));
+        }
+
+        return Buffer.concat(buffers);
+    }
+
+    borshSerializeValue(type, value) {
+        if (typeof type === 'string') {
+            switch (type) {
+                case 'u8':
+                    const u8Buf = Buffer.alloc(1);
+                    u8Buf.writeUInt8(value);
+                    return u8Buf;
+
+                case 'u16':
+                    const u16Buf = Buffer.alloc(2);
+                    u16Buf.writeUInt16LE(value);
+                    return u16Buf;
+
+                case 'u32':
+                    const u32Buf = Buffer.alloc(4);
+                    u32Buf.writeUInt32LE(value);
+                    return u32Buf;
+
+                case 'u64':
+                    const u64Buf = Buffer.alloc(8);
+                    u64Buf.writeBigUInt64LE(BigInt(value));
+                    return u64Buf;
+
+                case 'i64':
+                    const i64Buf = Buffer.alloc(8);
+                    i64Buf.writeBigInt64LE(BigInt(value));
+                    return i64Buf;
+
+                case 'bool':
+                    return Buffer.from([value ? 1 : 0]);
+
+                case 'pubkey':
+                    const hex = value.startsWith('0x') ? value.slice(2) : value;
+                    return Buffer.from(hex.padStart(64, '0'), 'hex');
+
+                case 'string':
+                    const strBuf = Buffer.from(value, 'utf8');
+                    const lenBuf = Buffer.alloc(4);
+                    lenBuf.writeUInt32LE(strBuf.length);
+                    return Buffer.concat([lenBuf, strBuf]);
+
+                default:
+                    throw new Error(`Unknown Borsh type: ${type}`);
+            }
+        }
+
+        // Handle complex types
+        if (type.vec) {
+            const lenBuf = Buffer.alloc(4);
+            lenBuf.writeUInt32LE(value.length);
+            const items = value.map(v => this.borshSerializeValue(type.vec, v));
+            return Buffer.concat([lenBuf, ...items]);
+        }
+
+        if (type.option) {
+            if (value === null || value === undefined) {
+                return Buffer.from([0]);
+            }
+            return Buffer.concat([Buffer.from([1]), this.borshSerializeValue(type.option, value)]);
+        }
+
+        throw new Error(`Unsupported Borsh type: ${JSON.stringify(type)}`);
+    }
+
+    borshDeserialize(schema, data) {
+        const result = {};
+        let offset = 0;
+
+        for (const field of schema) {
+            const { value, bytesRead } = this.borshDeserializeValue(field.type, data, offset);
+            result[field.name] = value;
+            offset += bytesRead;
+        }
+
+        return result;
+    }
+
+    borshDeserializeValue(type, data, offset) {
+        if (typeof type === 'string') {
+            switch (type) {
+                case 'u8':
+                    return { value: data.readUInt8(offset), bytesRead: 1 };
+
+                case 'u16':
+                    return { value: data.readUInt16LE(offset), bytesRead: 2 };
+
+                case 'u32':
+                    return { value: data.readUInt32LE(offset), bytesRead: 4 };
+
+                case 'u64':
+                    return { value: data.readBigUInt64LE(offset), bytesRead: 8 };
+
+                case 'i64':
+                    return { value: data.readBigInt64LE(offset), bytesRead: 8 };
+
+                case 'bool':
+                    return { value: data[offset] !== 0, bytesRead: 1 };
+
+                case 'pubkey':
+                    return { value: data.slice(offset, offset + 32).toString('hex'), bytesRead: 32 };
+
+                case 'string':
+                    const len = data.readUInt32LE(offset);
+                    const str = data.slice(offset + 4, offset + 4 + len).toString('utf8');
+                    return { value: str, bytesRead: 4 + len };
+
+                default:
+                    throw new Error(`Unknown Borsh type: ${type}`);
+            }
+        }
+
+        throw new Error(`Unsupported Borsh type: ${JSON.stringify(type)}`);
+    }
+
+    // ═══════════════════════════════════════════════════════════════
+    // HELPERS
+    // ═══════════════════════════════════════════════════════════════
+
+    getInstructionDiscriminator(methodName) {
+        const hash = crypto.createHash('sha256')
+            .update(`global:${methodName}`)
+            .digest();
+        return hash.slice(0, 8);
+    }
+
+    generateProgramId(bytecode) {
+        const hash = crypto.createHash('sha256').update(bytecode).digest('hex');
+        return hash;
+    }
+
+    getRecentBlockhash() {
+        // Generate pseudo-random blockhash
+        return crypto.randomBytes(32).toString('hex');
+    }
+
+    calculateRent(space) {
+        // Solana rent calculation
+        // Approximate: 19.055441478439427 lamports per byte per year
+        // Rent-exempt minimum: 2 years
+        const lamportsPerByteYear = 19055441478n;
+        return (BigInt(space) * lamportsPerByteYear * 2n) / 1000000000n;
+    }
+
+    getAccount(pubkey) {
+        return this.accounts.get(pubkey);
+    }
+
+    setAccount(pubkey, account) {
+        this.accounts.set(pubkey, account);
+    }
+}
+
+module.exports = SVMAdapter;