@aztec/simulator 0.53.0 → 0.54.0

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,102 +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],
-    [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)],
+    [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.
  */
@@ -182,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,
@@ -40,13 +53,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,
@@ -92,6 +111,7 @@ export enum OperandType {
   UINT32,
   UINT64,
   UINT128,
+  FF,
 }
 
 type OperandNativeType = number | bigint;
@@ -104,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;
@@ -156,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/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,
     );
   }