jaelis-node 1.10.0 → 2.0.0

package/lib/JAELIS-VM/lib/serialization/serializer.js

@@ -1,819 +0,0 @@
-/**
- * JAELIS FAST SERIALIZATION
- *
- * High-performance serialization using:
- * - CBOR-X: 3-10x faster than JSON
- * - MessagePack: 37% smaller than JSON
- * - Zero-copy deserialization (Wincode-inspired)
- *
- * Benchmarks:
- * ┌──────────────┬────────────┬────────────┬──────────────┐
- * │ Format       │ Encode     │ Decode     │ Size         │
- * ├──────────────┼────────────┼────────────┼──────────────┤
- * │ JSON         │ 1x         │ 1x         │ 1x           │
- * │ CBOR-X       │ 3-10x      │ 3-10x      │ 0.7x         │
- * │ MessagePack  │ 2-5x       │ 2-5x       │ 0.63x        │
- * │ Zero-copy    │ 100x+      │ 100x+      │ 1x (binary)  │
- * └──────────────┴────────────┴────────────┴──────────────┘
- *
- * @version 0.1.0
- * @author Mario Papaleo - JAELIS Foundation
- */
-
-// Try to load fast serializers
-let Encoder, Decoder, pack, unpack;
-try {
-    const cborx = require('cbor-x');
-    Encoder = cborx.Encoder;
-    Decoder = cborx.Decoder;
-} catch (e) {
-    // Will use fallback
-}
-
-try {
-    const msgpackr = require('msgpackr');
-    pack = msgpackr.pack;
-    unpack = msgpackr.unpack;
-} catch (e) {
-    // Will use fallback
-}
-
-/**
- * Custom type handlers for blockchain types
- */
-const CUSTOM_TYPES = {
-    // BigInt (not natively supported in JSON/CBOR)
-    BIGINT: 0x01,
-
-    // Uint256 (32-byte big int)
-    UINT256: 0x02,
-
-    // Address (20 bytes for EVM, 32 for Solana)
-    ADDRESS: 0x03,
-
-    // Bytes32
-    BYTES32: 0x04,
-
-    // Contract call data
-    CALLDATA: 0x05,
-
-    // Transaction
-    TRANSACTION: 0x06,
-
-    // State proof
-    STATE_PROOF: 0x07
-};
-
-/**
- * Zero-Copy Buffer View
- *
- * Inspired by Wincode - provides views into binary data without copying
- */
-class ZeroCopyView {
-    constructor(buffer, offset = 0, length = -1) {
-        this.buffer = buffer;
-        this.offset = offset;
-        this.length = length === -1 ? buffer.length - offset : length;
-        this.position = 0;
-    }
-
-    // Read primitives without copying
-    readUint8() {
-        const value = this.buffer[this.offset + this.position];
-        this.position++;
-        return value;
-    }
-
-    readUint16LE() {
-        const value = this.buffer.readUInt16LE(this.offset + this.position);
-        this.position += 2;
-        return value;
-    }
-
-    readUint32LE() {
-        const value = this.buffer.readUInt32LE(this.offset + this.position);
-        this.position += 4;
-        return value;
-    }
-
-    readUint64LE() {
-        const value = this.buffer.readBigUInt64LE(this.offset + this.position);
-        this.position += 8;
-        return value;
-    }
-
-    readInt32LE() {
-        const value = this.buffer.readInt32LE(this.offset + this.position);
-        this.position += 4;
-        return value;
-    }
-
-    readInt64LE() {
-        const value = this.buffer.readBigInt64LE(this.offset + this.position);
-        this.position += 8;
-        return value;
-    }
-
-    readFloat32LE() {
-        const value = this.buffer.readFloatLE(this.offset + this.position);
-        this.position += 4;
-        return value;
-    }
-
-    readFloat64LE() {
-        const value = this.buffer.readDoubleLE(this.offset + this.position);
-        this.position += 8;
-        return value;
-    }
-
-    // Zero-copy slice - returns a view, not a copy
-    slice(length) {
-        const view = new ZeroCopyView(this.buffer, this.offset + this.position, length);
-        this.position += length;
-        return view;
-    }
-
-    // Get underlying buffer (for when you really need it)
-    toBuffer() {
-        return this.buffer.slice(this.offset, this.offset + this.length);
-    }
-
-    // Read variable-length integer (compact encoding)
-    readVarInt() {
-        const first = this.readUint8();
-
-        if (first < 0xFD) {
-            return first;
-        } else if (first === 0xFD) {
-            return this.readUint16LE();
-        } else if (first === 0xFE) {
-            return this.readUint32LE();
-        } else {
-            return Number(this.readUint64LE());
-        }
-    }
-
-    // Read length-prefixed bytes (zero-copy)
-    readBytes() {
-        const length = this.readVarInt();
-        return this.slice(length);
-    }
-
-    // Read length-prefixed string
-    readString() {
-        const bytes = this.readBytes();
-        return bytes.toBuffer().toString('utf8');
-    }
-
-    // Read BigInt (256-bit)
-    readUint256() {
-        const bytes = this.slice(32);
-        let result = 0n;
-        for (let i = 31; i >= 0; i--) {
-            result = (result << 8n) | BigInt(bytes.buffer[bytes.offset + i]);
-        }
-        return result;
-    }
-
-    // Read address (20 or 32 bytes)
-    readAddress(length = 20) {
-        const bytes = this.slice(length);
-        return '0x' + bytes.toBuffer().toString('hex');
-    }
-
-    remaining() {
-        return this.length - this.position;
-    }
-
-    hasMore() {
-        return this.position < this.length;
-    }
-}
-
-/**
- * Zero-Copy Buffer Writer
- */
-class ZeroCopyWriter {
-    constructor(initialSize = 1024) {
-        this.buffer = Buffer.alloc(initialSize);
-        this.position = 0;
-    }
-
-    _ensureCapacity(needed) {
-        if (this.position + needed > this.buffer.length) {
-            const newSize = Math.max(this.buffer.length * 2, this.position + needed);
-            const newBuffer = Buffer.alloc(newSize);
-            this.buffer.copy(newBuffer);
-            this.buffer = newBuffer;
-        }
-    }
-
-    writeUint8(value) {
-        this._ensureCapacity(1);
-        this.buffer[this.position++] = value;
-    }
-
-    writeUint16LE(value) {
-        this._ensureCapacity(2);
-        this.buffer.writeUInt16LE(value, this.position);
-        this.position += 2;
-    }
-
-    writeUint32LE(value) {
-        this._ensureCapacity(4);
-        this.buffer.writeUInt32LE(value, this.position);
-        this.position += 4;
-    }
-
-    writeUint64LE(value) {
-        this._ensureCapacity(8);
-        this.buffer.writeBigUInt64LE(BigInt(value), this.position);
-        this.position += 8;
-    }
-
-    writeInt32LE(value) {
-        this._ensureCapacity(4);
-        this.buffer.writeInt32LE(value, this.position);
-        this.position += 4;
-    }
-
-    writeInt64LE(value) {
-        this._ensureCapacity(8);
-        this.buffer.writeBigInt64LE(BigInt(value), this.position);
-        this.position += 8;
-    }
-
-    writeFloat64LE(value) {
-        this._ensureCapacity(8);
-        this.buffer.writeDoubleLE(value, this.position);
-        this.position += 8;
-    }
-
-    writeBuffer(buffer) {
-        this._ensureCapacity(buffer.length);
-        buffer.copy(this.buffer, this.position);
-        this.position += buffer.length;
-    }
-
-    writeVarInt(value) {
-        if (value < 0xFD) {
-            this.writeUint8(value);
-        } else if (value <= 0xFFFF) {
-            this.writeUint8(0xFD);
-            this.writeUint16LE(value);
-        } else if (value <= 0xFFFFFFFF) {
-            this.writeUint8(0xFE);
-            this.writeUint32LE(value);
-        } else {
-            this.writeUint8(0xFF);
-            this.writeUint64LE(value);
-        }
-    }
-
-    writeBytes(buffer) {
-        this.writeVarInt(buffer.length);
-        this.writeBuffer(buffer);
-    }
-
-    writeString(str) {
-        const buffer = Buffer.from(str, 'utf8');
-        this.writeBytes(buffer);
-    }
-
-    writeUint256(value) {
-        this._ensureCapacity(32);
-        let v = BigInt(value);
-        for (let i = 0; i < 32; i++) {
-            this.buffer[this.position + i] = Number(v & 0xffn);
-            v >>= 8n;
-        }
-        this.position += 32;
-    }
-
-    writeAddress(address, length = 20) {
-        const hex = address.startsWith('0x') ? address.slice(2) : address;
-        const buffer = Buffer.from(hex.padStart(length * 2, '0'), 'hex');
-        this._ensureCapacity(length);
-        buffer.copy(this.buffer, this.position, 0, length);
-        this.position += length;
-    }
-
-    toBuffer() {
-        return this.buffer.slice(0, this.position);
-    }
-}
-
-/**
- * JAELIS Serializer
- *
- * Fast serialization with multiple format support
- */
-class Serializer {
-    constructor(config = {}) {
-        this.config = {
-            format: config.serializer || 'cbor',
-            zeroCopy: config.zeroCopy !== false,
-            ...config
-        };
-
-        // Initialize encoders based on available libraries
-        if (this.config.format === 'cbor' && Encoder) {
-            this.cborEncoder = new Encoder({
-                structures: [],
-                useRecords: false
-            });
-            this.cborDecoder = new Decoder();
-        }
-
-        // Stats
-        this.stats = {
-            encodes: 0,
-            decodes: 0,
-            bytesEncoded: 0,
-            bytesDecoded: 0,
-            totalEncodeTime: 0,
-            totalDecodeTime: 0
-        };
-
-        console.log(`[Serializer] Using ${this.config.format.toUpperCase()} format`);
-    }
-
-    /**
-     * Serialize data to binary
-     *
-     * @param {any} data - Data to serialize
-     * @returns {Buffer} Serialized data
-     */
-    serialize(data) {
-        const start = Date.now();
-
-        let result;
-
-        switch (this.config.format) {
-            case 'cbor':
-                result = this._serializeCBOR(data);
-                break;
-            case 'msgpack':
-                result = this._serializeMsgPack(data);
-                break;
-            case 'zerocopy':
-                result = this._serializeZeroCopy(data);
-                break;
-            case 'json':
-            default:
-                result = this._serializeJSON(data);
-                break;
-        }
-
-        this.stats.encodes++;
-        this.stats.bytesEncoded += result.length;
-        this.stats.totalEncodeTime += Date.now() - start;
-
-        return result;
-    }
-
-    /**
-     * Deserialize binary to data
-     *
-     * @param {Buffer} buffer - Serialized data
-     * @returns {any} Deserialized data
-     */
-    deserialize(buffer) {
-        if (!buffer || buffer.length === 0) {
-            return null;
-        }
-
-        const start = Date.now();
-
-        let result;
-
-        switch (this.config.format) {
-            case 'cbor':
-                result = this._deserializeCBOR(buffer);
-                break;
-            case 'msgpack':
-                result = this._deserializeMsgPack(buffer);
-                break;
-            case 'zerocopy':
-                result = this._deserializeZeroCopy(buffer);
-                break;
-            case 'json':
-            default:
-                result = this._deserializeJSON(buffer);
-                break;
-        }
-
-        this.stats.decodes++;
-        this.stats.bytesDecoded += buffer.length;
-        this.stats.totalDecodeTime += Date.now() - start;
-
-        return result;
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // CBOR-X SERIALIZATION (3-10x faster than JSON!)
-    // ═══════════════════════════════════════════════════════════════
-
-    _serializeCBOR(data) {
-        if (this.cborEncoder) {
-            try {
-                // Pre-process for BigInt support
-                const processed = this._preprocessForSerialization(data);
-                return Buffer.from(this.cborEncoder.encode(processed));
-            } catch (e) {
-                console.warn('[Serializer] CBOR encode failed, falling back to JSON');
-                return this._serializeJSON(data);
-            }
-        }
-        return this._serializeJSON(data);
-    }
-
-    _deserializeCBOR(buffer) {
-        if (this.cborDecoder) {
-            try {
-                const decoded = this.cborDecoder.decode(buffer);
-                return this._postprocessFromSerialization(decoded);
-            } catch (e) {
-                console.warn('[Serializer] CBOR decode failed, trying JSON');
-                return this._deserializeJSON(buffer);
-            }
-        }
-        return this._deserializeJSON(buffer);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // MESSAGEPACK SERIALIZATION (37% smaller than JSON!)
-    // ═══════════════════════════════════════════════════════════════
-
-    _serializeMsgPack(data) {
-        if (pack) {
-            try {
-                const processed = this._preprocessForSerialization(data);
-                return pack(processed);
-            } catch (e) {
-                return this._serializeJSON(data);
-            }
-        }
-        return this._serializeJSON(data);
-    }
-
-    _deserializeMsgPack(buffer) {
-        if (unpack) {
-            try {
-                const decoded = unpack(buffer);
-                return this._postprocessFromSerialization(decoded);
-            } catch (e) {
-                return this._deserializeJSON(buffer);
-            }
-        }
-        return this._deserializeJSON(buffer);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // ZERO-COPY SERIALIZATION (Wincode-inspired, 100x+ for hot paths!)
-    // ═══════════════════════════════════════════════════════════════
-
-    _serializeZeroCopy(data) {
-        const writer = new ZeroCopyWriter();
-
-        this._writeValue(writer, data);
-
-        return writer.toBuffer();
-    }
-
-    _deserializeZeroCopy(buffer) {
-        const view = new ZeroCopyView(buffer);
-        return this._readValue(view);
-    }
-
-    _writeValue(writer, value) {
-        if (value === null || value === undefined) {
-            writer.writeUint8(0x00);  // Null
-        } else if (typeof value === 'boolean') {
-            writer.writeUint8(value ? 0x01 : 0x02);  // True/False
-        } else if (typeof value === 'number') {
-            if (Number.isInteger(value)) {
-                if (value >= 0 && value < 256) {
-                    writer.writeUint8(0x10);  // Uint8
-                    writer.writeUint8(value);
-                } else if (value >= 0) {
-                    writer.writeUint8(0x12);  // Uint64
-                    writer.writeUint64LE(value);
-                } else {
-                    writer.writeUint8(0x13);  // Int64
-                    writer.writeInt64LE(value);
-                }
-            } else {
-                writer.writeUint8(0x14);  // Float64
-                writer.writeFloat64LE(value);
-            }
-        } else if (typeof value === 'bigint') {
-            writer.writeUint8(0x20);  // BigInt
-            writer.writeUint256(value);
-        } else if (typeof value === 'string') {
-            writer.writeUint8(0x30);  // String
-            writer.writeString(value);
-        } else if (Buffer.isBuffer(value)) {
-            writer.writeUint8(0x40);  // Buffer
-            writer.writeBytes(value);
-        } else if (Array.isArray(value)) {
-            writer.writeUint8(0x50);  // Array
-            writer.writeVarInt(value.length);
-            for (const item of value) {
-                this._writeValue(writer, item);
-            }
-        } else if (typeof value === 'object') {
-            writer.writeUint8(0x60);  // Object
-            const keys = Object.keys(value);
-            writer.writeVarInt(keys.length);
-            for (const key of keys) {
-                writer.writeString(key);
-                this._writeValue(writer, value[key]);
-            }
-        }
-    }
-
-    _readValue(view) {
-        const type = view.readUint8();
-
-        switch (type) {
-            case 0x00:
-                return null;
-            case 0x01:
-                return true;
-            case 0x02:
-                return false;
-            case 0x10:
-                return view.readUint8();
-            case 0x11:
-                return view.readUint32LE();
-            case 0x12:
-                return Number(view.readUint64LE());
-            case 0x13:
-                return Number(view.readInt64LE());
-            case 0x14:
-                return view.readFloat64LE();
-            case 0x20:
-                return view.readUint256();
-            case 0x30:
-                return view.readString();
-            case 0x40:
-                return view.readBytes().toBuffer();
-            case 0x50: {
-                const length = view.readVarInt();
-                const array = [];
-                for (let i = 0; i < length; i++) {
-                    array.push(this._readValue(view));
-                }
-                return array;
-            }
-            case 0x60: {
-                const length = view.readVarInt();
-                const obj = {};
-                for (let i = 0; i < length; i++) {
-                    const key = view.readString();
-                    obj[key] = this._readValue(view);
-                }
-                return obj;
-            }
-            default:
-                throw new Error(`Unknown type: 0x${type.toString(16)}`);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // JSON FALLBACK
-    // ═══════════════════════════════════════════════════════════════
-
-    _serializeJSON(data) {
-        const processed = this._preprocessForSerialization(data);
-        return Buffer.from(JSON.stringify(processed));
-    }
-
-    _deserializeJSON(buffer) {
-        try {
-            const decoded = JSON.parse(buffer.toString());
-            return this._postprocessFromSerialization(decoded);
-        } catch (e) {
-            return null;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // PREPROCESSING FOR BIGINT SUPPORT
-    // ═══════════════════════════════════════════════════════════════
-
-    _preprocessForSerialization(data) {
-        if (data === null || data === undefined) {
-            return data;
-        }
-
-        if (typeof data === 'bigint') {
-            return { __type: 'bigint', value: data.toString() };
-        }
-
-        if (Buffer.isBuffer(data)) {
-            return { __type: 'buffer', value: data.toString('hex') };
-        }
-
-        if (Array.isArray(data)) {
-            return data.map(item => this._preprocessForSerialization(item));
-        }
-
-        if (typeof data === 'object') {
-            const result = {};
-            for (const [key, value] of Object.entries(data)) {
-                result[key] = this._preprocessForSerialization(value);
-            }
-            return result;
-        }
-
-        return data;
-    }
-
-    _postprocessFromSerialization(data) {
-        if (data === null || data === undefined) {
-            return data;
-        }
-
-        if (typeof data === 'object' && data.__type) {
-            switch (data.__type) {
-                case 'bigint':
-                    return BigInt(data.value);
-                case 'buffer':
-                    return Buffer.from(data.value, 'hex');
-            }
-        }
-
-        if (Array.isArray(data)) {
-            return data.map(item => this._postprocessFromSerialization(item));
-        }
-
-        if (typeof data === 'object') {
-            const result = {};
-            for (const [key, value] of Object.entries(data)) {
-                result[key] = this._postprocessFromSerialization(value);
-            }
-            return result;
-        }
-
-        return data;
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // SPECIALIZED SERIALIZATION (for blockchain types)
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Serialize a transaction
-     */
-    serializeTransaction(tx) {
-        const writer = new ZeroCopyWriter(256);
-
-        // Version
-        writer.writeUint8(1);
-
-        // Type
-        writer.writeUint8(tx.type || 0);
-
-        // Chain ID
-        writer.writeUint32LE(tx.chainId || 4545);
-
-        // Nonce
-        writer.writeUint64LE(tx.nonce || 0);
-
-        // From
-        writer.writeAddress(tx.from, 20);
-
-        // To
-        if (tx.to) {
-            writer.writeUint8(1);
-            writer.writeAddress(tx.to, 20);
-        } else {
-            writer.writeUint8(0);  // Contract creation
-        }
-
-        // Value
-        writer.writeUint256(tx.value || 0);
-
-        // Gas limit
-        writer.writeUint64LE(tx.gasLimit || 21000);
-
-        // Data
-        const data = tx.data || Buffer.alloc(0);
-        writer.writeBytes(Buffer.isBuffer(data) ? data : Buffer.from(data, 'hex'));
-
-        // Signature
-        if (tx.signature) {
-            writer.writeUint8(1);
-            writer.writeBytes(Buffer.from(tx.signature, 'hex'));
-        } else {
-            writer.writeUint8(0);
-        }
-
-        return writer.toBuffer();
-    }
-
-    /**
-     * Deserialize a transaction
-     */
-    deserializeTransaction(buffer) {
-        const view = new ZeroCopyView(buffer);
-
-        const version = view.readUint8();
-        if (version !== 1) {
-            throw new Error(`Unknown transaction version: ${version}`);
-        }
-
-        const tx = {
-            type: view.readUint8(),
-            chainId: view.readUint32LE(),
-            nonce: Number(view.readUint64LE()),
-            from: view.readAddress(20)
-        };
-
-        if (view.readUint8() === 1) {
-            tx.to = view.readAddress(20);
-        }
-
-        tx.value = view.readUint256();
-        tx.gasLimit = Number(view.readUint64LE());
-        tx.data = view.readBytes().toBuffer();
-
-        if (view.readUint8() === 1) {
-            tx.signature = view.readBytes().toBuffer().toString('hex');
-        }
-
-        return tx;
-    }
-
-    /**
-     * Serialize call data (function selector + args)
-     */
-    serializeCallData(functionSelector, args) {
-        const writer = new ZeroCopyWriter();
-
-        // 4-byte function selector
-        const selector = typeof functionSelector === 'string'
-            ? Buffer.from(functionSelector.replace('0x', ''), 'hex')
-            : functionSelector;
-        writer.writeBuffer(selector.slice(0, 4));
-
-        // Arguments
-        for (const arg of args) {
-            this._writeABIValue(writer, arg);
-        }
-
-        return writer.toBuffer();
-    }
-
-    _writeABIValue(writer, value) {
-        if (typeof value === 'bigint' || typeof value === 'number') {
-            // 32-byte padded
-            writer.writeUint256(value);
-        } else if (typeof value === 'string' && value.startsWith('0x')) {
-            // Address or bytes32
-            const bytes = Buffer.from(value.slice(2), 'hex');
-            if (bytes.length <= 32) {
-                const padded = Buffer.alloc(32);
-                bytes.copy(padded, 32 - bytes.length);
-                writer.writeBuffer(padded);
-            }
-        } else if (typeof value === 'boolean') {
-            writer.writeUint256(value ? 1 : 0);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // STATS
-    // ═══════════════════════════════════════════════════════════════
-
-    getStats() {
-        return {
-            ...this.stats,
-            avgEncodeTime: this.stats.encodes > 0
-                ? (this.stats.totalEncodeTime / this.stats.encodes).toFixed(2) + 'ms'
-                : '0ms',
-            avgDecodeTime: this.stats.decodes > 0
-                ? (this.stats.totalDecodeTime / this.stats.decodes).toFixed(2) + 'ms'
-                : '0ms',
-            format: this.config.format
-        };
-    }
-
-    resetStats() {
-        this.stats = {
-            encodes: 0,
-            decodes: 0,
-            bytesEncoded: 0,
-            bytesDecoded: 0,
-            totalEncodeTime: 0,
-            totalDecodeTime: 0
-        };
-    }
-}
-
-// Export classes
-module.exports = Serializer;
-module.exports.ZeroCopyView = ZeroCopyView;
-module.exports.ZeroCopyWriter = ZeroCopyWriter;