@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

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

@@ -0,0 +1,328 @@
+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, 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)
+    ],
+    [
+        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/{avm → public/avm}/serialization/instruction_serialization.d.ts

@@ -72,8 +72,7 @@ export declare enum Opcode {
     SHA256COMPRESSION = 63,
     KECCAKF1600 = 64,
     ECADD = 65,
-    MSM = 66,
-    TORADIXBE = 67
+    TORADIXBE = 66
 }
 export declare const MAX_OPCODE_VALUE: number;
 export declare enum OperandType {

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,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,225 @@
+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["RETURNDATASIZE"] = 32] = "RETURNDATASIZE";
+    Opcode[Opcode["RETURNDATACOPY"] = 33] = "RETURNDATACOPY";
+    // Control flow
+    Opcode[Opcode["JUMP_32"] = 34] = "JUMP_32";
+    Opcode[Opcode["JUMPI_32"] = 35] = "JUMPI_32";
+    Opcode[Opcode["INTERNALCALL"] = 36] = "INTERNALCALL";
+    Opcode[Opcode["INTERNALRETURN"] = 37] = "INTERNALRETURN";
+    // Memory
+    Opcode[Opcode["SET_8"] = 38] = "SET_8";
+    Opcode[Opcode["SET_16"] = 39] = "SET_16";
+    Opcode[Opcode["SET_32"] = 40] = "SET_32";
+    Opcode[Opcode["SET_64"] = 41] = "SET_64";
+    Opcode[Opcode["SET_128"] = 42] = "SET_128";
+    Opcode[Opcode["SET_FF"] = 43] = "SET_FF";
+    Opcode[Opcode["MOV_8"] = 44] = "MOV_8";
+    Opcode[Opcode["MOV_16"] = 45] = "MOV_16";
+    // World state
+    Opcode[Opcode["SLOAD"] = 46] = "SLOAD";
+    Opcode[Opcode["SSTORE"] = 47] = "SSTORE";
+    Opcode[Opcode["NOTEHASHEXISTS"] = 48] = "NOTEHASHEXISTS";
+    Opcode[Opcode["EMITNOTEHASH"] = 49] = "EMITNOTEHASH";
+    Opcode[Opcode["NULLIFIEREXISTS"] = 50] = "NULLIFIEREXISTS";
+    Opcode[Opcode["EMITNULLIFIER"] = 51] = "EMITNULLIFIER";
+    Opcode[Opcode["L1TOL2MSGEXISTS"] = 52] = "L1TOL2MSGEXISTS";
+    Opcode[Opcode["GETCONTRACTINSTANCE"] = 53] = "GETCONTRACTINSTANCE";
+    Opcode[Opcode["EMITUNENCRYPTEDLOG"] = 54] = "EMITUNENCRYPTEDLOG";
+    Opcode[Opcode["SENDL2TOL1MSG"] = 55] = "SENDL2TOL1MSG";
+    // External calls
+    Opcode[Opcode["CALL"] = 56] = "CALL";
+    Opcode[Opcode["STATICCALL"] = 57] = "STATICCALL";
+    Opcode[Opcode["RETURN"] = 58] = "RETURN";
+    Opcode[Opcode["REVERT_8"] = 59] = "REVERT_8";
+    Opcode[Opcode["REVERT_16"] = 60] = "REVERT_16";
+    // Misc
+    Opcode[Opcode["DEBUGLOG"] = 61] = "DEBUGLOG";
+    // Gadgets
+    Opcode[Opcode["POSEIDON2"] = 62] = "POSEIDON2";
+    Opcode[Opcode["SHA256COMPRESSION"] = 63] = "SHA256COMPRESSION";
+    Opcode[Opcode["KECCAKF1600"] = 64] = "KECCAKF1600";
+    Opcode[Opcode["ECADD"] = 65] = "ECADD";
+    // Conversion
+    Opcode[Opcode["TORADIXBE"] = 66] = "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/{avm → public/avm}/test_utils.d.ts

@@ -1,15 +1,17 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type ContractClassPublic, type ContractInstanceWithAddress, Fr } from '@aztec/circuits.js';
-import { type WorldStateDB } from '../public/public_db_sources.js';
-import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace_interface.js';
+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 mockNullifierExists(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;

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"}

package/dest/public/avm/test_utils.js

@@ -0,0 +1,52 @@
+import { Fr } from '@aztec/foundation/fields';
+import { computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
+import { mock } from 'jest-mock-extended';
+export async function mockGetBytecode(worldStateDB, bytecode) {
+    const commitment = await computePublicBytecodeCommitment(bytecode);
+    worldStateDB.getBytecodeCommitment.mockResolvedValue(commitment);
+}
+export function mockTraceFork(trace, nestedTrace) {
+    trace.fork.mockReturnValue(nestedTrace ?? mock());
+}
+export function mockStorageRead(worldStateDB, value) {
+    worldStateDB.storageRead.mockResolvedValue(value);
+}
+export function mockNoteHashCount(mockedTrace, count) {
+    mockedTrace.getNoteHashCount.mockReturnValue(count);
+}
+export function mockStorageReadWithMap(worldStateDB, mockedStorage) {
+    worldStateDB.storageRead.mockImplementation((_address, slot)=>Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO));
+}
+export function mockGetBytecodeCommitment(worldStateDB, commitment) {
+    worldStateDB.getBytecodeCommitment.mockResolvedValue(commitment);
+}
+export function mockNoteHashExists(worldStateDB, _leafIndex, value) {
+    worldStateDB.getCommitmentValue.mockImplementation((index)=>{
+        if (index == _leafIndex.toBigInt()) {
+            return Promise.resolve(value);
+        } else {
+            // This is ok for now since the traceing functions handle it
+            return Promise.resolve(undefined);
+        }
+    });
+}
+export function mockGetNullifierIndex(worldStateDB, leafIndex, _ignoredValue) {
+    worldStateDB.getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+}
+export function mockL1ToL2MessageExists(worldStateDB, leafIndex, value, valueAtOtherIndices) {
+    worldStateDB.getL1ToL2LeafValue.mockImplementation((index)=>{
+        if (index == leafIndex.toBigInt()) {
+            return Promise.resolve(value);
+        } else {
+            // any indices other than mockAtLeafIndex will return a different value
+            // (or undefined if no value is specified for other indices)
+            return Promise.resolve(valueAtOtherIndices);
+        }
+    });
+}
+export function mockGetContractInstance(worldStateDB, contractInstance) {
+    worldStateDB.getContractInstance.mockResolvedValue(contractInstance);
+}
+export function mockGetContractClass(worldStateDB, contractClass) {
+    worldStateDB.getContractClass.mockResolvedValue(contractClass);
+}

package/dest/public/bytecode_errors.js

@@ -1,7 +1,6 @@
 export class ContractClassBytecodeError extends Error {
-    constructor(contractAddress) {
+    constructor(contractAddress){
         super(`Failed to get bytecode for contract at address ${contractAddress}`);
         this.name = 'ContractClassBytecodeError';
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnl0ZWNvZGVfZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B1YmxpYy9ieXRlY29kZV9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLDBCQUEyQixTQUFRLEtBQUs7SUFDbkQsWUFBWSxlQUF1QjtRQUNqQyxLQUFLLENBQUMsa0RBQWtELGVBQWUsRUFBRSxDQUFDLENBQUM7UUFDM0UsSUFBSSxDQUFDLElBQUksR0FBRyw0QkFBNEIsQ0FBQztJQUMzQyxDQUFDO0NBQ0YifQ==

package/dest/public/execution.d.ts

@@ -1,7 +1,13 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type PublicExecutionRequest, type SimulationError } from '@aztec/circuit-types';
-import { type AvmExecutionHints, type ContractStorageRead, type ContractStorageUpdateRequest, type Fr, Gas, type L2ToL1Message, type NoteHash, type Nullifier, type PublicDataUpdateRequest, PublicInnerCallRequest, type PublicLog, type ReadRequest, type ScopedL2ToL1Message, type TreeLeafReadRequest } from '@aztec/circuits.js';
+import type { Fr } from '@aztec/foundation/fields';
+import { type AvmExecutionHints, type ContractStorageRead, type ContractStorageUpdateRequest, type PublicDataUpdateRequest, PublicInnerCallRequest } from '@aztec/stdlib/avm';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import { Gas } from '@aztec/stdlib/gas';
+import type { NoteHash, Nullifier, ReadRequest, TreeLeafReadRequest } from '@aztec/stdlib/kernel';
+import type { PublicLog } from '@aztec/stdlib/logs';
+import type { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import type { PublicExecutionRequest } from '@aztec/stdlib/tx';
 export interface PublicSideEffects {
     /** The contract storage update requests performed. */
     publicDataWrites: PublicDataUpdateRequest[];