@aztec/simulator 0.0.0-test.0

package/dest/public/avm/opcodes/memory.js

@@ -0,0 +1,253 @@
+import { Field, TaggedMemory, TypeTag, Uint32 } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+export class Set extends Instruction {
+    indirect;
+    dstOffset;
+    inTag;
+    value;
+    static type = 'SET';
+    // Required for gas.
+    static opcode = Opcode.SET_8;
+    static wireFormat8 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8
+    ];
+    static wireFormat16 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT8,
+        OperandType.UINT16
+    ];
+    static wireFormat32 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT8,
+        OperandType.UINT32
+    ];
+    static wireFormat64 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT8,
+        OperandType.UINT64
+    ];
+    static wireFormat128 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT8,
+        OperandType.UINT128
+    ];
+    static wireFormatFF = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT8,
+        OperandType.FF
+    ];
+    constructor(indirect, dstOffset, inTag, value){
+        super(), this.indirect = indirect, this.dstOffset = dstOffset, this.inTag = inTag, this.value = value;
+        TaggedMemory.checkIsValidTag(inTag);
+    }
+    async execute(context) {
+        // Constructor ensured that this.inTag is a valid tag
+        const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [dstOffset] = addressing.resolve(operands, memory);
+        memory.set(dstOffset, res);
+    }
+}
+export class Cast extends Instruction {
+    indirect;
+    srcOffset;
+    dstOffset;
+    dstTag;
+    static type = 'CAST';
+    static opcode = Opcode.CAST_8;
+    static wireFormat8 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8
+    ];
+    static wireFormat16 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT8
+    ];
+    constructor(indirect, srcOffset, dstOffset, dstTag){
+        super(), this.indirect = indirect, this.srcOffset = srcOffset, this.dstOffset = dstOffset, this.dstTag = dstTag;
+        TaggedMemory.checkIsValidTag(dstTag);
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.srcOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
+        const a = memory.get(srcOffset);
+        // Constructor ensured that this.dstTag is a valid tag
+        const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.dstTag);
+        memory.set(dstOffset, casted);
+    }
+}
+export class Mov extends Instruction {
+    indirect;
+    srcOffset;
+    dstOffset;
+    static type = 'MOV';
+    // FIXME: This is needed for gas.
+    static opcode = Opcode.MOV_8;
+    static wireFormat8 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT8
+    ];
+    static wireFormat16 = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, srcOffset, dstOffset){
+        super(), this.indirect = indirect, this.srcOffset = srcOffset, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.srcOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
+        const a = memory.get(srcOffset);
+        memory.set(dstOffset, a);
+    }
+}
+export class CalldataCopy extends Instruction {
+    indirect;
+    cdStartOffset;
+    copySizeOffset;
+    dstOffset;
+    static type = 'CALLDATACOPY';
+    static opcode = Opcode.CALLDATACOPY;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, cdStartOffset, copySizeOffset, dstOffset){
+        super(), this.indirect = indirect, this.cdStartOffset = cdStartOffset, this.copySizeOffset = copySizeOffset, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.cdStartOffset,
+            this.copySizeOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [cdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
+        memory.checkTags(TypeTag.UINT32, cdStartOffset, copySizeOffset);
+        const cdStart = memory.get(cdStartOffset).toNumber();
+        const copySize = memory.get(copySizeOffset).toNumber();
+        context.machineState.consumeGas(this.gasCost(copySize));
+        // Values which are out-of-range of the calldata array will be set with Field(0);
+        const slice = context.environment.calldata.slice(cdStart, cdStart + copySize).map((f)=>new Field(f));
+        // slice has size = MIN(copySize, calldata.length - cdStart) as TS truncates out-of-range portion
+        const transformedData = [
+            ...slice,
+            ...Array(copySize - slice.length).fill(new Field(0))
+        ];
+        memory.setSlice(dstOffset, transformedData);
+    }
+}
+export class ReturndataSize extends Instruction {
+    indirect;
+    dstOffset;
+    static type = 'RETURNDATASIZE';
+    static opcode = Opcode.RETURNDATASIZE;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16
+    ];
+    constructor(indirect, dstOffset){
+        super(), this.indirect = indirect, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [dstOffset] = addressing.resolve(operands, memory);
+        context.machineState.consumeGas(this.gasCost());
+        memory.set(dstOffset, new Uint32(context.machineState.nestedReturndata.length));
+    }
+}
+export class ReturndataCopy extends Instruction {
+    indirect;
+    rdStartOffset;
+    copySizeOffset;
+    dstOffset;
+    static type = 'RETURNDATACOPY';
+    static opcode = Opcode.RETURNDATACOPY;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, rdStartOffset, copySizeOffset, dstOffset){
+        super(), this.indirect = indirect, this.rdStartOffset = rdStartOffset, this.copySizeOffset = copySizeOffset, this.dstOffset = dstOffset;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.rdStartOffset,
+            this.copySizeOffset,
+            this.dstOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [rdStartOffset, copySizeOffset, dstOffset] = addressing.resolve(operands, memory);
+        memory.checkTags(TypeTag.UINT32, rdStartOffset, copySizeOffset);
+        const rdStart = memory.get(rdStartOffset).toNumber();
+        const copySize = memory.get(copySizeOffset).toNumber();
+        context.machineState.consumeGas(this.gasCost(copySize));
+        // Values which are out-of-range of the returndata array will be set with Field(0);
+        const slice = context.machineState.nestedReturndata.slice(rdStart, rdStart + copySize).map((f)=>new Field(f));
+        // slice has size = MIN(copySize, returndata.length - rdStart) as TS truncates out-of-range portion
+        const transformedData = [
+            ...slice,
+            ...Array(copySize - slice.length).fill(new Field(0))
+        ];
+        memory.setSlice(dstOffset, transformedData);
+    }
+}

