@aztec/simulator 0.52.0 → 0.54.0

package/src/avm/opcodes/memory.ts

@@ -1,39 +1,57 @@
 import type { AvmContext } from '../avm_context.js';
-import { Field, TaggedMemory, TypeTag } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
-import { BufferCursor } from '../serialization/buffer_cursor.js';
-import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
+import { Field, TaggedMemory } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 import { TwoOperandInstruction } from './instruction_impl.js';
 
-const TAG_TO_OPERAND_TYPE = new Map<TypeTag, OperandType>([
-  [TypeTag.UINT8, OperandType.UINT8],
-  [TypeTag.UINT16, OperandType.UINT16],
-  [TypeTag.UINT32, OperandType.UINT32],
-  [TypeTag.UINT64, OperandType.UINT64],
-  [TypeTag.UINT128, OperandType.UINT128],
-]);
-
-function getOperandTypeFromInTag(inTag: number | bigint): OperandType {
-  inTag = inTag as number;
-  const tagOperandType = TAG_TO_OPERAND_TYPE.get(inTag);
-  if (tagOperandType === undefined) {
-    throw new Error(`Invalid tag ${inTag} for SET.`);
-  }
-  return tagOperandType;
-}
-
 export class Set extends Instruction {
   static readonly type: string = 'SET';
-  static readonly opcode: Opcode = Opcode.SET;
-
-  private static readonly wireFormatBeforeConst: OperandType[] = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT8,
+  // Required for gas.
+  static readonly opcode: Opcode = Opcode.SET_8;
+
+  public static readonly wireFormat8: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT8, // const (value)
+    OperandType.UINT8, // dstOffset
+  ];
+  public static readonly wireFormat16: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT16, // const (value)
+    OperandType.UINT16, // dstOffset
+  ];
+  public static readonly wireFormat32: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT32, // const (value)
+    OperandType.UINT16, // dstOffset
+  ];
+  public static readonly wireFormat64: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT64, // const (value)
+    OperandType.UINT16, // dstOffset
+  ];
+  public static readonly wireFormat128: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.UINT128, // const (value)
+    OperandType.UINT16, // dstOffset
+  ];
+  public static readonly wireFormatFF: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect
+    OperandType.UINT8, // tag
+    OperandType.FF, // const (value)
+    OperandType.UINT16, // dstOffset
   ];
