jaelis-node 1.9.0 → 2.0.0

package/lib/JAELIS-VM/lib/unified/jaelis-abi.js

@@ -1,1150 +0,0 @@
-/**
- * JAELIS UNIFIED ABI
- *
- * ONE ABI TO RULE THEM ALL
- *
- * No more:
- * - Solidity ABI (EVM)
- * - Borsh (Solana)
- * - BCS (Move)
- * - TL-B (TON)
- * - JSON Schema (WASM)
- *
- * Just: JAELIS ABI
- *
- * This replaces ALL adapters with ONE unified encoding/decoding system.
- *
- * @version 0.3.0
- * @author Mario Papaleo - JAELIS Foundation
- * @patent PATENT PENDING - Unified Blockchain ABI
- */
-
-const crypto = require('crypto');
-
-// ═══════════════════════════════════════════════════════════════
-// JAELIS UNIFIED TYPES
-// ═══════════════════════════════════════════════════════════════
-
-/**
- * JAELIS Native Types
- *
- * These are THE types. Not EVM types, not Solana types.
- * JAELIS types that work everywhere.
- */
-const JAELIS_TYPES = {
-    // Integers (size in bytes)
-    U8:    { id: 0x01, size: 1,  signed: false },
-    U16:   { id: 0x02, size: 2,  signed: false },
-    U32:   { id: 0x03, size: 4,  signed: false },
-    U64:   { id: 0x04, size: 8,  signed: false },
-    U128:  { id: 0x05, size: 16, signed: false },
-    U256:  { id: 0x06, size: 32, signed: false },
-
-    I8:    { id: 0x11, size: 1,  signed: true },
-    I16:   { id: 0x12, size: 2,  signed: true },
-    I32:   { id: 0x13, size: 4,  signed: true },
-    I64:   { id: 0x14, size: 8,  signed: true },
-    I128:  { id: 0x15, size: 16, signed: true },
-    I256:  { id: 0x16, size: 32, signed: true },
-
-    // Floats (if needed)
-    F32:   { id: 0x21, size: 4 },
-    F64:   { id: 0x22, size: 8 },
-
-    // Boolean
-    BOOL:  { id: 0x30, size: 1 },
-
-    // Address - ALWAYS 32 bytes in JAELIS (unified!)
-    ADDRESS: { id: 0x40, size: 32 },
-
-    // Fixed bytes
-    BYTES1:  { id: 0x50, size: 1 },
-    BYTES4:  { id: 0x51, size: 4 },   // Function selectors
-    BYTES8:  { id: 0x52, size: 8 },
-    BYTES16: { id: 0x53, size: 16 },
-    BYTES32: { id: 0x54, size: 32 },  // Hashes
-
-    // Dynamic types
-    BYTES:   { id: 0x60, size: -1, dynamic: true },
-    STRING:  { id: 0x61, size: -1, dynamic: true },
-
-    // Collections
-    ARRAY:   { id: 0x70, size: -1, dynamic: true },
-    MAP:     { id: 0x71, size: -1, dynamic: true },
-
-    // Structs
-    STRUCT:  { id: 0x80, size: -1, dynamic: true },
-    TUPLE:   { id: 0x81, size: -1, dynamic: true },
-
-    // Optional
-    OPTION:  { id: 0x90, size: -1, dynamic: true },
-    RESULT:  { id: 0x91, size: -1, dynamic: true },
-
-    // Blockchain-specific (but unified representation!)
-    TOKEN_AMOUNT: { id: 0xA0, size: 32 },  // Always 256-bit for precision
-    SIGNATURE:    { id: 0xA1, size: 65 },  // 64 bytes sig + 1 byte recovery
-    HASH:         { id: 0xA2, size: 32 },  // SHA256/Keccak result
-    PUBKEY:       { id: 0xA3, size: 32 },  // Ed25519/Secp256k1 pubkey
-
-    // Null
-    NULL:    { id: 0xFF, size: 0 }
-};
-
-// Type name lookup
-const TYPE_BY_ID = new Map();
-for (const [name, info] of Object.entries(JAELIS_TYPES)) {
-    TYPE_BY_ID.set(info.id, { name, ...info });
-}
-
-// ═══════════════════════════════════════════════════════════════
-// JAELIS ABI ENCODER
-// ═══════════════════════════════════════════════════════════════
-
-class JaelisABIEncoder {
-    constructor() {
-        this.buffer = [];
-        this.position = 0;
-    }
-
-    /**
-     * Encode a value to JAELIS ABI format
-     */
-    encode(value, type) {
-        const typeInfo = typeof type === 'string' ? JAELIS_TYPES[type] : type;
-
-        if (!typeInfo) {
-            throw new Error(`Unknown type: ${type}`);
-        }
-
-        // Write type ID first (self-describing format!)
-        this.writeUint8(typeInfo.id);
-
-        // Encode based on type
-        switch (typeInfo.id) {
-            // Unsigned integers
-            case JAELIS_TYPES.U8.id:
-                this.writeUint8(value);
-                break;
-            case JAELIS_TYPES.U16.id:
-                this.writeUint16(value);
-                break;
-            case JAELIS_TYPES.U32.id:
-                this.writeUint32(value);
-                break;
-            case JAELIS_TYPES.U64.id:
-                this.writeUint64(value);
-                break;
-            case JAELIS_TYPES.U128.id:
-                this.writeUint128(value);
-                break;
-            case JAELIS_TYPES.U256.id:
-                this.writeUint256(value);
-                break;
-
-            // Signed integers
-            case JAELIS_TYPES.I8.id:
-                this.writeInt8(value);
-                break;
-            case JAELIS_TYPES.I16.id:
-                this.writeInt16(value);
-                break;
-            case JAELIS_TYPES.I32.id:
-                this.writeInt32(value);
-                break;
-            case JAELIS_TYPES.I64.id:
-                this.writeInt64(value);
-                break;
-            case JAELIS_TYPES.I128.id:
-                this.writeInt128(value);
-                break;
-            case JAELIS_TYPES.I256.id:
-                this.writeInt256(value);
-                break;
-
-            // Floats
-            case JAELIS_TYPES.F32.id:
-                this.writeFloat32(value);
-                break;
-            case JAELIS_TYPES.F64.id:
-                this.writeFloat64(value);
-                break;
-
-            // Boolean
-            case JAELIS_TYPES.BOOL.id:
-                this.writeUint8(value ? 1 : 0);
-                break;
-
-            // Address (32 bytes)
-            case JAELIS_TYPES.ADDRESS.id:
-                this.writeAddress(value);
-                break;
-
-            // Fixed bytes
-            case JAELIS_TYPES.BYTES32.id:
-                this.writeBytes32(value);
-                break;
-            case JAELIS_TYPES.BYTES4.id:
-                this.writeBytes(value, 4);
-                break;
-
-            // Dynamic bytes
-            case JAELIS_TYPES.BYTES.id:
-                this.writeDynamicBytes(value);
-                break;
-
-            // String
-            case JAELIS_TYPES.STRING.id:
-                this.writeString(value);
-                break;
-
-            // Array
-            case JAELIS_TYPES.ARRAY.id:
-                this.writeArray(value.values, value.elementType);
-                break;
-
-            // Struct
-            case JAELIS_TYPES.STRUCT.id:
-                this.writeStruct(value.fields, value.types);
-                break;
-
-            // Tuple
-            case JAELIS_TYPES.TUPLE.id:
-                this.writeTuple(value.values, value.types);
-                break;
-
-            // Option
-            case JAELIS_TYPES.OPTION.id:
-                this.writeOption(value.value, value.innerType);
-                break;
-
-            // Result
-            case JAELIS_TYPES.RESULT.id:
-                this.writeResult(value.isOk, value.value, value.innerType);
-                break;
-
-            // Token amount (always U256)
-            case JAELIS_TYPES.TOKEN_AMOUNT.id:
-                this.writeUint256(value);
-                break;
-
-            // Hash
-            case JAELIS_TYPES.HASH.id:
-                this.writeBytes32(value);
-                break;
-
-            default:
-                throw new Error(`Encoding not implemented for type: ${type}`);
-        }
-
-        return this;
-    }
-
-    /**
-     * Encode multiple values
-     */
-    encodeMultiple(values, types) {
-        // Write count
-        this.writeVarInt(values.length);
-
-        for (let i = 0; i < values.length; i++) {
-            this.encode(values[i], types[i]);
-        }
-
-        return this;
-    }
-
-    /**
-     * Encode a function call
-     */
-    encodeFunctionCall(functionName, args, argTypes) {
-        // Function selector (first 4 bytes of hash)
-        const selector = this.computeSelector(functionName, argTypes);
-        this.buffer.push(...selector);
-
-        // Arguments
-        this.encodeMultiple(args, argTypes);
-
-        return this;
-    }
-
-    /**
-     * Get encoded buffer
-     */
-    toBuffer() {
-        return Buffer.from(this.buffer);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // PRIMITIVE WRITERS
-    // ═══════════════════════════════════════════════════════════════
-
-    writeUint8(value) {
-        this.buffer.push(value & 0xFF);
-    }
-
-    writeInt8(value) {
-        this.buffer.push(value < 0 ? 256 + value : value);
-    }
-
-    writeUint16(value) {
-        this.buffer.push(value & 0xFF);
-        this.buffer.push((value >> 8) & 0xFF);
-    }
-
-    writeInt16(value) {
-        const v = value < 0 ? 65536 + value : value;
-        this.writeUint16(v);
-    }
-
-    writeUint32(value) {
-        this.buffer.push(value & 0xFF);
-        this.buffer.push((value >> 8) & 0xFF);
-        this.buffer.push((value >> 16) & 0xFF);
-        this.buffer.push((value >> 24) & 0xFF);
-    }
-
-    writeInt32(value) {
-        const v = value < 0 ? 4294967296 + value : value;
-        this.writeUint32(v);
-    }
-
-    writeUint64(value) {
-        const v = BigInt(value);
-        for (let i = 0; i < 8; i++) {
-            this.buffer.push(Number((v >> BigInt(i * 8)) & 0xFFn));
-        }
-    }
-
-    writeInt64(value) {
-        const v = BigInt(value);
-        for (let i = 0; i < 8; i++) {
-            this.buffer.push(Number((v >> BigInt(i * 8)) & 0xFFn));
-        }
-    }
-
-    writeUint128(value) {
-        const v = BigInt(value);
-        for (let i = 0; i < 16; i++) {
-            this.buffer.push(Number((v >> BigInt(i * 8)) & 0xFFn));
-        }
-    }
-
-    writeUint256(value) {
-        const v = BigInt(value);
-        for (let i = 0; i < 32; i++) {
-            this.buffer.push(Number((v >> BigInt(i * 8)) & 0xFFn));
-        }
-    }
-
-    writeInt128(value) {
-        let v = BigInt(value);
-        // Handle negative values with two's complement
-        if (v < 0n) {
-            v = (1n << 128n) + v;
-        }
-        for (let i = 0; i < 16; i++) {
-            this.buffer.push(Number((v >> BigInt(i * 8)) & 0xFFn));
-        }
-    }
-
-    writeInt256(value) {
-        let v = BigInt(value);
-        // Handle negative values with two's complement
-        if (v < 0n) {
-            v = (1n << 256n) + v;
-        }
-        for (let i = 0; i < 32; i++) {
-            this.buffer.push(Number((v >> BigInt(i * 8)) & 0xFFn));
-        }
-    }
-
-    writeFloat32(value) {
-        const buf = Buffer.alloc(4);
-        buf.writeFloatLE(value);
-        for (let i = 0; i < 4; i++) {
-            this.buffer.push(buf[i]);
-        }
-    }
-
-    writeFloat64(value) {
-        const buf = Buffer.alloc(8);
-        buf.writeDoubleLE(value);
-        for (let i = 0; i < 8; i++) {
-            this.buffer.push(buf[i]);
-        }
-    }
-
-    writeVarInt(value) {
-        if (value < 0xFD) {
-            this.writeUint8(value);
-        } else if (value <= 0xFFFF) {
-            this.writeUint8(0xFD);
-            this.writeUint16(value);
-        } else if (value <= 0xFFFFFFFF) {
-            this.writeUint8(0xFE);
-            this.writeUint32(value);
-        } else {
-            this.writeUint8(0xFF);
-            this.writeUint64(value);
-        }
-    }
-
-    writeAddress(address) {
-        // Normalize to 32 bytes
-        let hex = address;
-        if (typeof address === 'string') {
-            hex = address.startsWith('0x') ? address.slice(2) : address;
-        }
-
-        // Pad to 64 hex chars (32 bytes)
-        hex = hex.padStart(64, '0');
-
-        for (let i = 0; i < 32; i++) {
-            this.buffer.push(parseInt(hex.substr(i * 2, 2), 16));
-        }
-    }
-
-    writeBytes32(value) {
-        let bytes;
-        if (typeof value === 'string') {
-            const hex = value.startsWith('0x') ? value.slice(2) : value;
-            bytes = Buffer.from(hex.padStart(64, '0'), 'hex');
-        } else if (Buffer.isBuffer(value)) {
-            bytes = value;
-        } else {
-            bytes = Buffer.alloc(32);
-        }
-
-        // Ensure 32 bytes
-        const padded = Buffer.alloc(32);
-        bytes.copy(padded, 32 - bytes.length);
-
-        for (let i = 0; i < 32; i++) {
-            this.buffer.push(padded[i]);
-        }
-    }
-
-    writeBytes(value, length) {
-        let bytes;
-        if (typeof value === 'string') {
-            const hex = value.startsWith('0x') ? value.slice(2) : value;
-            bytes = Buffer.from(hex, 'hex');
-        } else if (Buffer.isBuffer(value)) {
-            bytes = value;
-        } else {
-            bytes = Buffer.alloc(length);
-        }
-
-        for (let i = 0; i < length; i++) {
-            this.buffer.push(bytes[i] || 0);
-        }
-    }
-
-    writeDynamicBytes(value) {
-        let bytes;
-        if (typeof value === 'string') {
-            const hex = value.startsWith('0x') ? value.slice(2) : value;
-            bytes = Buffer.from(hex, 'hex');
-        } else if (Buffer.isBuffer(value)) {
-            bytes = value;
-        } else {
-            bytes = Buffer.alloc(0);
-        }
-
-        // Length prefix
-        this.writeVarInt(bytes.length);
-
-        // Data
-        for (let i = 0; i < bytes.length; i++) {
-            this.buffer.push(bytes[i]);
-        }
-    }
-
-    writeString(value) {
-        const bytes = Buffer.from(value, 'utf8');
-        this.writeVarInt(bytes.length);
-        for (let i = 0; i < bytes.length; i++) {
-            this.buffer.push(bytes[i]);
-        }
-    }
-
-    writeArray(values, elementType) {
-        this.writeVarInt(values.length);
-        for (const value of values) {
-            this.encode(value, elementType);
-        }
-    }
-
-    writeStruct(fields, types) {
-        const keys = Object.keys(fields);
-        this.writeVarInt(keys.length);
-
-        for (let i = 0; i < keys.length; i++) {
-            // Write field name
-            this.writeString(keys[i]);
-            // Write field value
-            this.encode(fields[keys[i]], types[i]);
-        }
-    }
-
-    writeOption(value, innerType) {
-        if (value === null || value === undefined) {
-            this.writeUint8(0);  // None
-        } else {
-            this.writeUint8(1);  // Some
-            this.encode(value, innerType);
-        }
-    }
-
-    writeTuple(values, types) {
-        // Tuple: fixed-size collection of heterogeneous values
-        this.writeVarInt(values.length);
-        for (let i = 0; i < values.length; i++) {
-            this.encode(values[i], types[i]);
-        }
-    }
-
-    writeResult(isOk, value, innerType) {
-        // Result: Ok(value) or Err(error)
-        if (isOk) {
-            this.writeUint8(1);  // Ok
-            if (value !== undefined) {
-                this.encode(value, innerType);
-            }
-        } else {
-            this.writeUint8(0);  // Err
-            if (value !== undefined) {
-                this.encode(value, innerType);
-            }
-        }
-    }
-
-    computeSelector(functionName, argTypes) {
-        const signature = `${functionName}(${argTypes.join(',')})`;
-        const hash = crypto.createHash('sha256').update(signature).digest();
-        return Array.from(hash.slice(0, 4));
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// JAELIS ABI DECODER
-// ═══════════════════════════════════════════════════════════════
-
-class JaelisABIDecoder {
-    constructor(buffer) {
-        this.buffer = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
-        this.position = 0;
-    }
-
-    /**
-     * Decode a value from JAELIS ABI format
-     * Returns { value, type } for self-describing format
-     */
-    decode() {
-        // Read type ID
-        const typeId = this.readUint8();
-        const typeInfo = TYPE_BY_ID.get(typeId);
-
-        if (!typeInfo) {
-            throw new Error(`Unknown type ID: 0x${typeId.toString(16)}`);
-        }
-
-        let value;
-
-        // Decode based on type
-        switch (typeId) {
-            case JAELIS_TYPES.U8.id:
-                value = this.readUint8();
-                break;
-            case JAELIS_TYPES.U16.id:
-                value = this.readUint16();
-                break;
-            case JAELIS_TYPES.U32.id:
-                value = this.readUint32();
-                break;
-            case JAELIS_TYPES.U64.id:
-                value = this.readUint64();
-                break;
-            case JAELIS_TYPES.U128.id:
-                value = this.readUint128();
-                break;
-            case JAELIS_TYPES.U256.id:
-            case JAELIS_TYPES.TOKEN_AMOUNT.id:
-                value = this.readUint256();
-                break;
-
-            case JAELIS_TYPES.I8.id:
-                value = this.readInt8();
-                break;
-            case JAELIS_TYPES.I16.id:
-                value = this.readInt16();
-                break;
-            case JAELIS_TYPES.I32.id:
-                value = this.readInt32();
-                break;
-            case JAELIS_TYPES.I64.id:
-                value = this.readInt64();
-                break;
-            case JAELIS_TYPES.I128.id:
-                value = this.readInt128();
-                break;
-            case JAELIS_TYPES.I256.id:
-                value = this.readInt256();
-                break;
-
-            // Floats
-            case JAELIS_TYPES.F32.id:
-                value = this.readFloat32();
-                break;
-            case JAELIS_TYPES.F64.id:
-                value = this.readFloat64();
-                break;
-
-            case JAELIS_TYPES.BOOL.id:
-                value = this.readUint8() !== 0;
-                break;
-
-            case JAELIS_TYPES.ADDRESS.id:
-            case JAELIS_TYPES.PUBKEY.id:
-                value = this.readAddress();
-                break;
-
-            case JAELIS_TYPES.BYTES32.id:
-            case JAELIS_TYPES.HASH.id:
-                value = this.readBytes32();
-                break;
-
-            case JAELIS_TYPES.BYTES4.id:
-                value = this.readBytes(4);
-                break;
-
-            case JAELIS_TYPES.BYTES.id:
-                value = this.readDynamicBytes();
-                break;
-
-            case JAELIS_TYPES.STRING.id:
-                value = this.readString();
-                break;
-
-            case JAELIS_TYPES.ARRAY.id:
-                value = this.readArray();
-                break;
-
-            case JAELIS_TYPES.STRUCT.id:
-                value = this.readStruct();
-                break;
-
-            case JAELIS_TYPES.TUPLE.id:
-                value = this.readTuple();
-                break;
-
-            case JAELIS_TYPES.OPTION.id:
-                value = this.readOption();
-                break;
-
-            case JAELIS_TYPES.RESULT.id:
-                value = this.readResult();
-                break;
-
-            case JAELIS_TYPES.NULL.id:
-                value = null;
-                break;
-
-            default:
-                throw new Error(`Decoding not implemented for type ID: 0x${typeId.toString(16)}`);
-        }
-
-        return { value, type: typeInfo.name };
-    }
-
-    /**
-     * Decode multiple values
-     */
-    decodeMultiple() {
-        const count = this.readVarInt();
-        const values = [];
-
-        for (let i = 0; i < count; i++) {
-            values.push(this.decode());
-        }
-
-        return values;
-    }
-
-    /**
-     * Decode function call
-     */
-    decodeFunctionCall() {
-        // Read selector (4 bytes)
-        const selector = this.readBytes(4);
-
-        // Decode arguments
-        const args = this.decodeMultiple();
-
-        return { selector, args };
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // PRIMITIVE READERS
-    // ═══════════════════════════════════════════════════════════════
-
-    readUint8() {
-        return this.buffer[this.position++];
-    }
-
-    readInt8() {
-        const v = this.readUint8();
-        return v > 127 ? v - 256 : v;
-    }
-
-    readUint16() {
-        const v = this.buffer[this.position] | (this.buffer[this.position + 1] << 8);
-        this.position += 2;
-        return v;
-    }
-
-    readInt16() {
-        const v = this.readUint16();
-        return v > 32767 ? v - 65536 : v;
-    }
-
-    readUint32() {
-        const v = this.buffer[this.position] |
-                 (this.buffer[this.position + 1] << 8) |
-                 (this.buffer[this.position + 2] << 16) |
-                 (this.buffer[this.position + 3] << 24);
-        this.position += 4;
-        return v >>> 0;
-    }
-
-    readInt32() {
-        const v = this.readUint32();
-        return v > 2147483647 ? v - 4294967296 : v;
-    }
-
-    readUint64() {
-        let result = 0n;
-        for (let i = 0; i < 8; i++) {
-            result |= BigInt(this.buffer[this.position + i]) << BigInt(i * 8);
-        }
-        this.position += 8;
-        return result;
-    }
-
-    readInt64() {
-        const v = this.readUint64();
-        if (v >= 2n ** 63n) {
-            return v - 2n ** 64n;
-        }
-        return v;
-    }
-
-    readUint128() {
-        let result = 0n;
-        for (let i = 0; i < 16; i++) {
-            result |= BigInt(this.buffer[this.position + i]) << BigInt(i * 8);
-        }
-        this.position += 16;
-        return result;
-    }
-
-    readUint256() {
-        let result = 0n;
-        for (let i = 0; i < 32; i++) {
-            result |= BigInt(this.buffer[this.position + i]) << BigInt(i * 8);
-        }
-        this.position += 32;
-        return result;
-    }
-
-    readVarInt() {
-        const first = this.readUint8();
-        if (first < 0xFD) {
-            return first;
-        } else if (first === 0xFD) {
-            return this.readUint16();
-        } else if (first === 0xFE) {
-            return this.readUint32();
-        } else {
-            return Number(this.readUint64());
-        }
-    }
-
-    readAddress() {
-        const bytes = this.buffer.slice(this.position, this.position + 32);
-        this.position += 32;
-        return '0x' + bytes.toString('hex');
-    }
-
-    readBytes32() {
-        const bytes = this.buffer.slice(this.position, this.position + 32);
-        this.position += 32;
-        return '0x' + bytes.toString('hex');
-    }
-
-    readBytes(length) {
-        const bytes = this.buffer.slice(this.position, this.position + length);
-        this.position += length;
-        return bytes;
-    }
-
-    readDynamicBytes() {
-        const length = this.readVarInt();
-        const bytes = this.buffer.slice(this.position, this.position + length);
-        this.position += length;
-        return bytes;
-    }
-
-    readString() {
-        const length = this.readVarInt();
-        const bytes = this.buffer.slice(this.position, this.position + length);
-        this.position += length;
-        return bytes.toString('utf8');
-    }
-
-    readArray() {
-        const count = this.readVarInt();
-        const values = [];
-        for (let i = 0; i < count; i++) {
-            values.push(this.decode());
-        }
-        return values;
-    }
-
-    readStruct() {
-        const count = this.readVarInt();
-        const result = {};
-        for (let i = 0; i < count; i++) {
-            const key = this.readString();
-            const value = this.decode();
-            result[key] = value;
-        }
-        return result;
-    }
-
-    readOption() {
-        const hasValue = this.readUint8() !== 0;
-        if (hasValue) {
-            return this.decode();
-        }
-        return null;
-    }
-
-    readInt128() {
-        let result = 0n;
-        for (let i = 0; i < 16; i++) {
-            result |= BigInt(this.buffer[this.position + i]) << BigInt(i * 8);
-        }
-        this.position += 16;
-        // Handle two's complement for negative values
-        if (result >= (1n << 127n)) {
-            result = result - (1n << 128n);
-        }
-        return result;
-    }
-
-    readInt256() {
-        let result = 0n;
-        for (let i = 0; i < 32; i++) {
-            result |= BigInt(this.buffer[this.position + i]) << BigInt(i * 8);
-        }
-        this.position += 32;
-        // Handle two's complement for negative values
-        if (result >= (1n << 255n)) {
-            result = result - (1n << 256n);
-        }
-        return result;
-    }
-
-    readFloat32() {
-        const bytes = this.buffer.slice(this.position, this.position + 4);
-        this.position += 4;
-        return bytes.readFloatLE(0);
-    }
-
-    readFloat64() {
-        const bytes = this.buffer.slice(this.position, this.position + 8);
-        this.position += 8;
-        return bytes.readDoubleLE(0);
-    }
-
-    readTuple() {
-        const count = this.readVarInt();
-        const values = [];
-        for (let i = 0; i < count; i++) {
-            values.push(this.decode());
-        }
-        return values;
-    }
-
-    readResult() {
-        const isOk = this.readUint8() !== 0;
-        const value = this.decode();
-        return {
-            isOk,
-            value: value.value,
-            type: value.type
-        };
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// JAELIS ABI (MAIN INTERFACE)
-// ═══════════════════════════════════════════════════════════════
-
-class JaelisABI {
-    /**
-     * Encode a value
-     */
-    static encode(value, type) {
-        const encoder = new JaelisABIEncoder();
-        encoder.encode(value, type);
-        return encoder.toBuffer();
-    }
-
-    /**
-     * Encode multiple values
-     */
-    static encodeMultiple(values, types) {
-        const encoder = new JaelisABIEncoder();
-        encoder.encodeMultiple(values, types);
-        return encoder.toBuffer();
-    }
-
-    /**
-     * Encode a function call
-     */
-    static encodeFunctionCall(functionName, args, argTypes) {
-        const encoder = new JaelisABIEncoder();
-        encoder.encodeFunctionCall(functionName, args, argTypes);
-        return encoder.toBuffer();
-    }
-
-    /**
-     * Decode a value
-     */
-    static decode(buffer) {
-        const decoder = new JaelisABIDecoder(buffer);
-        return decoder.decode();
-    }
-
-    /**
-     * Decode multiple values
-     */
-    static decodeMultiple(buffer) {
-        const decoder = new JaelisABIDecoder(buffer);
-        return decoder.decodeMultiple();
-    }
-
-    /**
-     * Decode a function call
-     */
-    static decodeFunctionCall(buffer) {
-        const decoder = new JaelisABIDecoder(buffer);
-        return decoder.decodeFunctionCall();
-    }
-
-    /**
-     * Compute function selector
-     */
-    static computeSelector(functionName, argTypes = []) {
-        const signature = `${functionName}(${argTypes.join(',')})`;
-        return crypto.createHash('sha256').update(signature).digest().slice(0, 4);
-    }
-
-    /**
-     * Get type info
-     */
-    static getType(typeName) {
-        return JAELIS_TYPES[typeName];
-    }
-
-    /**
-     * Get all types
-     */
-    static get TYPES() {
-        return JAELIS_TYPES;
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// HELPER: CONVERT FROM OTHER ABIS
-// ═══════════════════════════════════════════════════════════════
-
-class ABIConverter {
-    /**
-     * Convert Solidity ABI to JAELIS ABI
-     */
-    static fromSolidityABI(solidityABI) {
-        const jaelisABI = [];
-
-        for (const item of solidityABI) {
-            if (item.type === 'function') {
-                jaelisABI.push({
-                    type: 'function',
-                    name: item.name,
-                    inputs: item.inputs.map(i => ({
-                        name: i.name,
-                        type: this.solidityTypeToJaelis(i.type)
-                    })),
-                    outputs: (item.outputs || []).map(o => ({
-                        name: o.name,
-                        type: this.solidityTypeToJaelis(o.type)
-                    })),
-                    selector: JaelisABI.computeSelector(
-                        item.name,
-                        item.inputs.map(i => this.solidityTypeToJaelis(i.type))
-                    )
-                });
-            } else if (item.type === 'event') {
-                jaelisABI.push({
-                    type: 'event',
-                    name: item.name,
-                    inputs: item.inputs.map(i => ({
-                        name: i.name,
-                        type: this.solidityTypeToJaelis(i.type),
-                        indexed: i.indexed
-                    }))
-                });
-            }
-        }
-
-        return jaelisABI;
-    }
-
-    /**
-     * Convert Solidity type to JAELIS type
-     */
-    static solidityTypeToJaelis(solidityType) {
-        const typeMap = {
-            'uint8': 'U8',
-            'uint16': 'U16',
-            'uint32': 'U32',
-            'uint64': 'U64',
-            'uint128': 'U128',
-            'uint256': 'U256',
-            'int8': 'I8',
-            'int16': 'I16',
-            'int32': 'I32',
-            'int64': 'I64',
-            'int128': 'I128',
-            'int256': 'I256',
-            'bool': 'BOOL',
-            'address': 'ADDRESS',
-            'bytes': 'BYTES',
-            'bytes4': 'BYTES4',
-            'bytes32': 'BYTES32',
-            'string': 'STRING'
-        };
-
-        // Handle arrays
-        if (solidityType.endsWith('[]')) {
-            return 'ARRAY';
-        }
-
-        return typeMap[solidityType] || 'U256';
-    }
-
-    /**
-     * Convert Anchor/Borsh IDL to JAELIS ABI
-     */
-    static fromAnchorIDL(idl) {
-        const jaelisABI = [];
-
-        for (const instruction of idl.instructions || []) {
-            jaelisABI.push({
-                type: 'function',
-                name: instruction.name,
-                inputs: (instruction.args || []).map(a => ({
-                    name: a.name,
-                    type: this.rustTypeToJaelis(a.type)
-                })),
-                outputs: [],
-                selector: JaelisABI.computeSelector(instruction.name, [])
-            });
-        }
-
-        return jaelisABI;
-    }
-
-    /**
-     * Convert Rust type to JAELIS type
-     */
-    static rustTypeToJaelis(rustType) {
-        const typeMap = {
-            'u8': 'U8',
-            'u16': 'U16',
-            'u32': 'U32',
-            'u64': 'U64',
-            'u128': 'U128',
-            'i8': 'I8',
-            'i16': 'I16',
-            'i32': 'I32',
-            'i64': 'I64',
-            'i128': 'I128',
-            'bool': 'BOOL',
-            'Pubkey': 'ADDRESS',
-            'String': 'STRING'
-        };
-
-        if (typeof rustType === 'object') {
-            if (rustType.vec) return 'ARRAY';
-            if (rustType.option) return 'OPTION';
-        }
-
-        return typeMap[rustType] || 'U256';
-    }
-
-    /**
-     * Convert Move ABI to JAELIS ABI
-     */
-    static fromMoveABI(moveABI) {
-        const jaelisABI = [];
-
-        for (const func of moveABI.exposed_functions || []) {
-            jaelisABI.push({
-                type: 'function',
-                name: func.name,
-                inputs: (func.params || []).map((p, i) => ({
-                    name: `arg${i}`,
-                    type: this.moveTypeToJaelis(p)
-                })),
-                outputs: (func.return || []).map((r, i) => ({
-                    name: `ret${i}`,
-                    type: this.moveTypeToJaelis(r)
-                })),
-                selector: JaelisABI.computeSelector(func.name, [])
-            });
-        }
-
-        return jaelisABI;
-    }
-
-    /**
-     * Convert Move type to JAELIS type
-     */
-    static moveTypeToJaelis(moveType) {
-        const typeMap = {
-            'u8': 'U8',
-            'u16': 'U16',
-            'u32': 'U32',
-            'u64': 'U64',
-            'u128': 'U128',
-            'u256': 'U256',
-            'bool': 'BOOL',
-            'address': 'ADDRESS',
-            'vector<u8>': 'BYTES',
-            '0x1::string::String': 'STRING'
-        };
-
-        return typeMap[moveType] || 'U256';
-    }
-}
-
-module.exports = {
-    JaelisABI,
-    JaelisABIEncoder,
-    JaelisABIDecoder,
-    ABIConverter,
-    JAELIS_TYPES
-};