@aztec/simulator 0.86.0-starknet.1 → 0.87.0-nightly.20250521

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.86.0-starknet.1",
+  "version": "0.87.0-nightly.20250521",
   "type": "module",
   "exports": {
     "./server": "./dest/server.js",
@@ -58,34 +58,34 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.86.0-starknet.1",
-    "@aztec/foundation": "0.86.0-starknet.1",
-    "@aztec/noir-acvm_js": "0.86.0-starknet.1",
-    "@aztec/noir-noirc_abi": "0.86.0-starknet.1",
-    "@aztec/noir-protocol-circuits-types": "0.86.0-starknet.1",
-    "@aztec/noir-types": "0.86.0-starknet.1",
-    "@aztec/protocol-contracts": "0.86.0-starknet.1",
-    "@aztec/stdlib": "0.86.0-starknet.1",
-    "@aztec/telemetry-client": "0.86.0-starknet.1",
-    "@aztec/world-state": "0.86.0-starknet.1",
+    "@aztec/constants": "0.87.0-nightly.20250521",
+    "@aztec/foundation": "0.87.0-nightly.20250521",
+    "@aztec/noir-acvm_js": "0.87.0-nightly.20250521",
+    "@aztec/noir-noirc_abi": "0.87.0-nightly.20250521",
+    "@aztec/noir-protocol-circuits-types": "0.87.0-nightly.20250521",
+    "@aztec/noir-types": "0.87.0-nightly.20250521",
+    "@aztec/protocol-contracts": "0.87.0-nightly.20250521",
+    "@aztec/stdlib": "0.87.0-nightly.20250521",
+    "@aztec/telemetry-client": "0.87.0-nightly.20250521",
+    "@aztec/world-state": "0.87.0-nightly.20250521",
     "lodash.clonedeep": "^4.5.0",
     "lodash.merge": "^4.6.2",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/kv-store": "0.86.0-starknet.1",
-    "@aztec/merkle-tree": "0.86.0-starknet.1",
-    "@aztec/noir-contracts.js": "0.86.0-starknet.1",
-    "@aztec/noir-test-contracts.js": "0.86.0-starknet.1",
+    "@aztec/kv-store": "0.87.0-nightly.20250521",
+    "@aztec/merkle-tree": "0.87.0-nightly.20250521",
+    "@aztec/noir-contracts.js": "0.87.0-nightly.20250521",
+    "@aztec/noir-test-contracts.js": "0.87.0-nightly.20250521",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/lodash.clonedeep": "^4.5.7",
     "@types/lodash.merge": "^4.6.9",
-    "@types/node": "^18.7.23",
+    "@types/node": "^22.15.17",
     "jest": "^29.5.0",
     "jest-mock-extended": "^3.0.4",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4",
+    "typescript": "^5.3.3",
     "viem": "2.23.7"
   },
   "files": [
@@ -95,6 +95,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/private/acvm/acvm.ts

@@ -104,7 +104,7 @@ export function extractCallStack(
 
   try {
     return resolveOpcodeLocations(callStack, debug.debugSymbols, debug.files, brilligFunctionId);
-  } catch (err) {
+  } catch {
     return callStack;
   }
 }

package/src/private/acvm/oracle/oracle.ts

@@ -1,13 +1,18 @@
 import { Fr, Point } from '@aztec/foundation/fields';
 import { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { ContractClassLog, LogWithTxData } from '@aztec/stdlib/logs';
+import { ContractClassLog, ContractClassLogFields, LogWithTxData } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { ACVMField } from '../acvm_types.js';
 import { fromBoundedVec, fromUintArray, fromUintBoundedVec } from '../deserialize.js';
-import { bufferToBoundedVec, toACVMField, toACVMFieldSingleOrArray } from '../serialize.js';
+import {
+  arrayOfArraysToBoundedVecOfArrays,
+  bufferToBoundedVec,
+  toACVMField,
+  toACVMFieldSingleOrArray,
+} from '../serialize.js';
 import type { TypedOracle } from './typed_oracle.js';
 
 /**
@@ -169,8 +174,9 @@ export class Oracle {
     [limit]: ACVMField[],
     [offset]: ACVMField[],
     [status]: ACVMField[],
-    [returnSize]: ACVMField[],
-  ): Promise<ACVMField[][]> {
+    [maxNotes]: ACVMField[],
+    [packedRetrievedNoteLength]: ACVMField[],
+  ): Promise<(ACVMField | ACVMField[])[]> {
     const noteDatas = await this.typedOracle.getNotes(
       Fr.fromString(storageSlot),
       +numSelects,
@@ -188,32 +194,30 @@ export class Oracle {
       +status,
     );
 
-    const noteLength = noteDatas?.[0]?.note.items.length ?? 0;
-    if (!noteDatas.every(({ note }) => noteLength === note.items.length)) {
-      throw new Error('Notes should all be the same length.');
+    if (noteDatas.length > 0) {
+      const noteLength = noteDatas[0].note.items.length;
+      if (!noteDatas.every(({ note }) => noteLength === note.items.length)) {
+        throw new Error('Notes should all be the same length.');
+      }
     }
 
-    const contractAddress = noteDatas[0]?.contractAddress ?? Fr.ZERO;
-
-    // Values indicates whether the note is settled or transient.
-    const noteTypes = {
-      isSettled: new Fr(0),
-      isTransient: new Fr(1),
-    };
-    const flattenData = noteDatas.flatMap(({ nonce, note, index }) => [
-      nonce,
-      index === undefined ? noteTypes.isTransient : noteTypes.isSettled,
-      ...note.items,
-    ]);
-
-    const returnFieldSize = +returnSize;
-    const returnData = [noteDatas.length, contractAddress, ...flattenData].map(v => toACVMField(v));
-    if (returnData.length > returnFieldSize) {
-      throw new Error(`Return data size too big. Maximum ${returnFieldSize} fields. Got ${flattenData.length}.`);
-    }
+    // The expected return type is a BoundedVec<[Field; packedRetrievedNoteLength], maxNotes> where each
+    // array is structured as [contract_address, nonce, nonzero_note_hash_counter, ...packed_note].
 
-    const paddedZeros = Array(returnFieldSize - returnData.length).fill(toACVMField(0));
-    return [returnData.concat(paddedZeros)];
+    const returnDataAsArrayOfArrays = noteDatas.map(({ contractAddress, nonce, index, note }) => {
+      // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
+      const noteIsTransient = index === undefined;
+      const nonzeroNoteHashCounter = noteIsTransient ? true : false;
+      // If you change the array on the next line you have to change the `unpack_retrieved_note` function in
+      // `aztec/src/note/retrieved_note.nr`
+      return [contractAddress, nonce, nonzeroNoteHashCounter, ...note.items];
+    });
+
+    // Now we convert each sub-array to an array of ACVMField
+    const returnDataAsArrayOfACVMFieldArrays = returnDataAsArrayOfArrays.map(subArray => subArray.map(toACVMField));
+
+    // At last we convert the array of arrays to a bounded vec of arrays
+    return arrayOfArraysToBoundedVecOfArrays(returnDataAsArrayOfACVMFieldArrays, +maxNotes, +packedRetrievedNoteLength);
   }
 
   notifyCreatedNote(
@@ -288,10 +292,11 @@ export class Oracle {
   notifyCreatedContractClassLog(
     [contractAddress]: ACVMField[],
     message: ACVMField[],
+    [length]: ACVMField[],
     [counter]: ACVMField[],
   ): Promise<ACVMField[]> {
-    const logPayload = message.map(Fr.fromString);
-    const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logPayload);
+    const logFields = new ContractClassLogFields(message.map(Fr.fromString));
+    const log = new ContractClassLog(new AztecAddress(Fr.fromString(contractAddress)), logFields, +length);
 
     this.typedOracle.notifyCreatedContractClassLog(log, +counter);
     return Promise.resolve([]);
@@ -351,8 +356,10 @@ export class Oracle {
     return [];
   }
 
-  notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
-    this.typedOracle.notifySetMinRevertibleSideEffectCounter(Fr.fromString(minRevertibleSideEffectCounter).toNumber());
+  async notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]): Promise<ACVMField[]> {
+    await this.typedOracle.notifySetMinRevertibleSideEffectCounter(
+      Fr.fromString(minRevertibleSideEffectCounter).toNumber(),
+    );
     return Promise.resolve([]);
   }
 

package/src/private/acvm/oracle/typed_oracle.ts

@@ -198,7 +198,7 @@ export abstract class TypedOracle {
     return Promise.reject(new OracleMethodNotAvailableError('notifySetPublicTeardownFunctionCall'));
   }
 
-  notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): void {
+  notifySetMinRevertibleSideEffectCounter(_minRevertibleSideEffectCounter: number): Promise<void> {
     throw new OracleMethodNotAvailableError('notifySetMinRevertibleSideEffectCounter');
   }
 

package/src/private/acvm/serialize.ts

@@ -86,3 +86,38 @@ export function arrayToBoundedVec(bVecStorage: ACVMField[], maxLen: number): [AC
   const len = toACVMField(BigInt(bVecStorage.length));
   return [storage, len];
 }
+
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */
+export function arrayOfArraysToBoundedVecOfArrays(
+  bVecStorage: ACVMField[][],
+  maxLen: number,
+  nestedArrayLength: number,
+): [ACVMField[], ACVMField] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+
+  // Check that all nested arrays have length nestedArrayLength
+  if (!bVecStorage.every(nestedArray => nestedArray.length === nestedArrayLength)) {
+    throw new Error(
+      `Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`,
+    );
+  }
+
+  // Flatten the array of arrays
+  const flattenedStorage = bVecStorage.flat();
+
+  // Calculate and add padding
+  const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
+  const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(toACVMField(BigInt(0))));
+
+  // Return flattened array with padding and length
+  const len = toACVMField(BigInt(bVecStorage.length));
+  return [flattenedStorageWithPadding, len];
+}

