@aztec/simulator 0.47.1 → 0.48.0

package/src/client/client_execution_context.ts

@@ -30,7 +30,7 @@ import {
   countArgumentsSize,
 } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { pedersenHash } from '@aztec/foundation/crypto';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr, GrumpkinScalar, type Point } from '@aztec/foundation/fields';
 import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 
@@ -71,7 +71,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * They should act as references for the read requests output by an app circuit via public inputs.
    */
   private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
-  private nullifiedNoteHashCounters: Map<number, number> = new Map();
+  private noteHashNullifierCounterMap: Map<number, number> = new Map();
   private noteEncryptedLogs: CountedNoteLog[] = [];
   private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
@@ -94,8 +94,9 @@ export class ClientExecutionContext extends ViewDataOracle {
     private node: AztecNode,
     protected sideEffectCounter: number = 0,
     log = createDebugLogger('aztec:simulator:client_execution_context'),
+    scopes?: AztecAddress[],
   ) {
-    super(contractAddress, authWitnesses, db, node, log);
+    super(contractAddress, authWitnesses, db, node, log, scopes);
   }
 
   // We still need this function until we can get user-defined ordering of structs for fn arguments
@@ -135,14 +136,13 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   /**
    * Get the data for the newly created notes.
-   * @param innerNoteHashes - Inner note hashes for the notes.
    */
   public getNewNotes(): NoteAndSlot[] {
     return this.newNotes;
   }
 
-  public getNullifiedNoteHashCounters() {
-    return this.nullifiedNoteHashCounters;
+  public getNoteHashNullifierCounterMap() {
+    return this.noteHashNullifierCounterMap;
   }
 
   /**
@@ -251,7 +251,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const pendingNotes = this.noteCache.getNotes(this.callContext.storageContractAddress, storageSlot);
 
     const pendingNullifiers = this.noteCache.getNullifiers(this.callContext.storageContractAddress);
-    const dbNotes = await this.db.getNotes(this.callContext.storageContractAddress, storageSlot, status);
+    const dbNotes = await this.db.getNotes(this.callContext.storageContractAddress, storageSlot, status, this.scopes);
     const dbNotesFiltered = dbNotes.filter(n => !pendingNullifiers.has((n.siloedNullifier as Fr).value));
 
     const notes = pickNotes<NoteData>([...dbNotesFiltered, ...pendingNotes], {
@@ -276,12 +276,9 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     notes.forEach(n => {
       if (n.index !== undefined) {
-        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)
-        // Should always call computeUniqueNoteHash when publicly created notes include nonces.
-        const uniqueNoteHash = n.nonce.isZero() ? n.innerNoteHash : computeUniqueNoteHash(n.nonce, n.innerNoteHash);
+        const uniqueNoteHash = computeUniqueNoteHash(n.nonce, n.noteHash);
         const siloedNoteHash = siloNoteHash(n.contractAddress, uniqueNoteHash);
-        const noteHashForReadRequest = siloedNoteHash;
-        this.noteHashLeafIndexMap.set(noteHashForReadRequest.toBigInt(), n.index);
+        this.noteHashLeafIndexMap.set(siloedNoteHash.toBigInt(), n.index);
       }
     });
 
@@ -295,14 +292,14 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param storageSlot - The storage slot.
    * @param noteTypeId - The type ID of the note.
    * @param noteItems - The items to be included in a Note.
-   * @param innerNoteHash - The inner note hash of the new note.
+   * @param noteHash - A hash of the new note.
    * @returns
    */
   public override notifyCreatedNote(
     storageSlot: Fr,
     noteTypeId: NoteSelector,
     noteItems: Fr[],
-    innerNoteHash: Fr,
+    noteHash: Fr,
     counter: number,
   ) {
     const note = new Note(noteItems);
@@ -313,7 +310,7 @@ export class ClientExecutionContext extends ViewDataOracle {
         nonce: Fr.ZERO, // Nonce cannot be known during private execution.
         note,
         siloedNullifier: undefined, // Siloed nullifier cannot be known for newly created note.
-        innerNoteHash,
+        noteHash,
       },
       counter,
     );
@@ -328,16 +325,16 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Adding a siloed nullifier into the current set of all pending nullifiers created
    * within the current transaction/execution.
    * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
-   * @param innerNoteHash - The inner note hash of the new note.
+   * @param noteHash - A hash of the new note.
    */
-  public override notifyNullifiedNote(innerNullifier: Fr, innerNoteHash: Fr, counter: number) {
+  public override notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
     const nullifiedNoteHashCounter = this.noteCache.nullifyNote(
       this.callContext.storageContractAddress,
       innerNullifier,
-      innerNoteHash,
+      noteHash,
     );
     if (nullifiedNoteHashCounter !== undefined) {
-      this.nullifiedNoteHashCounters.set(nullifiedNoteHashCounter, counter);
+      this.noteHashNullifierCounterMap.set(nullifiedNoteHashCounter, counter);
     }
     return Promise.resolve();
   }
@@ -360,7 +357,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     // An app providing randomness = 0 signals to not mask the address.
     const maskedContractAddress = randomness.isZero()
       ? contractAddress.toField()
-      : pedersenHash([contractAddress, randomness], 0);
+      : poseidon2HashWithSeparator([contractAddress, randomness], 0);
     const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedEvent, maskedContractAddress), counter);
     this.encryptedLogs.push(encryptedLog);
   }
@@ -519,6 +516,8 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.db,
       this.node,
       sideEffectCounter,
+      this.log,
+      this.scopes,
     );
 
     const childExecutionResult = await executePrivateFunction(
@@ -645,6 +644,10 @@ export class ClientExecutionContext extends ViewDataOracle {
     );
   }
 
+  public override notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): void {
+    this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
+  }
+
   /**
    * Derives the call context for a nested execution.
    * @param targetContractAddress - The address of the contract being called.

package/src/client/db_oracle.ts

@@ -78,12 +78,18 @@ export interface DBOracle extends CommitmentsDB {
    * The query result is paginated using 'limit' and 'offset' values.
    * Returns an object containing an array of note data.
    *
-   * @param contractAddress - The AztecAddress instance representing the contract address.
-   * @param storageSlot - The Fr instance representing the storage slot of the notes.
+   * @param contractAddress - The contract address of the notes.
+   * @param storageSlot - The storage slot of the notes.
    * @param status - The status of notes to fetch.
+   * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
    * @returns A Promise that resolves to an array of note data.
    */
-  getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus): Promise<NoteData[]>;
+  getNotes(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    status: NoteStatus,
+    scopes?: AztecAddress[],
+  ): Promise<NoteData[]>;
 
   /**
    * Retrieve the artifact information of a specific function within a contract.

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/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;
   }
 }