-  private static readonly wireFormatAfterConst: OperandType[] = [OperandType.UINT32];
 
   constructor(
     private indirect: number,
@@ -44,42 +62,13 @@ export class Set extends Instruction {
     super();
   }
 
-  /** We need to use a custom serialize function because of the variable length of the value. */
-  public override serialize(): Buffer {
-    const format: OperandType[] = [
-      ...Set.wireFormatBeforeConst,
-      getOperandTypeFromInTag(this.inTag),
-      ...Set.wireFormatAfterConst,
-    ];
-    return serialize(format, this);
-  }
-
-  /** We need to use a custom deserialize function because of the variable length of the value. */
-  public static override deserialize(this: typeof Set, buf: BufferCursor | Buffer): Set {
-    if (buf instanceof Buffer) {
-      buf = new BufferCursor(buf);
-    }
-    const beforeConst = deserialize(buf, Set.wireFormatBeforeConst);
-    const tag = beforeConst[beforeConst.length - 1];
-    const val = deserialize(buf, [getOperandTypeFromInTag(tag)]);
-    const afterConst = deserialize(buf, Set.wireFormatAfterConst);
-    const res = [...beforeConst, ...val, ...afterConst];
-    const args = res.slice(1) as ConstructorParameters<typeof Set>; // Remove opcode.
-    return new this(...args);
-  }
-
   public async execute(context: AvmContext): Promise<void> {
     const memoryOperations = { writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    // Per the YP, the tag cannot be a field.
-    if ([TypeTag.FIELD, TypeTag.UNINITIALIZED, TypeTag.INVALID].includes(this.inTag)) {
-      throw new InstructionExecutionError(`Invalid tag ${TypeTag[this.inTag]} for SET.`);
-    }
     const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
-
-    const res = TaggedMemory.integralFromTag(this.value, this.inTag);
+    const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
     memory.set(dstOffset, res);
 
     memory.assert(memoryOperations);
@@ -148,9 +137,7 @@ export class Cast extends TwoOperandInstruction {
     const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.dstOffset], memory);
 
     const a = memory.get(srcOffset);
-
-    const casted =
-      this.inTag == TypeTag.FIELD ? new Field(a.toBigInt()) : TaggedMemory.integralFromTag(a.toBigInt(), this.inTag);
+    const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.inTag);
 
     memory.set(dstOffset, casted);
 
@@ -161,13 +148,20 @@ export class Cast extends TwoOperandInstruction {
 
 export class Mov extends Instruction {
   static readonly type: string = 'MOV';
-  static readonly opcode: Opcode = Opcode.MOV;
-  // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat: OperandType[] = [
+  // FIXME: This is needed for gas.
+  static readonly opcode: Opcode = Opcode.MOV_8;
+
+  static readonly wireFormat8: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
+    OperandType.UINT8,
+    OperandType.UINT8,
+  ];
+  static readonly wireFormat16: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
   ];
 
   constructor(private indirect: number, private srcOffset: number, private dstOffset: number) {
@@ -202,21 +196,29 @@ export class CalldataCopy extends Instruction {
     OperandType.UINT32,
   ];
 
-  constructor(private indirect: number, private cdOffset: number, private copySize: number, private dstOffset: number) {
+  constructor(
+    private indirect: number,
+    private cdStartOffset: number,
+    private copySizeOffset: number,
+    private dstOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { writes: this.copySize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: this.copySize }));
-
     // We don't need to check tags here because: (1) the calldata is NOT in memory, and (2) we are the ones writing to destination.
-    const [cdOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.cdOffset, this.dstOffset], memory);
+    const [cdStartOffset, copySizeOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.cdStartOffset, this.copySizeOffset, this.dstOffset],
+      memory,
+    );
+
+    const cdStart = memory.get(cdStartOffset).toNumber();
+    const copySize = memory.get(copySizeOffset).toNumber();
+    const memoryOperations = { reads: 2, writes: copySize, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost({ ...memoryOperations, dynMultiplier: copySize }));
 
-    const transformedData = context.environment.calldata
-      .slice(cdOffset, cdOffset + this.copySize)
-      .map(f => new Field(f));
+    const transformedData = context.environment.calldata.slice(cdStart, cdStart + copySize).map(f => new Field(f));
 
     memory.setSlice(dstOffset, transformedData);
 

package/src/avm/serialization/bytecode_serialization.ts

