@aztec/simulator 0.47.0 → 0.48.0

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

@@ -4,10 +4,11 @@ import {
   type EncryptedL2NoteLog,
   EncryptedNoteFunctionL2Logs,
   type Note,
+  PublicExecutionRequest,
   UnencryptedFunctionL2Logs,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import { type IsEmpty, type PrivateCallStackItem, PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
+import { type IsEmpty, type PrivateCallStackItem, sortByCounter } from '@aztec/circuits.js';
 import { type NoteSelector } from '@aztec/foundation/abi';
 import { type Fr } from '@aztec/foundation/fields';
 
@@ -38,6 +39,15 @@ export class CountedNoteLog extends CountedLog<EncryptedL2NoteLog> {
     super(log, counter);
   }
 }
+
+export class CountedPublicExecutionRequest {
+  constructor(public request: PublicExecutionRequest, public counter: number) {}
+
+  isEmpty(): boolean {
+    return this.request.isEmpty() && !this.counter;
+  }
+}
+
 /**
  * The result of executing a private function.
  */
@@ -57,15 +67,15 @@ 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. */
   nestedExecutions: this[];
   /** Enqueued public function execution requests to be picked up by the sequencer. */
-  enqueuedPublicFunctionCalls: PublicCallRequest[];
+  enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[];
   /** Public function execution requested for teardown */
-  publicTeardownFunctionCall: PublicCallRequest;
+  publicTeardownFunctionCall: PublicExecutionRequest;
   /**
    * Encrypted note logs emitted during execution of this function call.
    * Note: These are preimages to `noteEncryptedLogsHashes`.
@@ -89,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;
 }
 
@@ -102,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();
 }
 
@@ -116,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));
 }
@@ -161,21 +184,26 @@ export function collectSortedUnencryptedLogs(execResult: ExecutionResult): Unenc
   return new UnencryptedFunctionL2Logs(sortedLogs.map(l => l.log));
 }
 
+function collectEnqueuedCountedPublicExecutionRequests(execResult: ExecutionResult): CountedPublicExecutionRequest[] {
+  return [
+    ...execResult.enqueuedPublicFunctionCalls,
+    ...execResult.nestedExecutions.flatMap(collectEnqueuedCountedPublicExecutionRequests),
+  ];
+}
+
 /**
  * Collect all enqueued public function calls across all nested executions.
  * @param execResult - The topmost execution result.
  * @returns All enqueued public function calls.
  */
-export function collectEnqueuedPublicFunctionCalls(execResult: ExecutionResult): PublicCallRequest[] {
+export function collectEnqueuedPublicFunctionCalls(execResult: ExecutionResult): PublicExecutionRequest[] {
+  const countedRequests = collectEnqueuedCountedPublicExecutionRequests(execResult);
   // without the reverse sort, the logs will be in a queue like fashion which is wrong
   // as the kernel processes it like a stack, popping items off and pushing them to output
-  return [
-    ...execResult.enqueuedPublicFunctionCalls,
-    ...execResult.nestedExecutions.flatMap(collectEnqueuedPublicFunctionCalls),
-  ].sort((a, b) => b.sideEffectCounter - a.sideEffectCounter);
+  return sortByCounter(countedRequests, false).map(r => r.request);
 }
 
-export function collectPublicTeardownFunctionCall(execResult: ExecutionResult): PublicCallRequest {
+export function collectPublicTeardownFunctionCall(execResult: ExecutionResult): PublicExecutionRequest {
   const teardownCalls = [
     execResult.publicTeardownFunctionCall,
     ...execResult.nestedExecutions.flatMap(collectPublicTeardownFunctionCall),
@@ -189,5 +217,12 @@ export function collectPublicTeardownFunctionCall(execResult: ExecutionResult):
     throw new Error('Multiple public teardown calls detected');
   }
 
-  return PublicCallRequest.empty();
+  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/mocks/fixtures.ts

@@ -1,4 +1,9 @@
-import { type FunctionCall, type SimulationError, UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
+import {
+  type FunctionCall,
+  PublicExecutionRequest,
+  type SimulationError,
+  UnencryptedFunctionL2Logs,
+} from '@aztec/circuit-types';
 import {
   ARGS_LENGTH,
   AvmExecutionHints,
@@ -8,13 +13,12 @@ import {
   type ContractStorageUpdateRequest,
   Fr,
   Gas,
-  type PublicCallRequest,
 } from '@aztec/circuits.js';
 import { makeAztecAddress, makeSelector } from '@aztec/circuits.js/testing';
 import { FunctionType } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
-import { type PublicExecutionRequest, type PublicExecutionResult } from '../public/execution.js';
+import { type PublicExecutionResult, resultToPublicCallRequest } from '../public/execution.js';
 
 export class PublicExecutionResultBuilder {
   private _executionRequest: PublicExecutionRequest;
@@ -29,7 +33,7 @@ export class PublicExecutionResultBuilder {
     this._executionRequest = executionRequest;
   }
 
-  static fromPublicCallRequest({
+  static fromPublicExecutionRequest({
     request,
     returnValues = [new Fr(1n)],
     nestedExecutions = [],
@@ -37,7 +41,7 @@ export class PublicExecutionResultBuilder {
     contractStorageReads = [],
     revertReason = undefined,
   }: {
-    request: PublicCallRequest;
+    request: PublicExecutionRequest;
     returnValues?: Fr[];
     nestedExecutions?: PublicExecutionResult[];
     contractStorageUpdateRequests?: ContractStorageUpdateRequest[];
@@ -74,12 +78,9 @@ export class PublicExecutionResultBuilder {
     contractStorageReads?: ContractStorageRead[];
     revertReason?: SimulationError;
   }) {
-    const builder = new PublicExecutionResultBuilder({
-      callContext: new CallContext(from, tx.to, tx.selector, false, false),
-      contractAddress: tx.to,
-      functionSelector: tx.selector,
-      args: tx.args,
-    });
+    const builder = new PublicExecutionResultBuilder(
+      new PublicExecutionRequest(tx.to, new CallContext(from, tx.to, tx.selector, false, false), tx.args),
+    );
 
     builder.withNestedExecutions(...nestedExecutions);
     builder.withContractStorageUpdateRequest(...contractStorageUpdateRequests);
@@ -122,6 +123,7 @@ export class PublicExecutionResultBuilder {
     return {
       executionRequest: this._executionRequest,
       nestedExecutions: this._nestedExecutions,
+      publicCallRequests: this._nestedExecutions.map(resultToPublicCallRequest),
       noteHashReadRequests: [],
       nullifierReadRequests: [],
       nullifierNonExistentReadRequests: [],