@aztec/simulator 0.53.0 → 0.55.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);
@@ -134,7 +123,7 @@ export class CMov extends Instruction {
 
 export class Cast extends TwoOperandInstruction {
   static readonly type: string = 'CAST';
-  static readonly opcode = Opcode.CAST;
+  static readonly opcode = Opcode.CAST_8;
 
   constructor(indirect: number, dstTag: number, srcOffset: number, dstOffset: number) {
     super(indirect, dstTag, srcOffset, dstOffset);
@@ -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) {

package/src/avm/serialization/bytecode_serialization.ts

@@ -2,7 +2,6 @@ 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 {
   Add,
   Address,
@@ -24,6 +23,7 @@ import {
   FieldDiv,
   FunctionSelector,
   GetContractInstance,
+  Instruction,
   InternalCall,
   InternalReturn,
   Jump,
@@ -59,102 +59,125 @@ 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],
+    [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],
+    [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],
-    [FeePerL2Gas.opcode, FeePerL2Gas],
-    [FeePerDAGas.opcode, FeePerDAGas],
+    [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
+    [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)],
+    [Opcode.REVERT_8, Revert.as(Revert.wireFormat8).deserialize],
+    [Opcode.REVERT_16, Revert.as(Revert.wireFormat16).deserialize],
 
     // 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.
  */
@@ -182,8 +205,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,21 +8,36 @@ import { BufferCursor } from './buffer_cursor.js';
  */
 export enum Opcode {
   // Compute
-  ADD,
-  SUB,
-  MUL,
-  DIV,
-  FDIV,
-  EQ,
-  LT,
-  LTE,
-  AND,
-  OR,
-  XOR,
-  NOT,
-  SHL,
-  SHR,
-  CAST,
+  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_8,
+  NOT_16,
+  SHL_8,
+  SHL_16,
+  SHR_8,
+  SHR_16,
+  CAST_8,
+  CAST_16,
   // Execution environment
   ADDRESS,
   STORAGEADDRESS,
@@ -40,13 +55,19 @@ export enum Opcode {
   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,
@@ -64,7 +85,8 @@ export enum Opcode {
   STATICCALL,
   DELEGATECALL,
   RETURN,
-  REVERT,
+  REVERT_8,
+  REVERT_16,
   // Misc
   DEBUGLOG,
   // Gadgets
@@ -92,6 +114,7 @@ export enum OperandType {
   UINT32,
   UINT64,
   UINT128,
+  FF,
 }
 
 type OperandNativeType = number | bigint;
@@ -104,8 +127,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;
@@ -156,12 +198,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/public/hints_builder.ts

@@ -7,7 +7,6 @@ import {
   type MAX_NULLIFIERS_PER_TX,
   type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  type MAX_PUBLIC_DATA_HINTS,
   type MAX_PUBLIC_DATA_READS_PER_TX,
   type MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
@@ -15,7 +14,6 @@ import {
   NULLIFIER_TREE_HEIGHT,
   type Nullifier,
   PUBLIC_DATA_TREE_HEIGHT,
-  type PublicDataHint,
   type PublicDataRead,
   type PublicDataTreeLeafPreimage,
   type PublicDataUpdateRequest,
@@ -25,7 +23,6 @@ import {
   buildNullifierNonExistentReadRequestHints,
   buildPublicDataHint,
   buildPublicDataHints,
-  buildPublicDataReadRequestHints,
   buildSiloedNullifierReadRequestHints,
 } from '@aztec/circuits.js';
 import { makeTuple } from '@aztec/foundation/array';
@@ -91,14 +88,6 @@ export class HintsBuilder {
     return buildPublicDataHint(this, slot);
   }
 
-  getPublicDataReadRequestHints(
-    publicDataReads: Tuple<PublicDataRead, typeof MAX_PUBLIC_DATA_READS_PER_TX>,
-    publicDataUpdateRequests: Tuple<PublicDataUpdateRequest, typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX>,
-    publicDataHints: Tuple<PublicDataHint, typeof MAX_PUBLIC_DATA_HINTS>,
-  ) {
-    return buildPublicDataReadRequestHints(publicDataReads, publicDataUpdateRequests, publicDataHints);
-  }
-
   async getNullifierMembershipWitness(nullifier: Fr) {
     const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
     if (index === undefined) {

package/src/public/tail_phase_manager.ts

@@ -112,12 +112,6 @@ export class TailPhaseManager extends AbstractPhaseManager {
       pendingPublicDataWrites,
     );
 
-    const publicDataReadRequestHints = this.hintsBuilder.getPublicDataReadRequestHints(
-      validationRequests.publicDataReads,
-      pendingPublicDataWrites,
-      publicDataHints,
-    );
-
     const currentState = await this.db.getStateReference();
 
     return new PublicKernelTailCircuitPrivateInputs(
@@ -127,7 +121,6 @@ export class TailPhaseManager extends AbstractPhaseManager {
       nullifierNonExistentReadRequestHints,
       l1ToL2MsgReadRequestHints,
       publicDataHints,
-      publicDataReadRequestHints,
       currentState.partial,
     );
   }