package/dest/public/avm/opcodes/misc.d.ts

@@ -0,0 +1,17 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+export declare class DebugLog extends Instruction {
+    private indirect;
+    private messageOffset;
+    private fieldsOffset;
+    private fieldsSizeOffset;
+    private messageSize;
+    static type: string;
+    static readonly opcode: Opcode;
+    static readonly logger: import("@aztec/foundation/log").Logger;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, messageOffset: number, fieldsOffset: number, fieldsSizeOffset: number, messageSize: number);
+    execute(context: AvmContext): Promise<void>;
+}
+//# sourceMappingURL=misc.d.ts.map

package/dest/public/avm/opcodes/misc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/misc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qBAAa,QAAS,SAAQ,WAAW;IAgBrC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,WAAW;IAnBrB,MAAM,CAAC,IAAI,EAAE,MAAM,CAAc;IACjC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAmB;IACjD,MAAM,CAAC,QAAQ,CAAC,MAAM,yCAA2C;IAGjE,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW,EAAE,CAOvC;gBAGQ,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,MAAM;IAKhB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CA0BzD"}

package/dest/public/avm/opcodes/misc.js

@@ -0,0 +1,48 @@
+import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import { TypeTag } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+export class DebugLog extends Instruction {
+    indirect;
+    messageOffset;
+    fieldsOffset;
+    fieldsSizeOffset;
+    messageSize;
+    static type = 'DEBUGLOG';
+    static opcode = Opcode.DEBUGLOG;
+    static logger = createLogger('simulator:avm:debug_log');
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, messageOffset, fieldsOffset, fieldsSizeOffset, messageSize){
+        super(), this.indirect = indirect, this.messageOffset = messageOffset, this.fieldsOffset = fieldsOffset, this.fieldsSizeOffset = fieldsSizeOffset, this.messageSize = messageSize;
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        const operands = [
+            this.messageOffset,
+            this.fieldsOffset,
+            this.fieldsSizeOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
+        memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
+        const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
+        const rawMessage = memory.getSlice(messageOffset, this.messageSize);
+        const fields = memory.getSlice(fieldsOffset, fieldsSize);
+        memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
+        memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
+        context.machineState.consumeGas(this.gasCost(this.messageSize + fieldsSize));
+        // Interpret str<N> = [u8; N] to string.
+        const messageAsStr = rawMessage.map((field)=>String.fromCharCode(field.toNumber())).join('');
+        const formattedStr = applyStringFormatting(messageAsStr, fields.map((field)=>field.toFr()));
+        DebugLog.logger.verbose(formattedStr);
+    }
+}