package/src/private/index.ts

@@ -9,6 +9,9 @@ export { ExecutionNoteCache } from './execution_note_cache.js';
 export { extractPrivateCircuitPublicInputs, readCurrentClassId } from './private_execution.js';
 export { witnessMapToFields } from './acvm/deserialize.js';
 export { toACVMWitness } from './acvm/serialize.js';
+export { executePrivateFunction } from './private_execution.js';
+export { PrivateExecutionOracle } from './private_execution_oracle.js';
+export { UtilityExecutionOracle } from './utility_execution_oracle.js';
 export { extractCallStack } from './acvm/acvm.js';
 export { type NoteData, TypedOracle } from './acvm/oracle/typed_oracle.js';
 export { Oracle } from './acvm/oracle/oracle.js';

package/src/private/pick_notes.ts

@@ -113,19 +113,19 @@ const sortNotes = (a: Fr[], b: Fr[], sorts: Sort[], level = 0): number => {
   }
 
   const { selector, order } = sorts[level];
-  if (order === 0) {
+  if (order === (0 as SortOrder)) {
     return 0;
   }
 
   const aValue = selectPropertyFromPackedNoteContent(a, selector);
   const bValue = selectPropertyFromPackedNoteContent(b, selector);
 
-  const dir = order === 1 ? [-1, 1] : [1, -1];
+  const dir = order === (1 as SortOrder) ? [-1, 1] : [1, -1];
   return aValue.toBigInt() === bValue.toBigInt()
     ? sortNotes(a, b, sorts, level + 1)
     : aValue.toBigInt() > bValue.toBigInt()
-    ? dir[0]
-    : dir[1];
+      ? dir[0]
+      : dir[1];
 };
 
 /**

package/src/private/providers/acvm_native.ts

@@ -78,7 +78,7 @@ export async function executeNativeCircuit(
   try {
     // Check that the directory exists
     await fs.access(workingDirectory);
-  } catch (error) {
+  } catch {
     return { status: ACVM_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
@@ -138,7 +138,11 @@ export async function executeNativeCircuit(
 }
 
 export class NativeACVMSimulator implements SimulationProvider {
-  constructor(private workingDirectory: string, private pathToAcvm: string, private witnessFilename?: string) {}
+  constructor(
+    private workingDirectory: string,
+    private pathToAcvm: string,
+    private witnessFilename?: string,
+  ) {}
 
   async executeProtocolCircuit(
     input: ACVMWitness,

package/src/private/providers/simulation_provider.ts

@@ -60,7 +60,7 @@ export function enrichNoirError(artifact: NoirCompiledCircuit, originalError: Ex
         // If not, attach the payload to the original error
         enrichedError.decodedAssertionPayload = decodedPayload;
       }
-    } catch (_errorDecoding) {
+    } catch {
       // Ignore errors decoding the payload
     }
   }
@@ -82,7 +82,7 @@ export function enrichNoirError(artifact: NoirCompiledCircuit, originalError: Ex
         return `at ${errorLocation.locationText} (${errorLocation.filePath}:${errorLocation.line}:${errorLocation.column})`;
       }
     });
-  } catch (_errorResolving) {
+  } catch {
     // Ignore errors resolving the callstack
   }
 

package/src/private/simulator.ts

@@ -22,7 +22,10 @@ import { UtilityExecutionOracle } from './utility_execution_oracle.js';
 export class AcirSimulator {
   private log: Logger;
 
-  constructor(private executionDataProvider: ExecutionDataProvider, private simulationProvider: SimulationProvider) {
+  constructor(
+    private executionDataProvider: ExecutionDataProvider,
+    private simulationProvider: SimulationProvider,
+  ) {
     this.log = createLogger('simulator');
   }
 

package/src/public/avm/avm_contract_call_result.ts

@@ -25,7 +25,7 @@ export class AvmContractCallResult {
       this.gasLeft,
     )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
-      resultsStr += `, revertReason: ${this.revertReason}`;
+      resultsStr += `, revertReason: ${this.revertReason.message}`;
     }
     return resultsStr;
   }
@@ -60,7 +60,7 @@ export class AvmFinalizedCallResult {
       this.gasLeft,
     )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
-      resultsStr += `, revertReason: ${this.revertReason}`;
+      resultsStr += `, revertReason: ${this.revertReason.message}`;
     }
     return resultsStr;
   }

package/src/public/avm/avm_execution_environment.ts

@@ -15,9 +15,14 @@ export class AvmExecutionEnvironment {
     public readonly globals: GlobalVariables,
     public readonly isStaticCall: boolean,
     public readonly calldata: Fr[],
+    public readonly clientInitiatedSimulation: boolean = false,
   ) {}
 
-  private deriveEnvironmentForNestedCallInternal(targetAddress: AztecAddress, calldata: Fr[], isStaticCall: boolean) {
+  private deriveEnvironmentForNestedCallInternal(
+    targetAddress: AztecAddress,
+    calldata: Fr[],
+    isStaticCall: boolean,
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
       /*address=*/ targetAddress,
       /*sender=*/ this.address,
