@aztec/simulator 0.47.1 → 0.49.2

package/src/client/execution_note_cache.ts

@@ -1,12 +1,13 @@
-import { siloNullifier } from '@aztec/circuits.js/hash';
+import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr } from '@aztec/foundation/fields';
+import { type Fr } from '@aztec/foundation/fields';
 
 import { type NoteData } from '../acvm/index.js';
 
-export interface PendingNote {
+interface PendingNote {
   note: NoteData;
   counter: number;
+  noteHashForConsumption: Fr;
 }
 
 /**
@@ -15,9 +16,13 @@ export interface PendingNote {
 export class ExecutionNoteCache {
   /**
    * New notes created in this transaction.
+   * They are pushed to this array in the same order as they are emitted.
+   */
+  private notes: PendingNote[] = [];
+  /**
    * This mapping maps from a contract address to the notes in the contract.
    */
-  private newNotes: Map<bigint, PendingNote[]> = new Map();
+  private noteMap: Map<bigint, PendingNote[]> = new Map();
 
   /**
    * The list of nullifiers created in this transaction.
@@ -25,43 +30,81 @@ export class ExecutionNoteCache {
    * The note which is nullified might be new or not (i.e., was generated in a previous transaction).
    * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
    */
-  private nullifiers: Map<bigint, Set<bigint>> = new Map();
+  private nullifierMap: Map<bigint, Set<bigint>> = new Map();
+
+  private minRevertibleSideEffectCounter = 0;
+
+  constructor(private readonly txHash: Fr) {}
+
+  public setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
+    if (this.minRevertibleSideEffectCounter && this.minRevertibleSideEffectCounter !== minRevertibleSideEffectCounter) {
+      throw new Error(
+        `Cannot override minRevertibleSideEffectCounter. Current value: ${minRevertibleSideEffectCounter}. Previous value: ${this.minRevertibleSideEffectCounter}`,
+      );
+    }
+
+    this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
+
+    // The existing pending notes are all non-revertible.
+    // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
+    // Their indexes in the tx are known at this point and won't change. So we can assign a nonce to each one of them.
+    // The nonces will be used to create the "complete" nullifier.
+    const updatedNotes = this.notes.map(({ note, counter }, i) => {
+      const nonce = computeNoteHashNonce(this.txHash, i);
+      const uniqueNoteHash = computeUniqueNoteHash(nonce, note.noteHash);
+      return {
+        counter,
+        note: { ...note, nonce },
+        noteHashForConsumption: siloNoteHash(note.contractAddress, uniqueNoteHash),
+      };
+    });
+    // Rebuild the data.
+    this.notes = [];
+    this.noteMap = new Map();
+    updatedNotes.forEach(n => this.#addNote(n));
+  }
 
   /**
    * Add a new note to cache.
    * @param note - New note created during execution.
    */
   public addNewNote(note: NoteData, counter: number) {
-    const notes = this.newNotes.get(note.contractAddress.toBigInt()) ?? [];
-    notes.push({ note, counter });
-    this.newNotes.set(note.contractAddress.toBigInt(), notes);
+    const previousNote = this.notes[this.notes.length - 1];
+    if (previousNote && previousNote.counter >= counter) {
+      throw new Error(
+        `Note hash counters must be strictly increasing. Current counter: ${counter}. Previous counter: ${previousNote.counter}.`,
+      );
+    }
+
+    this.#addNote({ note, counter, noteHashForConsumption: note.noteHash });
   }
 
   /**
    * Add a nullifier to cache. It could be for a db note or a new note created during execution.
    * @param contractAddress - Contract address of the note.
-   * @param storageSlot - Storage slot of the note.
    * @param innerNullifier - Inner nullifier of the note.
-   * @param innerNoteHash - Inner note hash of the note. If this value equals 0, it means the
-   * note being nullified is from a previous transaction (and thus not a new note).
+   * @param noteHash - A hash of the note. If this value equals 0, it means the note being nullified is from a previous
+   * transaction (and thus not a new note).
    */
-  public nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, innerNoteHash: Fr) {
+  public nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, noteHash: Fr) {
     const siloedNullifier = siloNullifier(contractAddress, innerNullifier);
     const nullifiers = this.getNullifiers(contractAddress);
     nullifiers.add(siloedNullifier.value);
-    this.nullifiers.set(contractAddress.toBigInt(), nullifiers);
+    this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
 
     let nullifiedNoteHashCounter: number | undefined = undefined;
-    // Find and remove the matching new note and log(s) if the emitted innerNoteHash is not empty.
-    if (!innerNoteHash.equals(Fr.ZERO)) {
-      const notes = this.newNotes.get(contractAddress.toBigInt()) ?? [];
-      const noteIndexToRemove = notes.findIndex(n => n.note.innerNoteHash.equals(innerNoteHash));
+    // Find and remove the matching new note and log(s) if the emitted noteHash is not empty.
+    if (!noteHash.isEmpty()) {
+      const notesInContract = this.noteMap.get(contractAddress.toBigInt()) ?? [];
+      const noteIndexToRemove = notesInContract.findIndex(n => n.noteHashForConsumption.equals(noteHash));
       if (noteIndexToRemove === -1) {
         throw new Error('Attempt to remove a pending note that does not exist.');
       }
-      const note = notes.splice(noteIndexToRemove, 1)[0];
+
+      const note = notesInContract.splice(noteIndexToRemove, 1)[0];
       nullifiedNoteHashCounter = note.counter;
-      this.newNotes.set(contractAddress.toBigInt(), notes);
+      this.noteMap.set(contractAddress.toBigInt(), notesInContract);
+      this.notes = this.notes.filter(n => n.counter !== note.counter);
     }
     return nullifiedNoteHashCounter;
   }
@@ -73,7 +116,7 @@ export class ExecutionNoteCache {
    * @param storageSlot - Storage slot of the notes.
    **/
   public getNotes(contractAddress: AztecAddress, storageSlot: Fr) {
-    const notes = this.newNotes.get(contractAddress.toBigInt()) ?? [];
+    const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
     return notes.filter(n => n.note.storageSlot.equals(storageSlot)).map(n => n.note);
   }
 
@@ -81,11 +124,11 @@ export class ExecutionNoteCache {
    * Check if a note exists in the newNotes array.
    * @param contractAddress - Contract address of the note.
    * @param storageSlot - Storage slot of the note.
-   * @param innerNoteHash - Inner note hash of the note.
+   * @param noteHash - A hash of the note.
    **/
-  public checkNoteExists(contractAddress: AztecAddress, innerNoteHash: Fr) {
-    const notes = this.newNotes.get(contractAddress.toBigInt()) ?? [];
-    return notes.some(n => n.note.innerNoteHash.equals(innerNoteHash));
+  public checkNoteExists(contractAddress: AztecAddress, noteHash: Fr) {
+    const notes = this.noteMap.get(contractAddress.toBigInt()) ?? [];
+    return notes.some(n => n.note.noteHash.equals(noteHash));
   }
 
   /**
@@ -93,6 +136,14 @@ export class ExecutionNoteCache {
    * @param contractAddress - Address of the contract.
    */
   public getNullifiers(contractAddress: AztecAddress): Set<bigint> {
-    return this.nullifiers.get(contractAddress.toBigInt()) ?? new Set();
+    return this.nullifierMap.get(contractAddress.toBigInt()) ?? new Set();
+  }
+
+  #addNote(note: PendingNote) {
+    this.notes.push(note);
+
+    const notes = this.noteMap.get(note.note.contractAddress.toBigInt()) ?? [];
+    notes.push(note);
+    this.noteMap.set(note.note.contractAddress.toBigInt(), notes);
   }
 }

package/src/client/execution_result.ts

@@ -67,7 +67,7 @@ export interface ExecutionResult {
   /** The notes created in the executed function. */
   newNotes: NoteAndSlot[];
   /** Mapping of note hash counter to the counter of its nullifier. */
-  nullifiedNoteHashCounters: Map<number, number>;
+  noteHashNullifierCounterMap: Map<number, number>;
   /** The raw return values of the executed function. */
   returnValues: Fr[];
   /** The nested executions. */
@@ -99,9 +99,12 @@ export function collectNoteHashLeafIndexMap(execResult: ExecutionResult, accum:
   return accum;
 }
 
-export function collectNullifiedNoteHashCounters(execResult: ExecutionResult, accum: Map<number, number> = new Map()) {
-  execResult.nullifiedNoteHashCounters.forEach((value, key) => accum.set(key, value));
-  execResult.nestedExecutions.forEach(nested => collectNullifiedNoteHashCounters(nested, accum));
+export function collectNoteHashNullifierCounterMap(
+  execResult: ExecutionResult,
+  accum: Map<number, number> = new Map(),
+) {
+  execResult.noteHashNullifierCounterMap.forEach((value, key) => accum.set(key, value));
+  execResult.nestedExecutions.forEach(nested => collectNoteHashNullifierCounterMap(nested, accum));
   return accum;
 }
 
@@ -112,11 +115,20 @@ export function collectNullifiedNoteHashCounters(execResult: ExecutionResult, ac
  */
 function collectNoteEncryptedLogs(
   execResult: ExecutionResult,
-  nullifiedNoteHashCounters: Map<number, number>,
+  noteHashNullifierCounterMap: Map<number, number>,
+  minRevertibleSideEffectCounter: number,
 ): CountedLog<EncryptedL2NoteLog>[] {
   return [
-    execResult.noteEncryptedLogs.filter(noteLog => !nullifiedNoteHashCounters.has(noteLog.noteHashCounter)),
-    ...execResult.nestedExecutions.flatMap(res => collectNoteEncryptedLogs(res, nullifiedNoteHashCounters)),
+    execResult.noteEncryptedLogs.filter(noteLog => {
+      const nullifierCounter = noteHashNullifierCounterMap.get(noteLog.noteHashCounter);
+      return (
+        nullifierCounter === undefined ||
+        (noteLog.noteHashCounter < minRevertibleSideEffectCounter && nullifierCounter >= minRevertibleSideEffectCounter)
+      );
+    }),
+    ...execResult.nestedExecutions.flatMap(res =>
+      collectNoteEncryptedLogs(res, noteHashNullifierCounterMap, minRevertibleSideEffectCounter),
+    ),
   ].flat();
 }
 
@@ -126,8 +138,9 @@ function collectNoteEncryptedLogs(
  * @returns All encrypted logs.
  */
 export function collectSortedNoteEncryptedLogs(execResult: ExecutionResult): EncryptedNoteFunctionL2Logs {
-  const nullifiedNoteHashCounters = collectNullifiedNoteHashCounters(execResult);
-  const allLogs = collectNoteEncryptedLogs(execResult, nullifiedNoteHashCounters);
+  const noteHashNullifierCounterMap = collectNoteHashNullifierCounterMap(execResult);
+  const minRevertibleSideEffectCounter = getFinalMinRevertibleSideEffectCounter(execResult);
+  const allLogs = collectNoteEncryptedLogs(execResult, noteHashNullifierCounterMap, minRevertibleSideEffectCounter);
   const sortedLogs = sortByCounter(allLogs);
   return new EncryptedNoteFunctionL2Logs(sortedLogs.map(l => l.log));
 }
@@ -206,3 +219,10 @@ export function collectPublicTeardownFunctionCall(execResult: ExecutionResult):
 
   return PublicExecutionRequest.empty();
 }
+
+export function getFinalMinRevertibleSideEffectCounter(execResult: ExecutionResult): number {
+  return execResult.nestedExecutions.reduce((counter, exec) => {
+    const nestedCounter = getFinalMinRevertibleSideEffectCounter(exec);
+    return nestedCounter ? nestedCounter : counter;
+  }, execResult.callStackItem.publicInputs.minRevertibleSideEffectCounter.toNumber());
+}

package/src/client/private_execution.ts

@@ -68,7 +68,7 @@ export async function executePrivateFunction(
 
   const noteHashLeafIndexMap = context.getNoteHashLeafIndexMap();
   const newNotes = context.getNewNotes();
-  const nullifiedNoteHashCounters = context.getNullifiedNoteHashCounters();
+  const noteHashNullifierCounterMap = context.getNoteHashNullifierCounterMap();
   const nestedExecutions = context.getNestedExecutions();
   const enqueuedPublicFunctionCalls = context.getEnqueuedPublicFunctionCalls();
   const publicTeardownFunctionCall = context.getPublicTeardownFunctionCall();
@@ -82,7 +82,7 @@ export async function executePrivateFunction(
     returnValues: rawReturnValues,
     noteHashLeafIndexMap,
     newNotes,
-    nullifiedNoteHashCounters,
+    noteHashNullifierCounterMap,
     vk: Buffer.from(artifact.verificationKey!, 'hex'),
     nestedExecutions,
     enqueuedPublicFunctionCalls,

package/src/client/simulator.ts

@@ -38,6 +38,7 @@ export class AcirSimulator {
    * @param entryPointArtifact - The artifact of the entry point function.
    * @param contractAddress - The address of the contract (should match request.origin)
    * @param msgSender - The address calling the function. This can be replaced to simulate a call from another contract or a specific account.
+   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
    * @returns The result of the execution.
    */
   public async run(
@@ -45,6 +46,7 @@ export class AcirSimulator {
     entryPointArtifact: FunctionArtifact,
     contractAddress: AztecAddress,
     msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE),
+    scopes?: AztecAddress[],
   ): Promise<ExecutionResult> {
     if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
@@ -68,6 +70,9 @@ export class AcirSimulator {
       false,
       entryPointArtifact.isStatic,
     );
+
+    const txHash = request.toTxRequest().hash();
+
     const context = new ClientExecutionContext(
       contractAddress,
       request.firstCallArgsHash,
@@ -76,10 +81,12 @@ export class AcirSimulator {
       header,
       request.authWitnesses,
       PackedValuesCache.create(request.argsOfCalls),
-      new ExecutionNoteCache(),
+      new ExecutionNoteCache(txHash),
       this.db,
       this.node,
       startSideEffectCounter,
+      undefined,
+      scopes,
     );
 
     try {
@@ -100,18 +107,19 @@ export class AcirSimulator {
    * @param request - The transaction request.
    * @param entryPointArtifact - The artifact of the entry point function.
    * @param contractAddress - The address of the contract.
-   * @param aztecNode - The AztecNode instance.
+   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
    */
   public async runUnconstrained(
     request: FunctionCall,
     entryPointArtifact: FunctionArtifact,
     contractAddress: AztecAddress,
+    scopes?: AztecAddress[],
   ) {
     if (entryPointArtifact.functionType !== FunctionType.UNCONSTRAINED) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as unconstrained`);
     }
 
-    const context = new ViewDataOracle(contractAddress, [], this.db, this.node);
+    const context = new ViewDataOracle(contractAddress, [], this.db, this.node, undefined, scopes);
 
     try {
       return await executeUnconstrainedFunction(
@@ -188,14 +196,15 @@ export class AcirSimulator {
       returnTypes: artifact.returnTypes,
     };
 
-    const [innerNoteHash, uniqueNoteHash, siloedNoteHash, innerNullifier] = (await this.runUnconstrained(
+    const [noteHash, uniqueNoteHash, siloedNoteHash, innerNullifier] = (await this.runUnconstrained(
       execRequest,
       artifact,
       contractAddress,
+      // We can omit scopes here, because "compute_note_hash_and_optionally_a_nullifier" does not need access to any notes.
     )) as bigint[];
 
     return {
-      innerNoteHash: new Fr(innerNoteHash),
+      noteHash: new Fr(noteHash),
       uniqueNoteHash: new Fr(uniqueNoteHash),
       siloedNoteHash: new Fr(siloedNoteHash),
       innerNullifier: new Fr(innerNullifier),
@@ -203,20 +212,15 @@ export class AcirSimulator {
   }
 
   /**
-   * Computes the inner note hash of a note, which contains storage slot and the custom note hash.
+   * Computes a hash of the note.
    * @param contractAddress - The address of the contract.
    * @param storageSlot - The storage slot.
    * @param noteTypeId - The note type identifier.
    * @param note - The note.
    * @returns The note hash.
    */
-  public async computeInnerNoteHash(
-    contractAddress: AztecAddress,
-    storageSlot: Fr,
-    noteTypeId: NoteSelector,
-    note: Note,
-  ) {
-    const { innerNoteHash } = await this.computeNoteHashAndOptionallyANullifier(
+  public async computeNoteHash(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: NoteSelector, note: Note) {
+    const { noteHash } = await this.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       Fr.ZERO,
       storageSlot,
@@ -224,6 +228,6 @@ export class AcirSimulator {
       false,
       note,
     );
-    return innerNoteHash;
+    return noteHash;
   }
 }

package/src/client/test_utils.ts

@@ -0,0 +1,30 @@
+import { Fq, Fr, GeneratorIndex, Point } from '@aztec/circuits.js';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+import { pedersenCommit } from '@aztec/foundation/crypto';
+
+// Copied over from `noir-projects/aztec-nr/aztec/src/generators.nr`
+const G_SLOT = new Point(
+  new Fr(0x041223147b680850dc82e8a55a952d4df20256fe0593d949a9541ca00f0abf15n),
+  new Fr(0x0a8c72e60d0e60f5d804549d48f3044d06140b98ed717a9b532af630c1530791n),
+  false,
+);
+
+/**
+ * Computes a note hiding point as is done by the default implementation injected by macros.
+ * @param storageSlot - The slot to which the note was inserted.
+ * @param noteContent - The note content (e.g. note.items).
+ * @returns A note hash.
+ */
+export function computeNoteHash(storageSlot: Fr, noteContent: Fr[]): Fr {
+  // TODO(#7771): update this to do only 1 MSM call
+  const c = pedersenCommit(
+    noteContent.map(f => f.toBuffer()),
+    GeneratorIndex.NOTE_HIDING_POINT,
+  );
+  const noteHidingPointBeforeSlotting = new Point(new Fr(c[0]), new Fr(c[1]), false);
+
+  const grumpkin = new Grumpkin();
+  const slotPoint = grumpkin.mul(G_SLOT, new Fq(storageSlot.toBigInt()));
+  const noteHidingPoint = grumpkin.add(noteHidingPointBeforeSlotting, slotPoint);
+  return noteHidingPoint.x;
+}

package/src/client/view_data_oracle.ts

@@ -30,6 +30,7 @@ export class ViewDataOracle extends TypedOracle {
     protected readonly db: DBOracle,
     protected readonly aztecNode: AztecNode,
     protected log = createDebugLogger('aztec:simulator:client_view_context'),
+    protected readonly scopes?: AztecAddress[],
   ) {
     super();
   }
@@ -219,7 +220,7 @@ export class ViewDataOracle extends TypedOracle {
     offset: number,
     status: NoteStatus,
   ): Promise<NoteData[]> {
-    const dbNotes = await this.db.getNotes(this.contractAddress, storageSlot, status);
+    const dbNotes = await this.db.getNotes(this.contractAddress, storageSlot, status, this.scopes);
     return pickNotes<NoteData>(dbNotes, {
       selects: selectByIndexes.slice(0, numSelects).map((index, i) => ({
         selector: { index, offset: selectByOffsets[i], length: selectByLengths[i] },

package/src/index.ts

@@ -6,4 +6,3 @@ export * from './public/index.js';
 export * from './providers/index.js';
 export * from './mocks/index.js';
 export * from './stats/index.js';
-export * from './utils.js';

package/src/providers/acvm_native.ts

@@ -156,6 +156,6 @@ export class NativeACVMSimulator implements SimulationProvider {
       return result.witness;
     };
 
-    return await runInDirectory(this.workingDirectory, operation);
+    return await runInDirectory(this.workingDirectory, operation, false);
   }
 }

package/src/public/abstract_phase_manager.ts

@@ -14,7 +14,6 @@ import {
 import {
   type AvmExecutionHints,
   AztecAddress,
-  ClientIvcProof,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
@@ -361,7 +360,7 @@ export abstract class AbstractPhaseManager {
     const previousKernel = this.getPreviousKernelData(previousOutput, previousCircuit);
 
     // We take a deep copy (clone) of these inputs to be passed to the prover
-    const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, ClientIvcProof.empty(), callData);
+    const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
     switch (this.phase) {
       case PublicKernelType.SETUP:
         return [inputs.clone(), await this.publicKernel.publicKernelCircuitSetup(inputs), 'PublicKernelSetupArtifact'];

package/src/public/executor.ts

@@ -3,6 +3,7 @@ import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
 import { Fr, Gas, type GlobalVariables, type Header, type Nullifier, type TxContext } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import { AvmContext } from '../avm/avm_context.js';
 import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
@@ -12,18 +13,24 @@ import { HostStorage } from '../avm/journal/host_storage.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db_interfaces.js';
 import { type PublicExecutionResult } from './execution.js';
+import { ExecutorMetrics } from './executor_metrics.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
 
 /**
  * Handles execution of public functions.
  */
 export class PublicExecutor {
+  metrics: ExecutorMetrics;
+
   constructor(
     private readonly publicStorageDB: PublicStateDB,
     private readonly contractsDb: PublicContractsDB,
     private readonly commitmentsDb: CommitmentsDB,
     private readonly header: Header,
-  ) {}
+    client: TelemetryClient,
+  ) {
+    this.metrics = new ExecutorMetrics(client, 'PublicExecutor');
+  }
 
   static readonly log = createDebugLogger('aztec:simulator:public_executor');
 
@@ -102,6 +109,12 @@ export class PublicExecutor {
       fnName,
     );
 
+    if (publicExecutionResult.reverted) {
+      this.metrics.recordFunctionSimulationFailure();
+    } else {
+      this.metrics.recordFunctionSimulation(bytecode.length, timer.ms());
+    }
+
     return publicExecutionResult;
   }
 }

package/src/public/executor_metrics.ts

@@ -0,0 +1,48 @@
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export class ExecutorMetrics {
+  private fnCount: UpDownCounter;
+  private fnDuration: Histogram;
+  private bytecodeSize: Histogram;
+
+  constructor(client: TelemetryClient, name = 'PublicExecutor') {
+    const meter = client.getMeter(name);
+
+    this.fnCount = meter.createUpDownCounter(Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT, {
+      description: 'Number of functions executed',
+    });
+
+    this.fnDuration = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_DURATION, {
+      description: 'How long it takes to execute a function',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.bytecodeSize = meter.createHistogram(Metrics.PUBLIC_EXECUTION_SIMULATION_BYTECODE_SIZE, {
+      description: 'Size of the function bytecode',
+      unit: 'By',
+      valueType: ValueType.INT,
+    });
+  }
+
+  recordFunctionSimulation(bytecodeSize: number, durationMs: number) {
+    this.fnCount.add(1, {
+      [Attributes.OK]: true,
+    });
+    this.bytecodeSize.record(bytecodeSize);
+    this.fnDuration.record(Math.ceil(durationMs));
+  }
+
+  recordFunctionSimulationFailure() {
+    this.fnCount.add(1, {
+      [Attributes.OK]: false,
+    });
+  }
+}

package/src/public/fee_payment.ts

@@ -1,26 +1,24 @@
-import { GAS_TOKEN_ADDRESS } from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
+import { FEE_JUICE_ADDRESS } from '@aztec/circuits.js';
+import { computePublicDataTreeLeafSlot, deriveStorageSlotInMap } from '@aztec/circuits.js/hash';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
-import { GasTokenArtifact } from '@aztec/protocol-contracts/gas-token';
-
-import { computeSlotForMapping } from '../utils.js';
+import { FeeJuiceArtifact } from '@aztec/protocol-contracts/fee-juice';
 
 /**
- * Computes the storage slot within the gas token contract for the balance of the fee payer.
+ * Computes the storage slot within the Fee Juice contract for the balance of the fee payer.
  */
 export function computeFeePayerBalanceStorageSlot(feePayer: AztecAddress) {
-  return computeSlotForMapping(GasTokenArtifact.storageLayout.balances.slot, feePayer);
+  return deriveStorageSlotInMap(FeeJuiceArtifact.storageLayout.balances.slot, feePayer);
 }
 
 /**
- * Computes the leaf slot in the public data tree for the balance of the fee payer in the gas token.
+ * Computes the leaf slot in the public data tree for the balance of the fee payer in the Fee Juice.
  */
 export function computeFeePayerBalanceLeafSlot(feePayer: AztecAddress): Fr {
   if (feePayer.isZero()) {
     return Fr.ZERO;
   }
-  const gasToken = AztecAddress.fromBigInt(GAS_TOKEN_ADDRESS);
+  const feeJuice = AztecAddress.fromBigInt(FEE_JUICE_ADDRESS);
   const balanceSlot = computeFeePayerBalanceStorageSlot(feePayer);
-  return computePublicDataTreeLeafSlot(gasToken, balanceSlot);
+  return computePublicDataTreeLeafSlot(feeJuice, balanceSlot);
 }

package/src/public/hints_builder.ts

@@ -1,4 +1,4 @@
-import { MerkleTreeId } from '@aztec/circuit-types';
+import { type IndexedTreeId, MerkleTreeId } from '@aztec/circuit-types';
 import {
   type Fr,
   type MAX_NULLIFIERS_PER_TX,
@@ -23,7 +23,7 @@ import {
   buildSiloedNullifierReadRequestHints,
 } from '@aztec/circuits.js';
 import { type Tuple } from '@aztec/foundation/serialize';
-import { type IndexedTreeId, type MerkleTreeOperations } from '@aztec/world-state';
+import { type MerkleTreeOperations } from '@aztec/world-state';
 
 export class HintsBuilder {
   constructor(private db: MerkleTreeOperations) {}