package/dest/public/avm/opcodes/storage.d.ts

@@ -0,0 +1,24 @@
+import type { AvmContext } from '../avm_context.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Instruction } from './instruction.js';
+declare abstract class BaseStorageInstruction extends Instruction {
+    protected indirect: number;
+    protected aOffset: number;
+    protected bOffset: number;
+    static readonly wireFormat: OperandType[];
+    constructor(indirect: number, aOffset: number, bOffset: number);
+}
+export declare class SStore extends BaseStorageInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.SSTORE;
+    constructor(indirect: number, srcOffset: number, slotOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export declare class SLoad extends BaseStorageInstruction {
+    static readonly type: string;
+    static readonly opcode = Opcode.SLOAD;
+    constructor(indirect: number, slotOffset: number, dstOffset: number);
+    execute(context: AvmContext): Promise<void>;
+}
+export {};
+//# sourceMappingURL=storage.d.ts.map

package/dest/public/avm/opcodes/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/opcodes/storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEpF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,uBAAe,sBAAuB,SAAQ,WAAW;IAS3C,SAAS,CAAC,QAAQ,EAAE,MAAM;IAAE,SAAS,CAAC,OAAO,EAAE,MAAM;IAAE,SAAS,CAAC,OAAO,EAAE,MAAM;IAP5F,gBAAuB,UAAU,EAAE,WAAW,EAAE,CAK9C;gBAEoB,QAAQ,EAAE,MAAM,EAAY,OAAO,EAAE,MAAM,EAAY,OAAO,EAAE,MAAM;CAG7F;AAED,qBAAa,MAAO,SAAQ,sBAAsB;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAY;IACxC,MAAM,CAAC,QAAQ,CAAC,MAAM,iBAAiB;gBAE3B,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAItD,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAkBzD;AAED,qBAAa,KAAM,SAAQ,sBAAsB;IAC/C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAW;IACvC,MAAM,CAAC,QAAQ,CAAC,MAAM,gBAAgB;gBAE1B,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAItD,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAazD"}

package/dest/public/avm/opcodes/storage.js

@@ -0,0 +1,66 @@
+import { Field, TypeTag } from '../avm_memory_types.js';
+import { StaticCallAlterationError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+class BaseStorageInstruction extends Instruction {
+    indirect;
+    aOffset;
+    bOffset;
+    // Informs (de)serialization. See Instruction.deserialize.
+    static wireFormat = [
+        OperandType.UINT8,
+        OperandType.UINT8,
+        OperandType.UINT16,
+        OperandType.UINT16
+    ];
+    constructor(indirect, aOffset, bOffset){
+        super(), this.indirect = indirect, this.aOffset = aOffset, this.bOffset = bOffset;
+    }
+}
+export class SStore extends BaseStorageInstruction {
+    static type = 'SSTORE';
+    static opcode = Opcode.SSTORE;
+    constructor(indirect, srcOffset, slotOffset){
+        super(indirect, srcOffset, slotOffset);
+    }
+    async execute(context) {
+        if (context.environment.isStaticCall) {
+            throw new StaticCallAlterationError();
+        }
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.aOffset,
+            this.bOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [srcOffset, slotOffset] = addressing.resolve(operands, memory);
+        memory.checkTag(TypeTag.FIELD, slotOffset);
+        memory.checkTag(TypeTag.FIELD, srcOffset);
+        const slot = memory.get(slotOffset).toFr();
+        const value = memory.get(srcOffset).toFr();
+        await context.persistableState.writeStorage(context.environment.address, slot, value);
+    }
+}
+export class SLoad extends BaseStorageInstruction {
+    static type = 'SLOAD';
+    static opcode = Opcode.SLOAD;
+    constructor(indirect, slotOffset, dstOffset){
+        super(indirect, slotOffset, dstOffset);
+    }
+    async execute(context) {
+        const memory = context.machineState.memory;
+        context.machineState.consumeGas(this.gasCost());
+        const operands = [
+            this.aOffset,
+            this.bOffset
+        ];
+        const addressing = Addressing.fromWire(this.indirect, operands.length);
+        const [slotOffset, dstOffset] = addressing.resolve(operands, memory);
+        memory.checkTag(TypeTag.FIELD, slotOffset);
+        const slot = memory.get(slotOffset).toFr();
+        const value = await context.persistableState.readStorage(context.environment.address, slot);
+        memory.set(dstOffset, new Field(value));
+    }
+}

package/dest/public/avm/serialization/buffer_cursor.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+export declare class BufferCursor {
+    private _buffer;
+    private _position;
+    constructor(_buffer: Buffer, _position?: number);
+    position(): number;
+    buffer(): Buffer;
+    eof(): boolean;
+    bufferAtPosition(): Buffer;
+    advance(n: number): void;
+    peekUint8(): number;
+    readUint8(): number;
+    readUint16LE(): number;
+    readUint16BE(): number;
+    readUint32LE(): number;
+    readUint32BE(): number;
+    readBigInt64LE(): bigint;
+    readBigInt64BE(): bigint;
+    writeUint8(v: number): number;
+    writeUint16LE(v: number): number;
+    writeUint16BE(v: number): number;
+    writeUint32LE(v: number): number;
+    writeUint32BE(v: number): number;
+    writeBigInt64LE(v: bigint): number;
+    writeBigInt64BE(v: bigint): number;
+}
+//# sourceMappingURL=buffer_cursor.d.ts.map

package/dest/public/avm/serialization/buffer_cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_cursor.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/serialization/buffer_cursor.ts"],"names":[],"mappings":";;AAGA,qBAAa,YAAY;IACX,OAAO,CAAC,OAAO;IAAU,OAAO,CAAC,SAAS;gBAAlC,OAAO,EAAE,MAAM,EAAU,SAAS,GAAE,MAAU;IAE3D,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,MAAM;IAIhB,GAAG,IAAI,OAAO;IAId,gBAAgB,IAAI,MAAM;IAI1B,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAIxB,SAAS,IAAI,MAAM;IAKnB,SAAS,IAAI,MAAM;IAMnB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,cAAc,IAAI,MAAM;IAMxB,cAAc,IAAI,MAAM;IAMxB,UAAU,CAAC,CAAC,EAAE,MAAM;IAMpB,aAAa,CAAC,CAAC,EAAE,MAAM;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAMvB,eAAe,CAAC,CAAC,EAAE,MAAM;IAMzB,eAAe,CAAC,CAAC,EAAE,MAAM;CAKjC"}

package/dest/public/avm/serialization/buffer_cursor.js

@@ -0,0 +1,99 @@
+/*
+ * A Buffer-like class that automatically advances the position.
+ */ export class BufferCursor {
+    _buffer;
+    _position;
+    constructor(_buffer, _position = 0){
+        this._buffer = _buffer;
+        this._position = _position;
+    }
+    position() {
+        return this._position;
+    }
+    buffer() {
+        return this._buffer;
+    }
+    eof() {
+        return this._position === this._buffer.length;
+    }
+    bufferAtPosition() {
+        return this._buffer.subarray(this._position);
+    }
+    advance(n) {
+        this._position += n;
+    }
+    peekUint8() {
+        const ret = this._buffer.readUint8(this._position);
+        return ret;
+    }
+    readUint8() {
+        const ret = this._buffer.readUint8(this._position);
+        this._position += 1;
+        return ret;
+    }
+    readUint16LE() {
+        const ret = this._buffer.readUint16LE(this._position);
+        this._position += 2;
+        return ret;
+    }
+    readUint16BE() {
+        const ret = this._buffer.readUint16BE(this._position);
+        this._position += 2;
+        return ret;
+    }
+    readUint32LE() {
+        const ret = this._buffer.readUint32LE(this._position);
+        this._position += 4;
+        return ret;
+    }
+    readUint32BE() {
+        const ret = this._buffer.readUint32BE(this._position);
+        this._position += 4;
+        return ret;
+    }
+    readBigInt64LE() {
+        const ret = this._buffer.readBigInt64LE(this._position);
+        this._position += 8;
+        return ret;
+    }
+    readBigInt64BE() {
+        const ret = this._buffer.readBigInt64BE(this._position);
+        this._position += 8;
+        return ret;
+    }
+    writeUint8(v) {
+        const ret = this._buffer.writeUint8(v, this._position);
+        this._position += 1;
+        return ret;
+    }
+    writeUint16LE(v) {
+        const ret = this._buffer.writeUint16LE(v, this._position);
+        this._position += 2;
+        return ret;
+    }
+    writeUint16BE(v) {
+        const ret = this._buffer.writeUint16BE(v, this._position);
+        this._position += 2;
+        return ret;
+    }
+    writeUint32LE(v) {
+        const ret = this._buffer.writeUint32LE(v, this._position);
+        this._position += 4;
+        return ret;
+    }
+    writeUint32BE(v) {
+        const ret = this._buffer.writeUint32BE(v, this._position);
+        this._position += 4;
+        return ret;
+    }
+    writeBigInt64LE(v) {
+        const ret = this._buffer.writeBigInt64LE(v, this._position);
+        this._position += 8;
+        return ret;
+    }
+    writeBigInt64BE(v) {
+        const ret = this._buffer.writeBigInt64BE(v, this._position);
+        this._position += 8;
+        return ret;
+    }
+}

package/dest/public/avm/serialization/bytecode_serialization.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Instruction } from '../opcodes/index.js';
+import { BufferCursor } from './buffer_cursor.js';
+import { Opcode } from './instruction_serialization.js';
+export type InstructionDeserializer = (buf: BufferCursor | Buffer) => Instruction;
+export interface Serializable {
+    serialize(): Buffer;
+}
+export interface Deserializable {
+    deserialize: InstructionDeserializer;
+}
+export type InstructionSet = Map<Opcode, InstructionDeserializer>;
+export declare const INSTRUCTION_SET: Map<Opcode, InstructionDeserializer>;
+/**
+ * Serializes an array of instructions to bytecode.
+ */
+export declare function encodeToBytecode(instructions: Serializable[]): Buffer;
+export declare function decodeFromBytecode(bytecode: Buffer, instructionSet?: InstructionSet): Instruction[];
+export declare function decodeInstructionFromBytecode(bytecode: Buffer, pc: number, instructionSet?: InstructionSet): [Instruction, number];
+//# sourceMappingURL=bytecode_serialization.d.ts.map

package/dest/public/avm/serialization/bytecode_serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytecode_serialization.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/serialization/bytecode_serialization.ts"],"names":[],"mappings":";;AACA,OAAO,EAgBL,WAAW,EAgCZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAoB,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAE1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,KAAK,WAAW,CAAC;AAElF,MAAM,WAAW,YAAY;IAC3B,SAAS,IAAI,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,uBAAuB,CAAC;CACtC;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;AAClE,eAAO,MAAM,eAAe,sCAoF1B,CAAC;AAEH;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,MAAM,CAErE;AAGD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,GAAE,cAAgC,GAAG,WAAW,EAAE,CASpH;AAGD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,EACV,cAAc,GAAE,cAAgC,GAC/C,CAAC,WAAW,EAAE,MAAM,CAAC,CA+BvB"}