@@ -26,6 +31,7 @@ export class AvmExecutionEnvironment {
       this.globals,
       isStaticCall,
       calldata,
+      /*clientInitiatedSimulation=*/ this.clientInitiatedSimulation,
     );
   }
 

package/src/public/avm/avm_gas.ts

@@ -2,7 +2,6 @@ import * as c from '@aztec/constants';
 
 import { TypeTag } from './avm_memory_types.js';
 import { InstructionExecutionError } from './errors.js';
-import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
 import { Opcode } from './serialization/instruction_serialization.js';
 
 /** Gas counters in L1, L2, and DA. */
@@ -136,7 +135,6 @@ const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.RETURN, makeCost(c.AVM_RETURN_DYN_L2_GAS, 0)],
   [Opcode.REVERT_8, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
   [Opcode.REVERT_16, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
-  [Opcode.DEBUGLOG, makeCost(c.AVM_DEBUGLOG_DYN_L2_GAS, 0)],
   [Opcode.TORADIXBE, makeCost(c.AVM_TORADIXBE_DYN_L2_GAS, 0)],
 ]);
 
@@ -149,24 +147,6 @@ export function getDynamicGasCost(opcode: Opcode): Gas {
   return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode)! : makeCost(0, 0);
 }
 
-/** Returns the gas cost associated with the memory operations performed. */
-export function getMemoryGasCost(args: { reads?: number; writes?: number; indirect?: number }) {
-  const { reads, writes, indirect } = args;
-  const indirectCount = Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
-  const l2MemoryGasCost =
-    (reads ?? 0) * GAS_COST_CONSTANTS.MEMORY_READ +
-    (writes ?? 0) * GAS_COST_CONSTANTS.MEMORY_WRITE +
-    indirectCount * GAS_COST_CONSTANTS.MEMORY_INDIRECT_READ_PENALTY;
-  return makeGas({ l2Gas: l2MemoryGasCost });
-}
-
-/** Constants used in base cost calculations. */
-export const GAS_COST_CONSTANTS = {
-  MEMORY_READ: 10,
-  MEMORY_INDIRECT_READ_PENALTY: 10,
-  MEMORY_WRITE: 100,
-};
-
 /** Returns gas cost for an operation on a given type tag based on the base cost per byte. */
 export function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas) {
   return mulGas(baseCost, getGasCostMultiplierFromTypeTag(tag));

package/src/public/avm/avm_simulator.ts

@@ -79,6 +79,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
     isStaticCall: boolean,
     calldata: Fr[],
     allocatedGas: Gas,
+    clientInitiatedSimulation: boolean = false,
   ) {
     const avmExecutionEnv = new AvmExecutionEnvironment(
       address,
@@ -88,6 +89,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
       globals,
       isStaticCall,
       calldata,
+      clientInitiatedSimulation,
     );
 
     const avmMachineState = new AvmMachineState(allocatedGas);
@@ -108,7 +110,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
         throw err;
       }
       return await this.handleFailureToRetrieveBytecode(
-        `Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err}. Reverting...`,
+        `Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err.message}. Reverting...`,
       );
     }
 

