@aztec/simulator 0.0.0-test.0

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

@@ -0,0 +1,332 @@
+import { AvmExecutionError, AvmParsingError, InvalidOpcodeError, InvalidProgramCounterError } from '../errors.js';
+import { Add, And, Call, CalldataCopy, Cast, DebugLog, Div, EcAdd, EmitNoteHash, EmitNullifier, EmitUnencryptedLog, Eq, FieldDiv, GetContractInstance, GetEnvVar, Instruction, InternalCall, InternalReturn, Jump, JumpI, KeccakF1600, L1ToL2MessageExists, Lt, Lte, Mov, Mul, Not, NoteHashExists, NullifierExists, Or, Poseidon2, Return, ReturndataCopy, ReturndataSize, Revert, SLoad, SStore, SendL2ToL1Message, Set, Sha256Compression, Shl, Shr, StaticCall, Sub, SuccessCopy, ToRadixBE, Xor } from '../opcodes/index.js';
+import { BufferCursor } from './buffer_cursor.js';
+import { MAX_OPCODE_VALUE, Opcode } from './instruction_serialization.js';
+export const INSTRUCTION_SET = new Map([
+    [
+        Opcode.ADD_8,
+        Add.as(Add.wireFormat8).deserialize
+    ],
+    [
+        Opcode.ADD_16,
+        Add.as(Add.wireFormat16).deserialize
+    ],
+    [
+        Opcode.SUB_8,
+        Sub.as(Sub.wireFormat8).deserialize
+    ],
+    [
+        Opcode.SUB_16,
+        Sub.as(Sub.wireFormat16).deserialize
+    ],
+    [
+        Opcode.MUL_8,
+        Mul.as(Mul.wireFormat8).deserialize
+    ],
+    [
+        Opcode.MUL_16,
+        Mul.as(Mul.wireFormat16).deserialize
+    ],
+    [
+        Opcode.DIV_8,
+        Div.as(Div.wireFormat8).deserialize
+    ],
+    [
+        Opcode.DIV_16,
+        Div.as(Div.wireFormat16).deserialize
+    ],
+    [
+        Opcode.FDIV_8,
+        FieldDiv.as(FieldDiv.wireFormat8).deserialize
+    ],
+    [
+        Opcode.FDIV_16,
+        FieldDiv.as(FieldDiv.wireFormat16).deserialize
+    ],
+    [
+        Opcode.EQ_8,
+        Eq.as(Eq.wireFormat8).deserialize
+    ],
+    [
+        Opcode.EQ_16,
+        Eq.as(Eq.wireFormat16).deserialize
+    ],
+    [
+        Opcode.LT_8,
+        Lt.as(Lt.wireFormat8).deserialize
+    ],
+    [
+        Opcode.LT_16,
+        Lt.as(Lt.wireFormat16).deserialize
+    ],
+    [
+        Opcode.LTE_8,
+        Lte.as(Lte.wireFormat8).deserialize
+    ],
+    [
+        Opcode.LTE_16,
+        Lte.as(Lte.wireFormat16).deserialize
+    ],
+    [
+        Opcode.AND_8,
+        And.as(And.wireFormat8).deserialize
+    ],
+    [
+        Opcode.AND_16,
+        And.as(And.wireFormat16).deserialize
+    ],
+    [
+        Opcode.OR_8,
+        Or.as(Or.wireFormat8).deserialize
+    ],
+    [
+        Opcode.OR_16,
+        Or.as(Or.wireFormat16).deserialize
+    ],
+    [
+        Opcode.XOR_8,
+        Xor.as(Xor.wireFormat8).deserialize
+    ],
+    [
+        Opcode.XOR_16,
+        Xor.as(Xor.wireFormat16).deserialize
+    ],
+    [
+        Opcode.NOT_8,
+        Not.as(Not.wireFormat8).deserialize
+    ],
+    [
+        Opcode.NOT_16,
+        Not.as(Not.wireFormat16).deserialize
+    ],
+    [
+        Opcode.SHL_8,
+        Shl.as(Shl.wireFormat8).deserialize
+    ],
+    [
+        Opcode.SHL_16,
+        Shl.as(Shl.wireFormat16).deserialize
+    ],
+    [
+        Opcode.SHR_8,
+        Shr.as(Shr.wireFormat8).deserialize
+    ],
+    [
+        Opcode.SHR_16,
+        Shr.as(Shr.wireFormat16).deserialize
+    ],
+    [
+        Opcode.CAST_8,
+        Cast.as(Cast.wireFormat8).deserialize
+    ],
+    [
+        Opcode.CAST_16,
+        Cast.as(Cast.wireFormat16).deserialize
+    ],
+    // Execution Environment
+    [
+        Opcode.GETENVVAR_16,
+        GetEnvVar.as(GetEnvVar.wireFormat16).deserialize
+    ],
+    [
+        CalldataCopy.opcode,
+        Instruction.deserialize.bind(CalldataCopy)
+    ],
+    [
+        SuccessCopy.opcode,
+        Instruction.deserialize.bind(SuccessCopy)
+    ],
+    [
+        Opcode.RETURNDATASIZE,
+        Instruction.deserialize.bind(ReturndataSize)
+    ],
+    [
+        Opcode.RETURNDATACOPY,
+        Instruction.deserialize.bind(ReturndataCopy)
+    ],
+    // Machine State - Internal Control Flow
+    [
+        Jump.opcode,
+        Instruction.deserialize.bind(Jump)
+    ],
+    [
+        JumpI.opcode,
+        Instruction.deserialize.bind(JumpI)
+    ],
+    [
+        InternalCall.opcode,
+        Instruction.deserialize.bind(InternalCall)
+    ],
+    [
+        InternalReturn.opcode,
+        Instruction.deserialize.bind(InternalReturn)
+    ],
+    [
+        Opcode.SET_8,
+        Set.as(Set.wireFormat8).deserialize
+    ],
+    [
+        Opcode.SET_16,
+        Set.as(Set.wireFormat16).deserialize
+    ],
+    [
+        Opcode.SET_32,
+        Set.as(Set.wireFormat32).deserialize
+    ],
+    [
+        Opcode.SET_64,
+        Set.as(Set.wireFormat64).deserialize
+    ],
+    [
+        Opcode.SET_128,
+        Set.as(Set.wireFormat128).deserialize
+    ],
+    [
+        Opcode.SET_FF,
+        Set.as(Set.wireFormatFF).deserialize
+    ],
+    [
+        Opcode.MOV_8,
+        Mov.as(Mov.wireFormat8).deserialize
+    ],
+    [
+        Opcode.MOV_16,
+        Mov.as(Mov.wireFormat16).deserialize
+    ],
+    // World State
+    [
+        SLoad.opcode,
+        Instruction.deserialize.bind(SLoad)
+    ],
+    [
+        SStore.opcode,
+        Instruction.deserialize.bind(SStore)
+    ],
+    [
+        NoteHashExists.opcode,
+        Instruction.deserialize.bind(NoteHashExists)
+    ],
+    [
+        EmitNoteHash.opcode,
+        Instruction.deserialize.bind(EmitNoteHash)
+    ],
+    [
+        NullifierExists.opcode,
+        Instruction.deserialize.bind(NullifierExists)
+    ],
+    [
+        EmitNullifier.opcode,
+        Instruction.deserialize.bind(EmitNullifier)
+    ],
+    [
+        L1ToL2MessageExists.opcode,
+        Instruction.deserialize.bind(L1ToL2MessageExists)
+    ],
+    // Accrued Substate
+    [
+        EmitUnencryptedLog.opcode,
+        Instruction.deserialize.bind(EmitUnencryptedLog)
+    ],
+    [
+        SendL2ToL1Message.opcode,
+        Instruction.deserialize.bind(SendL2ToL1Message)
+    ],
+    [
+        GetContractInstance.opcode,
+        Instruction.deserialize.bind(GetContractInstance)
+    ],
+    // Control Flow - Contract Calls
+    [
+        Call.opcode,
+        Instruction.deserialize.bind(Call)
+    ],
+    [
+        StaticCall.opcode,
+        Instruction.deserialize.bind(StaticCall)
+    ],
+    [
+        Return.opcode,
+        Instruction.deserialize.bind(Return)
+    ],
+    [
+        Opcode.REVERT_8,
+        Revert.as(Revert.wireFormat8).deserialize
+    ],
+    [
+        Opcode.REVERT_16,
+        Revert.as(Revert.wireFormat16).deserialize
+    ],
+    // Misc
+    [
+        DebugLog.opcode,
+        Instruction.deserialize.bind(DebugLog)
+    ],
+    // Gadgets
+    [
+        EcAdd.opcode,
+        Instruction.deserialize.bind(EcAdd)
+    ],
+    [
+        Poseidon2.opcode,
+        Instruction.deserialize.bind(Poseidon2)
+    ],
+    [
+        Sha256Compression.opcode,
+        Instruction.deserialize.bind(Sha256Compression)
+    ],
+    [
+        KeccakF1600.opcode,
+        Instruction.deserialize.bind(KeccakF1600)
+    ],
+    // Conversions
+    [
+        ToRadixBE.opcode,
+        Instruction.deserialize.bind(ToRadixBE)
+    ]
+]);
+/**
+ * Serializes an array of instructions to bytecode.
+ */ export function encodeToBytecode(instructions) {
+    return Buffer.concat(instructions.map((i)=>i.serialize()));
+}
+// For testing only
+export function decodeFromBytecode(bytecode, instructionSet = INSTRUCTION_SET) {
+    const instructions = [];
+    let pc = 0;
+    while(pc < bytecode.length){
+        const [instruction, bytesConsumed] = decodeInstructionFromBytecode(bytecode, pc, instructionSet);
+        instructions.push(instruction);
+        pc += bytesConsumed;
+    }
+    return instructions;
+}
+// Returns the instruction and the number of bytes consumed.
+export function decodeInstructionFromBytecode(bytecode, pc, instructionSet = INSTRUCTION_SET) {
+    if (pc >= bytecode.length) {
+        throw new InvalidProgramCounterError(pc, bytecode.length);
+    }
+    try {
+        const cursor = new BufferCursor(bytecode, pc);
+        const startingPosition = cursor.position();
+        const opcode = cursor.bufferAtPosition().readUint8(); // peek.
+        if (opcode > MAX_OPCODE_VALUE) {
+            throw new InvalidOpcodeError(`Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes.`);
+        }
+        const instructionDeserializerOrUndef = instructionSet.get(opcode);
+        if (instructionDeserializerOrUndef === undefined) {
+            throw new InvalidOpcodeError(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) is not implemented`);
+        }
+        const instructionDeserializer = instructionDeserializerOrUndef;
+        const instruction = instructionDeserializer(cursor);
+        return [
+            instruction,
+            cursor.position() - startingPosition
+        ];
+    } catch (error) {
+        if (error instanceof InvalidOpcodeError || error instanceof AvmExecutionError) {
+            throw error;
+        } else {
+            throw new AvmParsingError(`${error}`);
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { BufferCursor } from './buffer_cursor.js';
+/**
+ * All AVM opcodes. (Keep in sync with cpp counterpart code avm_opcode.hpp and rs in opcodes.rs).
+ * Source: https://yp-aztec.netlify.app/docs/public-vm/instruction-set
+ */
+export declare enum Opcode {
+    ADD_8 = 0,
+    ADD_16 = 1,
+    SUB_8 = 2,
+    SUB_16 = 3,
+    MUL_8 = 4,
+    MUL_16 = 5,
+    DIV_8 = 6,
+    DIV_16 = 7,
+    FDIV_8 = 8,
+    FDIV_16 = 9,
+    EQ_8 = 10,
+    EQ_16 = 11,
+    LT_8 = 12,
+    LT_16 = 13,
+    LTE_8 = 14,
+    LTE_16 = 15,
+    AND_8 = 16,
+    AND_16 = 17,
+    OR_8 = 18,
+    OR_16 = 19,
+    XOR_8 = 20,
+    XOR_16 = 21,
+    NOT_8 = 22,
+    NOT_16 = 23,
+    SHL_8 = 24,
+    SHL_16 = 25,
+    SHR_8 = 26,
+    SHR_16 = 27,
+    CAST_8 = 28,
+    CAST_16 = 29,
+    GETENVVAR_16 = 30,
+    CALLDATACOPY = 31,
+    SUCCESSCOPY = 32,
+    RETURNDATASIZE = 33,
+    RETURNDATACOPY = 34,
+    JUMP_32 = 35,
+    JUMPI_32 = 36,
+    INTERNALCALL = 37,
+    INTERNALRETURN = 38,
+    SET_8 = 39,
+    SET_16 = 40,
+    SET_32 = 41,
+    SET_64 = 42,
+    SET_128 = 43,
+    SET_FF = 44,
+    MOV_8 = 45,
+    MOV_16 = 46,
+    SLOAD = 47,
+    SSTORE = 48,
+    NOTEHASHEXISTS = 49,
+    EMITNOTEHASH = 50,
+    NULLIFIEREXISTS = 51,
+    EMITNULLIFIER = 52,
+    L1TOL2MSGEXISTS = 53,
+    GETCONTRACTINSTANCE = 54,
+    EMITUNENCRYPTEDLOG = 55,
+    SENDL2TOL1MSG = 56,
+    CALL = 57,
+    STATICCALL = 58,
+    RETURN = 59,
+    REVERT_8 = 60,
+    REVERT_16 = 61,
+    DEBUGLOG = 62,
+    POSEIDON2 = 63,
+    SHA256COMPRESSION = 64,
+    KECCAKF1600 = 65,
+    ECADD = 66,
+    TORADIXBE = 67
+}
+export declare const MAX_OPCODE_VALUE: number;
+export declare enum OperandType {
+    UINT8 = 0,
+    UINT16 = 1,
+    UINT32 = 2,
+    UINT64 = 3,
+    UINT128 = 4,
+    FF = 5
+}
+/**
+ * Reads an array of operands from a buffer.
+ * @param cursor Buffer to read from. Might be longer than needed.
+ * @param operands Specification of the operand types.
+ * @returns An array as big as {@code operands}, with the converted TS values.
+ */
+export declare function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): (number | bigint)[];
+/**
+ * Serializes a class using the specified operand types.
+ * More specifically, this serializes {@code [cls.constructor.opcode, ...Object.values(cls)]}.
+ * Observe in particular that:
+ *   (1) the first operand type specified must correspond to the opcode;
+ *   (2) the rest of the operand types must be specified in the order returned by {@code Object.values()}.
+ * @param operands Type specification for the values to be serialized.
+ * @param cls The class to be serialized.
+ * @returns
+ */
+export declare function serializeAs(operands: OperandType[], opcode: Opcode, cls: any): Buffer;
+//# sourceMappingURL=instruction_serialization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instruction_serialization.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/serialization/instruction_serialization.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;GAGG;AACH,oBAAY,MAAM;IAEhB,KAAK,IAAA;IACL,MAAM,IAAA;IACN,KAAK,IAAA;IACL,MAAM,IAAA;IACN,KAAK,IAAA;IACL,MAAM,IAAA;IACN,KAAK,IAAA;IACL,MAAM,IAAA;IACN,MAAM,IAAA;IACN,OAAO,IAAA;IACP,IAAI,KAAA;IACJ,KAAK,KAAA;IACL,IAAI,KAAA;IACJ,KAAK,KAAA;IACL,KAAK,KAAA;IACL,MAAM,KAAA;IACN,KAAK,KAAA;IACL,MAAM,KAAA;IACN,IAAI,KAAA;IACJ,KAAK,KAAA;IACL,KAAK,KAAA;IACL,MAAM,KAAA;IACN,KAAK,KAAA;IACL,MAAM,KAAA;IACN,KAAK,KAAA;IACL,MAAM,KAAA;IACN,KAAK,KAAA;IACL,MAAM,KAAA;IACN,MAAM,KAAA;IACN,OAAO,KAAA;IAEP,YAAY,KAAA;IACZ,YAAY,KAAA;IACZ,WAAW,KAAA;IACX,cAAc,KAAA;IACd,cAAc,KAAA;IAEd,OAAO,KAAA;IACP,QAAQ,KAAA;IACR,YAAY,KAAA;IACZ,cAAc,KAAA;IAEd,KAAK,KAAA;IACL,MAAM,KAAA;IACN,MAAM,KAAA;IACN,MAAM,KAAA;IACN,OAAO,KAAA;IACP,MAAM,KAAA;IACN,KAAK,KAAA;IACL,MAAM,KAAA;IAEN,KAAK,KAAA;IACL,MAAM,KAAA;IACN,cAAc,KAAA;IACd,YAAY,KAAA;IACZ,eAAe,KAAA;IACf,aAAa,KAAA;IACb,eAAe,KAAA;IACf,mBAAmB,KAAA;IACnB,kBAAkB,KAAA;IAClB,aAAa,KAAA;IAEb,IAAI,KAAA;IACJ,UAAU,KAAA;IACV,MAAM,KAAA;IACN,QAAQ,KAAA;IACR,SAAS,KAAA;IAET,QAAQ,KAAA;IAER,SAAS,KAAA;IACT,iBAAiB,KAAA;IACjB,WAAW,KAAA;IACX,KAAK,KAAA;IAEL,SAAS,KAAA;CACV;AAED,eAAO,MAAM,gBAAgB,QAI5B,CAAC;AAMF,oBAAY,WAAW;IACrB,KAAK,IAAA;IACL,MAAM,IAAA;IACN,MAAM,IAAA;IACN,MAAM,IAAA;IACN,OAAO,IAAA;IACP,EAAE,IAAA;CACH;AAmDD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAcvG;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAmBrF"}

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

@@ -0,0 +1,226 @@
+import { strict as assert } from 'assert';
+import { BufferCursor } from './buffer_cursor.js';
+/**
+ * All AVM opcodes. (Keep in sync with cpp counterpart code avm_opcode.hpp and rs in opcodes.rs).
+ * Source: https://yp-aztec.netlify.app/docs/public-vm/instruction-set
+ */ export var Opcode = /*#__PURE__*/ function(Opcode) {
+    // Compute
+    Opcode[Opcode["ADD_8"] = 0] = "ADD_8";
+    Opcode[Opcode["ADD_16"] = 1] = "ADD_16";
+    Opcode[Opcode["SUB_8"] = 2] = "SUB_8";
+    Opcode[Opcode["SUB_16"] = 3] = "SUB_16";
+    Opcode[Opcode["MUL_8"] = 4] = "MUL_8";
+    Opcode[Opcode["MUL_16"] = 5] = "MUL_16";
+    Opcode[Opcode["DIV_8"] = 6] = "DIV_8";
+    Opcode[Opcode["DIV_16"] = 7] = "DIV_16";
+    Opcode[Opcode["FDIV_8"] = 8] = "FDIV_8";
+    Opcode[Opcode["FDIV_16"] = 9] = "FDIV_16";
+    Opcode[Opcode["EQ_8"] = 10] = "EQ_8";
+    Opcode[Opcode["EQ_16"] = 11] = "EQ_16";
+    Opcode[Opcode["LT_8"] = 12] = "LT_8";
+    Opcode[Opcode["LT_16"] = 13] = "LT_16";
+    Opcode[Opcode["LTE_8"] = 14] = "LTE_8";
+    Opcode[Opcode["LTE_16"] = 15] = "LTE_16";
+    Opcode[Opcode["AND_8"] = 16] = "AND_8";
+    Opcode[Opcode["AND_16"] = 17] = "AND_16";
+    Opcode[Opcode["OR_8"] = 18] = "OR_8";
+    Opcode[Opcode["OR_16"] = 19] = "OR_16";
+    Opcode[Opcode["XOR_8"] = 20] = "XOR_8";
+    Opcode[Opcode["XOR_16"] = 21] = "XOR_16";
+    Opcode[Opcode["NOT_8"] = 22] = "NOT_8";
+    Opcode[Opcode["NOT_16"] = 23] = "NOT_16";
+    Opcode[Opcode["SHL_8"] = 24] = "SHL_8";
+    Opcode[Opcode["SHL_16"] = 25] = "SHL_16";
+    Opcode[Opcode["SHR_8"] = 26] = "SHR_8";
+    Opcode[Opcode["SHR_16"] = 27] = "SHR_16";
+    Opcode[Opcode["CAST_8"] = 28] = "CAST_8";
+    Opcode[Opcode["CAST_16"] = 29] = "CAST_16";
+    // Execution environment
+    Opcode[Opcode["GETENVVAR_16"] = 30] = "GETENVVAR_16";
+    Opcode[Opcode["CALLDATACOPY"] = 31] = "CALLDATACOPY";
+    Opcode[Opcode["SUCCESSCOPY"] = 32] = "SUCCESSCOPY";
+    Opcode[Opcode["RETURNDATASIZE"] = 33] = "RETURNDATASIZE";
+    Opcode[Opcode["RETURNDATACOPY"] = 34] = "RETURNDATACOPY";
+    // Control flow
+    Opcode[Opcode["JUMP_32"] = 35] = "JUMP_32";
+    Opcode[Opcode["JUMPI_32"] = 36] = "JUMPI_32";
+    Opcode[Opcode["INTERNALCALL"] = 37] = "INTERNALCALL";
+    Opcode[Opcode["INTERNALRETURN"] = 38] = "INTERNALRETURN";
+    // Memory
+    Opcode[Opcode["SET_8"] = 39] = "SET_8";
+    Opcode[Opcode["SET_16"] = 40] = "SET_16";
+    Opcode[Opcode["SET_32"] = 41] = "SET_32";
+    Opcode[Opcode["SET_64"] = 42] = "SET_64";
+    Opcode[Opcode["SET_128"] = 43] = "SET_128";
+    Opcode[Opcode["SET_FF"] = 44] = "SET_FF";
+    Opcode[Opcode["MOV_8"] = 45] = "MOV_8";
+    Opcode[Opcode["MOV_16"] = 46] = "MOV_16";
+    // World state
+    Opcode[Opcode["SLOAD"] = 47] = "SLOAD";
+    Opcode[Opcode["SSTORE"] = 48] = "SSTORE";
+    Opcode[Opcode["NOTEHASHEXISTS"] = 49] = "NOTEHASHEXISTS";
+    Opcode[Opcode["EMITNOTEHASH"] = 50] = "EMITNOTEHASH";
+    Opcode[Opcode["NULLIFIEREXISTS"] = 51] = "NULLIFIEREXISTS";
+    Opcode[Opcode["EMITNULLIFIER"] = 52] = "EMITNULLIFIER";
+    Opcode[Opcode["L1TOL2MSGEXISTS"] = 53] = "L1TOL2MSGEXISTS";
+    Opcode[Opcode["GETCONTRACTINSTANCE"] = 54] = "GETCONTRACTINSTANCE";
+    Opcode[Opcode["EMITUNENCRYPTEDLOG"] = 55] = "EMITUNENCRYPTEDLOG";
+    Opcode[Opcode["SENDL2TOL1MSG"] = 56] = "SENDL2TOL1MSG";
+    // External calls
+    Opcode[Opcode["CALL"] = 57] = "CALL";
+    Opcode[Opcode["STATICCALL"] = 58] = "STATICCALL";
+    Opcode[Opcode["RETURN"] = 59] = "RETURN";
+    Opcode[Opcode["REVERT_8"] = 60] = "REVERT_8";
+    Opcode[Opcode["REVERT_16"] = 61] = "REVERT_16";
+    // Misc
+    Opcode[Opcode["DEBUGLOG"] = 62] = "DEBUGLOG";
+    // Gadgets
+    Opcode[Opcode["POSEIDON2"] = 63] = "POSEIDON2";
+    Opcode[Opcode["SHA256COMPRESSION"] = 64] = "SHA256COMPRESSION";
+    Opcode[Opcode["KECCAKF1600"] = 65] = "KECCAKF1600";
+    Opcode[Opcode["ECADD"] = 66] = "ECADD";
+    // Conversion
+    Opcode[Opcode["TORADIXBE"] = 67] = "TORADIXBE";
+    return Opcode;
+}({});
+export const MAX_OPCODE_VALUE = Math.max(...Object.values(Opcode).map((k)=>+k).filter((k)=>!isNaN(k)));
+// Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.
+// See vm/avm_trace/deserialization.cpp)
+// Note that cpp code introduced an additional enum value TAG to express the instruction tag. In TS,
+// this one is parsed as UINT8.
+export var OperandType = /*#__PURE__*/ function(OperandType) {
+    OperandType[OperandType["UINT8"] = 0] = "UINT8";
+    OperandType[OperandType["UINT16"] = 1] = "UINT16";
+    OperandType[OperandType["UINT32"] = 2] = "UINT32";
+    OperandType[OperandType["UINT64"] = 3] = "UINT64";
+    OperandType[OperandType["UINT128"] = 4] = "UINT128";
+    OperandType[OperandType["FF"] = 5] = "FF";
+    return OperandType;
+}({});
+// Specifies how to read and write each operand type.
+const OPERAND_SPEC = new Map([
+    [
+        0,
+        [
+            1,
+            Buffer.prototype.readUint8,
+            Buffer.prototype.writeUint8
+        ]
+    ],
+    [
+        1,
+        [
+            2,
+            Buffer.prototype.readUint16BE,
+            Buffer.prototype.writeUint16BE
+        ]
+    ],
+    [
+        2,
+        [
+            4,
+            Buffer.prototype.readUint32BE,
+            Buffer.prototype.writeUint32BE
+        ]
+    ],
+    [
+        3,
+        [
+            8,
+            Buffer.prototype.readBigInt64BE,
+            Buffer.prototype.writeBigInt64BE
+        ]
+    ],
+    [
+        4,
+        [
+            16,
+            readBigInt128BE,
+            writeBigInt128BE
+        ]
+    ],
+    [
+        5,
+        [
+            32,
+            readBigInt254BE,
+            writeBigInt254BE
+        ]
+    ]
+]);
+function readBigInt254BE(offset) {
+    const totalBytes = 32;
+    let ret = 0n;
+    for(let i = 0; i < totalBytes; ++i){
+        ret <<= 8n;
+        ret |= BigInt(this.readUint8(i + offset));
+    }
+    return ret;
+}
+function writeBigInt254BE(value) {
+    const totalBytes = 32;
+    for(let offset = totalBytes - 1; offset >= 0; --offset){
+        this.writeUint8(Number(value & 0xffn), offset);
+        value >>= 8n;
+    }
+}
+function readBigInt128BE(offset) {
+    const totalBytes = 16;
+    let ret = 0n;
+    for(let i = 0; i < totalBytes; ++i){
+        ret <<= 8n;
+        ret |= BigInt(this.readUint8(i + offset));
+    }
+    return ret;
+}
+function writeBigInt128BE(value) {
+    const totalBytes = 16;
+    for(let offset = totalBytes - 1; offset >= 0; --offset){
+        this.writeUint8(Number(value & 0xffn), offset);
+        value >>= 8n;
+    }
+}
+/**
+ * Reads an array of operands from a buffer.
+ * @param cursor Buffer to read from. Might be longer than needed.
+ * @param operands Specification of the operand types.
+ * @returns An array as big as {@code operands}, with the converted TS values.
+ */ export function deserialize(cursor, operands) {
+    const argValues = [];
+    if (Buffer.isBuffer(cursor)) {
+        cursor = new BufferCursor(cursor);
+    }
+    for (const op of operands){
+        const opType = op;
+        const [sizeBytes, reader, _writer] = OPERAND_SPEC.get(opType);
+        argValues.push(reader.call(cursor.buffer(), cursor.position()));
+        cursor.advance(sizeBytes);
+    }
+    return argValues;
+}
+/**
+ * Serializes a class using the specified operand types.
+ * More specifically, this serializes {@code [cls.constructor.opcode, ...Object.values(cls)]}.
+ * Observe in particular that:
+ *   (1) the first operand type specified must correspond to the opcode;
+ *   (2) the rest of the operand types must be specified in the order returned by {@code Object.values()}.
+ * @param operands Type specification for the values to be serialized.
+ * @param cls The class to be serialized.
+ * @returns
+ */ export function serializeAs(operands, opcode, cls) {
+    const chunks = [];
+    const rawClassValues = [
+        opcode,
+        ...Object.values(cls)
+    ];
+    assert(rawClassValues.length === operands.length, `Got ${rawClassValues.length} values but only ${operands.length} serialization operands are specified!`);
+    const classValues = rawClassValues;
+    for(let i = 0; i < operands.length; i++){
+        const opType = operands[i];
+        const [sizeBytes, _reader, writer] = OPERAND_SPEC.get(opType);
+        const buf = Buffer.alloc(sizeBytes);
+        writer.call(buf, classValues[i]);
+        chunks.push(buf);
+    }
+    return Buffer.concat(chunks);
+}

package/dest/public/avm/test_utils.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { type ContractClassPublic, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { WorldStateDB } from '../../public/public_db_sources.js';
+import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
+export declare function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer): Promise<void>;
+export declare function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface): void;
+export declare function mockStorageRead(worldStateDB: WorldStateDB, value: Fr): void;
+export declare function mockNoteHashCount(mockedTrace: PublicSideEffectTraceInterface, count: number): void;
+export declare function mockStorageReadWithMap(worldStateDB: WorldStateDB, mockedStorage: Map<bigint, Fr>): void;
+export declare function mockGetBytecodeCommitment(worldStateDB: WorldStateDB, commitment: Fr): void;
+export declare function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, value?: Fr): void;
+export declare function mockGetNullifierIndex(worldStateDB: WorldStateDB, leafIndex: Fr, _ignoredValue?: Fr): void;
+export declare function mockL1ToL2MessageExists(worldStateDB: WorldStateDB, leafIndex: Fr, value: Fr, valueAtOtherIndices?: Fr): void;
+export declare function mockGetContractInstance(worldStateDB: WorldStateDB, contractInstance: ContractInstanceWithAddress): void;
+export declare function mockGetContractClass(worldStateDB: WorldStateDB, contractClass: ContractClassPublic): void;
+//# sourceMappingURL=test_utils.d.ts.map

package/dest/public/avm/test_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../src/public/avm/test_utils.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,EAEjC,MAAM,wBAAwB,CAAC;AAKhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AAExF,wBAAsB,eAAe,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAGjF;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,8BAA8B,EAAE,WAAW,CAAC,EAAE,8BAA8B,QAIhH;AAED,wBAAgB,eAAe,CAAC,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,QAEpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,8BAA8B,EAAE,KAAK,EAAE,MAAM,QAE3F;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,QAIhG;AAED,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,QAEnF;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,QASxF;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,EAAE,EAAE,aAAa,CAAC,EAAE,EAAE,QAElG;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,EAAE,EACb,KAAK,EAAE,EAAE,EACT,mBAAmB,CAAC,EAAE,EAAE,QAWzB;AAED,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,2BAA2B,QAEhH;AAED,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,mBAAmB,QAElG"}