@@ -2,7 +2,7 @@ import { PedersenCommitment } from '../opcodes/commitment.js';
 import { DAGasLeft, L2GasLeft } from '../opcodes/context_getters.js';
 import { EcAdd } from '../opcodes/ec_add.js';
 import { Keccak, KeccakF1600, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
-import type { Instruction } from '../opcodes/index.js';
+import { Instruction } from '../opcodes/index.js';
 import {
   Add,
   Address,
@@ -59,106 +59,122 @@ import { MultiScalarMul } from '../opcodes/multi_scalar_mul.js';
 import { BufferCursor } from './buffer_cursor.js';
 import { Opcode } from './instruction_serialization.js';
 
-interface DeserializableInstruction {
-  deserialize(buf: BufferCursor | Buffer): Instruction;
-  opcode: Opcode;
+export type InstructionDeserializer = (buf: BufferCursor | Buffer) => Instruction;
+
+export interface Serializable {
+  serialize(): Buffer;
+}
+
+export interface Deserializable {
+  deserialize: InstructionDeserializer;
 }
 
-export type InstructionSet = Map<Opcode, DeserializableInstruction>;
+export type InstructionSet = Map<Opcode, InstructionDeserializer>;
 // TODO(4359): This is a function so that Call and StaticCall can be lazily resolved.
 // This is a temporary solution until we solve the dependency cycle.
 const INSTRUCTION_SET = () =>
-  new Map<Opcode, DeserializableInstruction>([
-    [Add.opcode, Add],
-    [Sub.opcode, Sub],
-    [Mul.opcode, Mul],
-    [Div.opcode, Div],
-    [FieldDiv.opcode, FieldDiv],
-    [Eq.opcode, Eq],
-    [Lt.opcode, Lt],
-    [Lte.opcode, Lte],
-    [And.opcode, And],
-    [Or.opcode, Or],
-    [Xor.opcode, Xor],
-    [Not.opcode, Not],
-    [Shl.opcode, Shl],
-    [Shr.opcode, Shr],
-    [Cast.opcode, Cast],
-    [Address.opcode, Address],
-    [StorageAddress.opcode, StorageAddress],
-    [Sender.opcode, Sender],
-    [FunctionSelector.opcode, FunctionSelector],
-    [TransactionFee.opcode, TransactionFee],
+  new Map<Opcode, InstructionDeserializer>([
+    [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],
+    [Not.opcode, Instruction.deserialize.bind(Not)],
+    [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],
+    [Cast.opcode, Instruction.deserialize.bind(Cast)],
+    [Address.opcode, Instruction.deserialize.bind(Address)],
+    [StorageAddress.opcode, Instruction.deserialize.bind(StorageAddress)],
+    [Sender.opcode, Instruction.deserialize.bind(Sender)],
+    [FunctionSelector.opcode, Instruction.deserialize.bind(FunctionSelector)],
+    [TransactionFee.opcode, Instruction.deserialize.bind(TransactionFee)],
     // Execution Environment - Globals
-    [ChainId.opcode, ChainId],
-    [Version.opcode, Version],
-    [BlockNumber.opcode, BlockNumber],
-    [Timestamp.opcode, Timestamp],
-    //[Coinbase.opcode, Coinbase],
-    [FeePerL2Gas.opcode, FeePerL2Gas],
-    [FeePerDAGas.opcode, FeePerDAGas],
-    //[Blockl2gaslimit.opcode, Blockl2gaslimit],
-    //[Blockdagaslimit.opcode, Blockdagaslimit],
+    [ChainId.opcode, Instruction.deserialize.bind(ChainId)],
+    [Version.opcode, Instruction.deserialize.bind(Version)],
+    [BlockNumber.opcode, Instruction.deserialize.bind(BlockNumber)],
+    [Timestamp.opcode, Instruction.deserialize.bind(Timestamp)],
+    [FeePerL2Gas.opcode, Instruction.deserialize.bind(FeePerL2Gas)],
+    [FeePerDAGas.opcode, Instruction.deserialize.bind(FeePerDAGas)],
     // Execution Environment - Calldata
-    [CalldataCopy.opcode, CalldataCopy],
+    [CalldataCopy.opcode, Instruction.deserialize.bind(CalldataCopy)],
 
     // Machine State
     // Machine State - Gas
-    [L2GasLeft.opcode, L2GasLeft],
-    [DAGasLeft.opcode, DAGasLeft],
+    [L2GasLeft.opcode, Instruction.deserialize.bind(L2GasLeft)],
+    [DAGasLeft.opcode, Instruction.deserialize.bind(DAGasLeft)],
     // Machine State - Internal Control Flow
-    [Jump.opcode, Jump],
-    [JumpI.opcode, JumpI],
-    [InternalCall.opcode, InternalCall],
-    [InternalReturn.opcode, InternalReturn],
-    [Set.opcode, Set],
-    [Mov.opcode, Mov],
-    [CMov.opcode, CMov],
+    [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],
+    [CMov.opcode, Instruction.deserialize.bind(CMov)],
 
     // World State
-    [SLoad.opcode, SLoad], // Public Storage
-    [SStore.opcode, SStore], // Public Storage
-    [NoteHashExists.opcode, NoteHashExists], // Notes & Nullifiers
-    [EmitNoteHash.opcode, EmitNoteHash], // Notes & Nullifiers
-    [NullifierExists.opcode, NullifierExists], // Notes & Nullifiers
-    [EmitNullifier.opcode, EmitNullifier], // Notes & Nullifiers
-    [L1ToL2MessageExists.opcode, L1ToL2MessageExists], // Messages
-    //[HeaderMember.opcode, HeaderMember], // Header
+    [SLoad.opcode, Instruction.deserialize.bind(SLoad)], // Public Storage
+    [SStore.opcode, Instruction.deserialize.bind(SStore)], // Public Storage
+    [NoteHashExists.opcode, Instruction.deserialize.bind(NoteHashExists)], // Notes & Nullifiers
+    [EmitNoteHash.opcode, Instruction.deserialize.bind(EmitNoteHash)], // Notes & Nullifiers
+    [NullifierExists.opcode, Instruction.deserialize.bind(NullifierExists)], // Notes & Nullifiers
+    [EmitNullifier.opcode, Instruction.deserialize.bind(EmitNullifier)], // Notes & Nullifiers
+    [L1ToL2MessageExists.opcode, Instruction.deserialize.bind(L1ToL2MessageExists)], // Messages
 
     // Accrued Substate
-    [EmitUnencryptedLog.opcode, EmitUnencryptedLog],
-    [SendL2ToL1Message.opcode, SendL2ToL1Message],
-    [GetContractInstance.opcode, GetContractInstance],
+    [EmitUnencryptedLog.opcode, Instruction.deserialize.bind(EmitUnencryptedLog)],
+    [SendL2ToL1Message.opcode, Instruction.deserialize.bind(SendL2ToL1Message)],
+    [GetContractInstance.opcode, Instruction.deserialize.bind(GetContractInstance)],
 
     // Control Flow - Contract Calls
-    [Call.opcode, Call],
-    [StaticCall.opcode, StaticCall],
-    //[DelegateCall.opcode, DelegateCall],
-    [Return.opcode, Return],
-    [Revert.opcode, Revert],
+    [Call.opcode, Instruction.deserialize.bind(Call)],
+    [StaticCall.opcode, Instruction.deserialize.bind(StaticCall)],
+    //[DelegateCall.opcode, Instruction.deserialize.bind(DelegateCall)],
+    [Return.opcode, Instruction.deserialize.bind(Return)],
+    [Revert.opcode, Instruction.deserialize.bind(Revert)],
 
     // Misc
-    [DebugLog.opcode, DebugLog],
+    [DebugLog.opcode, Instruction.deserialize.bind(DebugLog)],
 
     // Gadgets
-    [EcAdd.opcode, EcAdd],
-    [Keccak.opcode, Keccak],
-    [Poseidon2.opcode, Poseidon2],
-    [Sha256.opcode, Sha256],
-    [Pedersen.opcode, Pedersen],
-    [MultiScalarMul.opcode, MultiScalarMul],
-    [PedersenCommitment.opcode, PedersenCommitment],
+    [EcAdd.opcode, Instruction.deserialize.bind(EcAdd)],
+    [Keccak.opcode, Instruction.deserialize.bind(Keccak)],
+    [Poseidon2.opcode, Instruction.deserialize.bind(Poseidon2)],
+    [Sha256.opcode, Instruction.deserialize.bind(Sha256)],
+    [Pedersen.opcode, Instruction.deserialize.bind(Pedersen)],
+    [MultiScalarMul.opcode, Instruction.deserialize.bind(MultiScalarMul)],
+    [PedersenCommitment.opcode, Instruction.deserialize.bind(PedersenCommitment)],
     // Conversions
-    [ToRadixLE.opcode, ToRadixLE],
+    [ToRadixLE.opcode, Instruction.deserialize.bind(ToRadixLE)],
     // Future Gadgets -- pending changes in noir
     // SHA256COMPRESSION,
-    [KeccakF1600.opcode, KeccakF1600],
+    [KeccakF1600.opcode, Instruction.deserialize.bind(KeccakF1600)],
   ]);
 
-interface Serializable {
-  serialize(): Buffer;
-}
-
 /**
  * Serializes an array of instructions to bytecode.
  */
@@ -186,8 +202,8 @@ export function decodeFromBytecode(
       throw new Error(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) not implemented`);
     }
 
-    const instructionDeserializer: DeserializableInstruction = instructionDeserializerOrUndef;
-    const i: Instruction = instructionDeserializer.deserialize(cursor);
+    const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
+    const i: Instruction = instructionDeserializer(cursor);
     instructions.push(i);
   }
 

package/src/avm/serialization/instruction_serialization.ts

@@ -8,20 +8,33 @@ import { BufferCursor } from './buffer_cursor.js';
  */
 export enum Opcode {
   // Compute
-  ADD,
-  SUB,
-  MUL,
-  DIV,
-  FDIV,
-  EQ,
-  LT,
-  LTE,
-  AND,
-  OR,
-  XOR,
+  ADD_8,
+  ADD_16,
+  SUB_8,
+  SUB_16,
+  MUL_8,
+  MUL_16,
+  DIV_8,
+  DIV_16,
+  FDIV_8,
+  FDIV_16,
+  EQ_8,
+  EQ_16,
+  LT_8,
+  LT_16,
+  LTE_8,
+  LTE_16,
+  AND_8,
+  AND_16,
+  OR_8,
+  OR_16,
+  XOR_8,
+  XOR_16,
   NOT,
-  SHL,
-  SHR,
+  SHL_8,
+  SHL_16,
+  SHR_8,
+  SHR_16,
   CAST,
   // Execution environment
   ADDRESS,
@@ -33,23 +46,26 @@ export enum Opcode {
   VERSION,
   BLOCKNUMBER,
   TIMESTAMP,
-  COINBASE,
   FEEPERL2GAS,
   FEEPERDAGAS,
-  BLOCKL2GASLIMIT,
-  BLOCKDAGASLIMIT,
   CALLDATACOPY,
   // Gas
   L2GASLEFT,
   DAGASLEFT,
   // Control flow
-  JUMP,
-  JUMPI,
+  JUMP_16,
+  JUMPI_16,
   INTERNALCALL,
   INTERNALRETURN,
   // Memory
-  SET,
-  MOV,
+  SET_8,
+  SET_16,
+  SET_32,
+  SET_64,
+  SET_128,
+  SET_FF,
+  MOV_8,
+  MOV_16,
   CMOV,
   // World state
   SLOAD,
@@ -59,7 +75,6 @@ export enum Opcode {
   NULLIFIEREXISTS,
   EMITNULLIFIER,
   L1TOL2MSGEXISTS,
-  HEADERMEMBER,
   GETCONTRACTINSTANCE,
   EMITUNENCRYPTEDLOG,
   SENDL2TOL1MSG,
@@ -96,6 +111,7 @@ export enum OperandType {
   UINT32,
   UINT64,
   UINT128,
+  FF,
 }
 
 type OperandNativeType = number | bigint;
@@ -108,8 +124,27 @@ const OPERAND_SPEC = new Map<OperandType, [number, () => OperandNativeType, Oper
   [OperandType.UINT32, [4, Buffer.prototype.readUint32BE, Buffer.prototype.writeUint32BE]],
   [OperandType.UINT64, [8, Buffer.prototype.readBigInt64BE, Buffer.prototype.writeBigInt64BE]],
   [OperandType.UINT128, [16, readBigInt128BE, writeBigInt128BE]],
+  [OperandType.FF, [32, readBigInt254BE, writeBigInt254BE]],
 ]);
 
+function readBigInt254BE(this: Buffer): bigint {
+  const totalBytes = 32;
+  let ret: bigint = 0n;
+  for (let i = 0; i < totalBytes; ++i) {
+    ret <<= 8n;
+    ret |= BigInt(this.readUint8(i));
+  }
+  return ret;
+}
+
+function writeBigInt254BE(this: Buffer, value: bigint): void {
+  const totalBytes = 32;
+  for (let offset = totalBytes - 1; offset >= 0; --offset) {
+    this.writeUint8(Number(value & 0xffn), offset);
+    value >>= 8n;
+  }
+}
+
 function readBigInt128BE(this: Buffer): bigint {
   const totalBytes = 16;
   let ret: bigint = 0n;
@@ -160,12 +195,10 @@ export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType
  * @param cls The class to be serialized.
  * @returns
  */
-export function serialize(operands: OperandType[], cls: any): Buffer {
+export function serializeAs(operands: OperandType[], opcode: Opcode, cls: any): Buffer {
   const chunks: Buffer[] = [];
 
-  // TODO: infer opcode not in this loop
-  assert(cls.constructor.opcode !== undefined && cls.constructor.opcode !== null);
-  const rawClassValues: any[] = [cls.constructor.opcode, ...Object.values(cls)];
+  const rawClassValues: any[] = [opcode, ...Object.values(cls)];
   assert(
     rawClassValues.length === operands.length,
     `Got ${rawClassValues.length} values but only ${operands.length} serialization operands are specified!`,

package/src/avm/test_utils.ts

@@ -28,8 +28,15 @@ export function mockStorageReadWithMap(hs: HostStorage, mockedStorage: Map<bigin
   );
 }
 
-export function mockNoteHashExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {
-  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getCommitmentIndex.mockResolvedValue(leafIndex.toBigInt());
+export function mockNoteHashExists(hs: HostStorage, _leafIndex: Fr, value?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getCommitmentValue.mockImplementation((index: bigint) => {
+    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 mockNullifierExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {

package/src/public/abstract_phase_manager.ts

@@ -47,6 +47,7 @@ import {
   PublicKernelData,
   ReadRequest,
   RevertCode,
+  TreeLeafReadRequest,
   makeEmptyProof,
   makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
@@ -412,7 +413,7 @@ export abstract class AbstractPhaseManager {
       returnsHash: computeVarArgsHash(result.returnValues),
       noteHashReadRequests: padArrayEnd(
         result.noteHashReadRequests,
-        ReadRequest.empty(),
+        TreeLeafReadRequest.empty(),
         MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
       ),
       nullifierReadRequests: padArrayEnd(
@@ -427,7 +428,7 @@ export abstract class AbstractPhaseManager {
       ),
       l1ToL2MsgReadRequests: padArrayEnd(
         result.l1ToL2MsgReadRequests,
-        ReadRequest.empty(),
+        TreeLeafReadRequest.empty(),
         MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
       ),
       contractStorageReads: padArrayEnd(

package/src/public/db_interfaces.ts

@@ -100,6 +100,13 @@ export interface CommitmentsDB {
    */
   getCommitmentIndex(commitment: Fr): Promise<bigint | undefined>;
 
+  /**
+   * Gets commitment in the note hash tree given a leaf index.
+   * @param leafIndex - the leaf to look up.
+   * @returns - The commitment at that index. Undefined if leaf index is not found.
+   */
+  getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined>;
+
   /**
    * Gets the index of a nullifier in the nullifier tree.
    * @param nullifier - The nullifier.

package/src/public/execution.ts

@@ -17,6 +17,7 @@ import {
   PublicCallStackItemCompressed,
   type ReadRequest,
   RevertCode,
+  type TreeLeafReadRequest,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 
@@ -62,13 +63,13 @@ export interface PublicExecutionResult {
   /** The new nullifiers to be inserted into the nullifier tree. */
   nullifiers: Nullifier[];
   /** The note hash read requests emitted in this call. */
-  noteHashReadRequests: ReadRequest[];
+  noteHashReadRequests: TreeLeafReadRequest[];
   /** The nullifier read requests emitted in this call. */
   nullifierReadRequests: ReadRequest[];
   /** The nullifier non existent read requests emitted in this call. */
   nullifierNonExistentReadRequests: ReadRequest[];
   /** L1 to L2 message read requests emitted in this call. */
-  l1ToL2MsgReadRequests: ReadRequest[];
+  l1ToL2MsgReadRequests: TreeLeafReadRequest[];
   /**
    * The hashed logs with side effect counter.
    * Note: required as we don't track the counter anywhere else.