package/src/public/avm/fixtures/initializers.ts

@@ -71,6 +71,7 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
     overrides?.calldata ?? [],
+    overrides?.clientInitiatedSimulation ?? true, // default to true for testing even though internal default is false
   );
 }
 

package/src/public/avm/opcodes/accrued_substate.ts

@@ -29,9 +29,10 @@ export class NoteHashExists extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
     const operands = [this.noteHashOffset, this.leafIndexOffset, this.existsOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [noteHashOffset, leafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, noteHashOffset, leafIndexOffset);
 
@@ -50,16 +51,20 @@ export class EmitNoteHash extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
-  constructor(private indirect: number, private noteHashOffset: number) {
+  constructor(
+    private indirect: number,
+    private noteHashOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.noteHashOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [noteHashOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, noteHashOffset);
 
@@ -95,10 +100,11 @@ export class NullifierExists extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.nullifierOffset, this.addressOffset, this.existsOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [nullifierOffset, addressOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, nullifierOffset, addressOffset);
 
@@ -116,7 +122,10 @@ export class EmitNullifier extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16];
 
-  constructor(private indirect: number, private nullifierOffset: number) {
+  constructor(
+    private indirect: number,
+    private nullifierOffset: number,
+  ) {
     super();
   }
 
@@ -126,10 +135,11 @@ export class EmitNullifier extends Instruction {
     }
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.nullifierOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [nullifierOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, nullifierOffset);
 
@@ -172,10 +182,11 @@ export class L1ToL2MessageExists extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.msgHashOffset, this.msgLeafIndexOffset, this.existsOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [msgHashOffset, msgLeafIndexOffset, existsOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, msgHashOffset, msgLeafIndexOffset);
 
@@ -193,7 +204,11 @@ export class EmitUnencryptedLog extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
-  constructor(private indirect: number, private logOffset: number, private logSizeOffset: number) {
+  constructor(
+    private indirect: number,
+    private logOffset: number,
+    private logSizeOffset: number,
+  ) {
     super();
   }
 
@@ -203,9 +218,9 @@ export class EmitUnencryptedLog extends Instruction {
     }
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
 
     const operands = [this.logOffset, this.logSizeOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [logOffset, logSizeOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.UINT32, logSizeOffset);
     const logSize = memory.get(logSizeOffset).toNumber();
@@ -225,7 +240,11 @@ export class SendL2ToL1Message extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
 
-  constructor(private indirect: number, private recipientOffset: number, private contentOffset: number) {
+  constructor(
+    private indirect: number,
+    private recipientOffset: number,
+    private contentOffset: number,
+  ) {
     super();
   }
 
@@ -235,10 +254,11 @@ export class SendL2ToL1Message extends Instruction {
     }
 
     const memory = context.machineState.memory;
+    const addressing = Addressing.fromWire(this.indirect);
+
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.recipientOffset, this.contentOffset];
-    const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
     memory.checkTags(TypeTag.FIELD, recipientOffset, contentOffset);
 

package/src/public/avm/opcodes/addressing_mode.ts

@@ -1,4 +1,6 @@
-import { strict as assert } from 'assert';
+import { AVM_MAX_OPERANDS } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import type { Tuple } from '@aztec/foundation/serialize';
 
 import { TaggedMemory, type TaggedMemoryInterface } from '../avm_memory_types.js';
 import { RelativeAddressOutOfRangeError } from '../errors.js';
@@ -13,21 +15,28 @@ export enum AddressingMode {
 /** A class to represent the addressing mode of an instruction. */
 export class Addressing {
   public constructor(
-    /** The addressing mode for each operand. The length of this array is the number of operands of the instruction. */
-    private readonly modePerOperand: AddressingMode[],
+    /** The addressing mode for each possible operand. */
+    private readonly modePerOperand: Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>,
   ) {}
 
-  // TODO(facundo): 8 for backwards compatibility.
-  public static fromWire(wireModes: number, numOperands: number = 8): Addressing {
-    // The modes are stored in the wire format as a byte, with each bit representing the mode for an operand.
-    // The least significant bit represents the zeroth operand, and the most significant bit represents the last operand.
-    const modes = new Array<AddressingMode>(numOperands);
-    for (let i = 0; i < numOperands; i++) {
+  public static fromModes(modes: AddressingMode[]): Addressing {
+    if (modes.length > AVM_MAX_OPERANDS) {
+      throw new Error('Too many operands for addressing mode');
+    }
+    return new Addressing(padArrayEnd(modes, AddressingMode.DIRECT, AVM_MAX_OPERANDS));
+  }
+
+  public static fromWire(wireModes: number): Addressing {
+    // The modes are stored in the wire format as one or two bytes, with each two bits representing the modes for an operand.
+    // Even bits are indirect, odd bits are relative.
+    const modes = new Array<AddressingMode>(AVM_MAX_OPERANDS);
+    for (let i = 0; i < AVM_MAX_OPERANDS; i++) {
       modes[i] =
-        (((wireModes >> i) & 1) * AddressingMode.INDIRECT) |
-        (((wireModes >> (i + numOperands)) & 1) * AddressingMode.RELATIVE);
+        (((wireModes >> (i * 2)) & 1) * AddressingMode.INDIRECT) |
+        (((wireModes >> (i * 2 + 1)) & 1) * AddressingMode.RELATIVE);
     }
-    return new Addressing(modes);
+    // Casting the array to tuple since it should be more performant than using makeTuple
+    return new Addressing(modes as Tuple<AddressingMode, typeof AVM_MAX_OPERANDS>);
   }
 
   public toWire(): number {
@@ -36,20 +45,15 @@ export class Addressing {
     let wire: number = 0;
     for (let i = 0; i < this.modePerOperand.length; i++) {
       if (this.modePerOperand[i] & AddressingMode.INDIRECT) {
-        wire |= 1 << i;
+        wire |= 1 << (i * 2);
       }
       if (this.modePerOperand[i] & AddressingMode.RELATIVE) {
-        wire |= 1 << (this.modePerOperand.length + i);
+        wire |= 1 << (i * 2 + 1);
       }
     }
     return wire;
   }
 
-  /** Returns how many operands use the given addressing mode. */
-  public count(mode: AddressingMode): number {
-    return this.modePerOperand.filter(m => (m & mode) !== 0).length;
-  }
-
   /**
    * Resolves the offsets using the addressing mode.
    * @param offsets The offsets to resolve.
@@ -57,7 +61,6 @@ export class Addressing {
    * @returns The resolved offsets. The length of the returned array is the same as the length of the input array.
    */
   public resolve(offsets: number[], mem: TaggedMemoryInterface): number[] {
-    assert(offsets.length <= this.modePerOperand.length);
     const resolved = new Array(offsets.length);
 
     let didRelativeOnce = false;