@aztec/simulator 0.36.0 → 0.38.0

package/src/client/client_execution_context.ts

@@ -15,10 +15,8 @@ import {
   FunctionData,
   FunctionSelector,
   type Header,
-  NoteHashReadRequestMembershipWitness,
   PrivateContextInputs,
   PublicCallRequest,
-  type SideEffect,
   type TxContext,
 } from '@aztec/circuits.js';
 import { Aes128 } from '@aztec/circuits.js/barretenberg';
@@ -32,7 +30,8 @@ import { type NoteData, toACVMWitness } from '../acvm/index.js';
 import { type PackedValuesCache } from '../common/packed_values_cache.js';
 import { type DBOracle } from './db_oracle.js';
 import { type ExecutionNoteCache } from './execution_note_cache.js';
-import { type ExecutionResult, type NoteAndSlot, type NullifiedNoteHashCounter } from './execution_result.js';
+import { CountedLog, type ExecutionResult, type NoteAndSlot } from './execution_result.js';
+import { type LogsCache } from './logs_cache.js';
 import { pickNotes } from './pick_notes.js';
 import { executePrivateFunction } from './private_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -58,10 +57,10 @@ export class ClientExecutionContext extends ViewDataOracle {
    * because these notes are meant to be maintained on a per-call basis
    * They should act as references for the read requests output by an app circuit via public inputs.
    */
-  private gotNotes: Map<bigint, bigint> = new Map();
-  private nullifiedNoteHashCounters: NullifiedNoteHashCounter[] = [];
-  private encryptedLogs: EncryptedL2Log[] = [];
-  private unencryptedLogs: UnencryptedL2Log[] = [];
+  private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
+  private nullifiedNoteHashCounters: Map<number, number> = new Map();
+  private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
+  private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
   private enqueuedPublicFunctionCalls: PublicCallRequest[] = [];
 
@@ -76,6 +75,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     authWitnesses: AuthWitness[],
     private readonly packedValuesCache: PackedValuesCache,
     private readonly noteCache: ExecutionNoteCache,
+    private readonly logsCache: LogsCache,
     db: DBOracle,
     private node: AztecNode,
     protected sideEffectCounter: number = 0,
@@ -112,23 +112,11 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * This function will populate readRequestPartialWitnesses which
-   * here is just used to flag reads as "transient" for new notes created during this execution
-   * or to flag non-transient reads with their leafIndex.
-   * The KernelProver will use this to fully populate witnesses and provide hints to
-   * the kernel regarding which commitments each transient read request corresponds to.
-   * @param noteHashReadRequests - SideEffect containing Note hashed of the notes being read and counter.
-   * @returns An array of partially filled in read request membership witnesses.
+   * The KernelProver will use this to fully populate witnesses and provide hints to the kernel circuit
+   * regarding which note hash each settled read request corresponds to.
    */
-  public getNoteHashReadRequestPartialWitnesses(noteHashReadRequests: SideEffect[]) {
-    return noteHashReadRequests
-      .filter(r => !r.isEmpty())
-      .map(r => {
-        const index = this.gotNotes.get(r.value.toBigInt());
-        return index !== undefined
-          ? NoteHashReadRequestMembershipWitness.empty(index)
-          : NoteHashReadRequestMembershipWitness.emptyTransient();
-      });
+  public getNoteHashLeafIndexMap() {
+    return this.noteHashLeafIndexMap;
   }
 
   /**
@@ -147,14 +135,28 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Return the encrypted logs emitted during this execution.
    */
   public getEncryptedLogs() {
-    return new EncryptedFunctionL2Logs(this.encryptedLogs);
+    return this.encryptedLogs;
+  }
+
+  /**
+   * Return the encrypted logs emitted during this execution and nested executions.
+   */
+  public getAllEncryptedLogs() {
+    return new EncryptedFunctionL2Logs(this.logsCache.getEncryptedLogs());
   }
 
   /**
    * Return the encrypted logs emitted during this execution.
    */
   public getUnencryptedLogs() {
-    return new UnencryptedFunctionL2Logs(this.unencryptedLogs);
+    return this.unencryptedLogs;
+  }
+
+  /**
+   * Return the unencrypted logs emitted during this execution and nested executions.
+   */
+  public getAllUnencryptedLogs() {
+    return new UnencryptedFunctionL2Logs(this.logsCache.getUnencryptedLogs());
   }
 
   /**
@@ -265,7 +267,7 @@ export class ClientExecutionContext extends ViewDataOracle {
         // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)
         // Should always be uniqueSiloedNoteHash when publicly created notes include nonces.
         const noteHashForReadRequest = n.nonce.isZero() ? siloedNoteHash : uniqueSiloedNoteHash;
-        this.gotNotes.set(noteHashForReadRequest.value, n.index);
+        this.noteHashLeafIndexMap.set(noteHashForReadRequest.toBigInt(), n.index);
       }
     });
 
@@ -321,7 +323,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       innerNoteHash,
     );
     if (nullifiedNoteHashCounter !== undefined) {
-      this.nullifiedNoteHashCounters.push({ noteHashCounter: nullifiedNoteHashCounter, nullifierCounter: counter });
+      this.nullifiedNoteHashCounters.set(nullifiedNoteHashCounter, counter);
     }
     return Promise.resolve();
   }
@@ -340,24 +342,45 @@ export class ClientExecutionContext extends ViewDataOracle {
     noteTypeId: Fr,
     publicKey: Point,
     log: Fr[],
+    counter: number,
   ) {
     const note = new Note(log);
     const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
     const taggedNote = new TaggedNote(l1NotePayload);
     const encryptedNote = taggedNote.toEncryptedBuffer(publicKey);
     const encryptedLog = new EncryptedL2Log(encryptedNote);
-    this.encryptedLogs.push(encryptedLog);
-    return Fr.fromBuffer(encryptedLog.hash());
+    this.encryptedLogs.push(new CountedLog(encryptedLog, counter));
+    this.logsCache.addEncryptedLog(encryptedLog);
+    return encryptedNote;
   }
 
   /**
    * Emit an unencrypted log.
    * @param log - The unencrypted log to be emitted.
    */
-  public override emitUnencryptedLog(log: UnencryptedL2Log) {
-    this.unencryptedLogs.push(log);
+  public override emitUnencryptedLog(log: UnencryptedL2Log, counter: number) {
+    this.unencryptedLogs.push(new CountedLog(log, counter));
+    this.logsCache.addUnencryptedLog(log);
     const text = log.toHumanReadable();
     this.log.verbose(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
+  }
+
+  /**
+   * Emit a contract class unencrypted log.
+   * This fn exists separately from emitUnencryptedLog because sha hashing the preimage
+   * is too large to compile (16,200 fields, 518,400 bytes) => the oracle hashes it.
+   * See private_context.nr
+   * @param log - The unencrypted log to be emitted.
+   */
+  public override emitContractClassUnencryptedLog(log: UnencryptedL2Log, counter: number) {
+    this.unencryptedLogs.push(new CountedLog(log, counter));
+    this.logsCache.addUnencryptedLog(log);
+    const text = log.toHumanReadable();
+    this.log.verbose(
+      `Emitted unencrypted log from ContractClassRegisterer: "${
+        text.length > 100 ? text.slice(0, 100) + '...' : text
+      }"`,
+    );
     return Fr.fromBuffer(log.hash());
   }
 
@@ -419,6 +442,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.authWitnesses,
       this.packedValuesCache,
       this.noteCache,
+      this.logsCache,
       this.db,
       this.node,
       sideEffectCounter,

package/src/client/db_oracle.ts

@@ -6,9 +6,9 @@ import {
   type PublicDataWitness,
 } from '@aztec/circuit-types';
 import { type CompleteAddress, type Header } from '@aztec/circuits.js';
-import { type FunctionArtifactWithDebugMetadata, type FunctionSelector } from '@aztec/foundation/abi';
+import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
+import { type Fr, type Point } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
 import { type NoteData, type NullifierKeys } from '../acvm/index.js';
@@ -64,6 +64,14 @@ export interface DBOracle extends CommitmentsDB {
    */
   popCapsule(): Promise<Fr[]>;
 
+  /**
+   * Gets public keys for an address.
+   * @param The address to look up
+   * @returns The public keys for a specific address
+   * TODO(#5834): Replace with `getCompleteAddress`.
+   */
+  getPublicKeysForAddress(address: AztecAddress): Promise<Point[]>;
+
   /**
    * Retrieve nullifier keys associated with a specific account and app/contract address.
    *
@@ -94,10 +102,7 @@ export interface DBOracle extends CommitmentsDB {
    * @param selector - The corresponding function selector.
    * @returns A Promise that resolves to a FunctionArtifact object.
    */
-  getFunctionArtifact(
-    contractAddress: AztecAddress,
-    selector: FunctionSelector,
-  ): Promise<FunctionArtifactWithDebugMetadata>;
+  getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifact>;
 
   /**
    * Retrieves the artifact of a specified function within a given contract.
@@ -107,10 +112,7 @@ export interface DBOracle extends CommitmentsDB {
    * @param functionName - The name of the function.
    * @returns The corresponding function's artifact as an object.
    */
-  getFunctionArtifactByName(
-    contractAddress: AztecAddress,
-    functionName: string,
-  ): Promise<FunctionArtifactWithDebugMetadata | undefined>;
+  getFunctionArtifactByName(contractAddress: AztecAddress, functionName: string): Promise<FunctionArtifact | undefined>;
 
   /**
    * Gets the index of a nullifier in the nullifier tree.

package/src/client/execution_result.ts

@@ -1,9 +1,11 @@
-import { type EncryptedFunctionL2Logs, type Note, type UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
-  type NoteHashReadRequestMembershipWitness,
-  type PrivateCallStackItem,
-  type PublicCallRequest,
-} from '@aztec/circuits.js';
+  EncryptedFunctionL2Logs,
+  type EncryptedL2Log,
+  type Note,
+  UnencryptedFunctionL2Logs,
+  type UnencryptedL2Log,
+} from '@aztec/circuit-types';
+import { type IsEmpty, type PrivateCallStackItem, type PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm/index.js';
@@ -20,9 +22,12 @@ export interface NoteAndSlot {
   noteTypeId: Fr;
 }
 
-export interface NullifiedNoteHashCounter {
-  noteHashCounter: number;
-  nullifierCounter: number;
+export class CountedLog<TLog extends UnencryptedL2Log | EncryptedL2Log> implements IsEmpty {
+  constructor(public log: TLog, public counter: number) {}
+
+  isEmpty(): boolean {
+    return !this.log.data.length && !this.counter;
+  }
 }
 
 /**
@@ -39,11 +44,12 @@ export interface ExecutionResult {
   // Needed for the verifier (kernel)
   /** The call stack item. */
   callStackItem: PrivateCallStackItem;
-  /** The partially filled-in read request membership witnesses for commitments being read. */
-  noteHashReadRequestPartialWitnesses: NoteHashReadRequestMembershipWitness[];
+  /** Mapping of note hash to its index in the note hash tree. Used for building hints for note hash read requests. */
+  noteHashLeafIndexMap: Map<bigint, bigint>;
   /** The notes created in the executed function. */
   newNotes: NoteAndSlot[];
-  nullifiedNoteHashCounters: NullifiedNoteHashCounter[];
+  /** Mapping of note hash counter to the counter of its nullifier. */
+  nullifiedNoteHashCounters: Map<number, number>;
   /** The raw return values of the executed function. */
   returnValues: Fr[];
   /** The nested executions. */
@@ -54,19 +60,24 @@ export interface ExecutionResult {
    * Encrypted logs emitted during execution of this function call.
    * Note: These are preimages to `encryptedLogsHashes`.
    */
-  encryptedLogs: EncryptedFunctionL2Logs;
+  encryptedLogs: CountedLog<EncryptedL2Log>[];
   /**
    * Unencrypted logs emitted during execution of this function call.
    * Note: These are preimages to `unencryptedLogsHashes`.
    */
-  unencryptedLogs: UnencryptedFunctionL2Logs;
+  unencryptedLogs: CountedLog<UnencryptedL2Log>[];
 }
 
-export function collectNullifiedNoteHashCounters(execResult: ExecutionResult): NullifiedNoteHashCounter[] {
-  return [
-    execResult.nullifiedNoteHashCounters,
-    ...execResult.nestedExecutions.flatMap(collectNullifiedNoteHashCounters),
-  ].flat();
+export function collectNoteHashLeafIndexMap(execResult: ExecutionResult, accum: Map<bigint, bigint> = new Map()) {
+  execResult.noteHashLeafIndexMap.forEach((value, key) => accum.set(key, value));
+  execResult.nestedExecutions.forEach(nested => collectNoteHashLeafIndexMap(nested, 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));
+  return accum;
 }
 
 /**
@@ -74,9 +85,19 @@ export function collectNullifiedNoteHashCounters(execResult: ExecutionResult): N
  * @param execResult - The topmost execution result.
  * @returns All encrypted logs.
  */
-export function collectEncryptedLogs(execResult: ExecutionResult): EncryptedFunctionL2Logs[] {
-  // without the .reverse(), the logs will be in a queue like fashion which is wrong as the kernel processes it like a stack.
-  return [execResult.encryptedLogs, ...[...execResult.nestedExecutions].reverse().flatMap(collectEncryptedLogs)];
+function collectEncryptedLogs(execResult: ExecutionResult): CountedLog<EncryptedL2Log>[] {
+  return [execResult.encryptedLogs, ...[...execResult.nestedExecutions].flatMap(collectEncryptedLogs)].flat();
+}
+
+/**
+ * Collect all encrypted logs across all nested executions and sorts by counter.
+ * @param execResult - The topmost execution result.
+ * @returns All encrypted logs.
+ */
+export function collectSortedEncryptedLogs(execResult: ExecutionResult): EncryptedFunctionL2Logs {
+  const allLogs = collectEncryptedLogs(execResult);
+  const sortedLogs = sortByCounter(allLogs);
+  return new EncryptedFunctionL2Logs(sortedLogs.map(l => l.log));
 }
 
 /**
@@ -84,9 +105,19 @@ export function collectEncryptedLogs(execResult: ExecutionResult): EncryptedFunc
  * @param execResult - The topmost execution result.
  * @returns All unencrypted logs.
  */
-export function collectUnencryptedLogs(execResult: ExecutionResult): UnencryptedFunctionL2Logs[] {
-  // without the .reverse(), the logs will be in a queue like fashion which is wrong as the kernel processes it like a stack.
-  return [execResult.unencryptedLogs, ...[...execResult.nestedExecutions].reverse().flatMap(collectUnencryptedLogs)];
+function collectUnencryptedLogs(execResult: ExecutionResult): CountedLog<UnencryptedL2Log>[] {
+  return [execResult.unencryptedLogs, ...[...execResult.nestedExecutions].flatMap(collectUnencryptedLogs)].flat();
+}
+
+/**
+ * Collect all unencrypted logs across all nested executions and sorts by counter.
+ * @param execResult - The topmost execution result.
+ * @returns All unencrypted logs.
+ */
+export function collectSortedUnencryptedLogs(execResult: ExecutionResult): UnencryptedFunctionL2Logs {
+  const allLogs = collectUnencryptedLogs(execResult);
+  const sortedLogs = sortByCounter(allLogs);
+  return new UnencryptedFunctionL2Logs(sortedLogs.map(l => l.log));
 }
 
 /**

package/src/client/logs_cache.ts

@@ -0,0 +1,65 @@
+import { type EncryptedL2Log, type UnencryptedL2Log } from '@aztec/circuit-types';
+
+/**
+ * Log data that's accessible by all the function calls in an execution.
+ * This class exists to:
+ * 1. Keep track of logs emitted through nested calls in the correct order.
+ * 2. TODO(1641): Remove encrypted logs based on notes nullified in the same scope.
+ */
+export class LogsCache {
+  /**
+   * Logs notes created in this transaction.
+   */
+  private encryptedLogs: EncryptedL2Log[] = [];
+  private unencryptedLogs: UnencryptedL2Log[] = [];
+
+  // TODO Separate encrypted logs linked to note hashes and arbitrary logs:
+
+  // Maps from note hash to encrypted log - useful for removing transient logs
+  // private encryptedLogsLinkedToNotes: Map<bigint, EncryptedL2Log> = new Map();
+
+  // /**
+  //  * Remove the encrypted log for a nullified note.
+  //  * This fn should only be called if the note's innerNoteHash != 0.
+  //  * @param noteHashCounter - Side effect counter of the note.
+  //  */
+  // public nullifyNote(noteHashCounter: Fr) {
+  //  // Find and remove the matching new note if the emitted innerNoteHash is not empty.
+  //  const log = this.encryptedLogsLinkedToNotes.get(noteHashCounter.toBigInt()) ?? false;
+  //  // TODO: throw here? Will the log always be here?
+  //  if (!log) {
+  //    throw new Error('Attempt to remove a pending note log that does not exist.');
+  //  }
+  //  this.encryptedLogsLinkedToNotes.delete(noteHashCounter.toBigInt());
+  // }
+
+  /**
+   * Add a new encrypted log to cache.
+   * @param log - New log created during execution.
+   */
+  public addEncryptedLog(log: EncryptedL2Log) {
+    this.encryptedLogs.push(log);
+  }
+
+  /**
+   * Add a new unencrypted log to cache.
+   * @param log - New log created during execution.
+   */
+  public addUnencryptedLog(log: UnencryptedL2Log) {
+    this.unencryptedLogs.push(log);
+  }
+
+  /**
+   * Return the encrypted logs.
+   */
+  public getEncryptedLogs() {
+    return this.encryptedLogs;
+  }
+
+  /**
+   * Return the encrypted logs.
+   */
+  public getUnencryptedLogs() {
+    return this.unencryptedLogs;
+  }
+}

package/src/client/private_execution.ts

@@ -1,7 +1,6 @@
 import { type FunctionData, PrivateCallStackItem, PrivateCircuitPublicInputs } from '@aztec/circuits.js';
-import { type FunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
+import { type FunctionArtifact } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { witnessMapToFields } from '../acvm/deserialize.js';
@@ -16,7 +15,7 @@ import { AcirSimulator } from './simulator.js';
  */
 export async function executePrivateFunction(
   context: ClientExecutionContext,
-  artifact: FunctionArtifactWithDebugMetadata,
+  artifact: FunctionArtifact,
   contractAddress: AztecAddress,
   functionData: FunctionData,
   log = createDebugLogger('aztec:simulator:secret_execution'),
@@ -45,17 +44,12 @@ export async function executePrivateFunction(
 
   const encryptedLogs = context.getEncryptedLogs();
   const unencryptedLogs = context.getUnencryptedLogs();
-  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir
-  publicInputs.encryptedLogPreimagesLength = new Fr(encryptedLogs.getSerializedLength());
-  publicInputs.unencryptedLogPreimagesLength = new Fr(unencryptedLogs.getSerializedLength());
 
   const callStackItem = new PrivateCallStackItem(contractAddress, functionData, publicInputs);
 
   const rawReturnValues = await context.unpackReturns(publicInputs.returnsHash);
 
-  const noteHashReadRequestPartialWitnesses = context.getNoteHashReadRequestPartialWitnesses(
-    publicInputs.noteHashReadRequests,
-  );
+  const noteHashLeafIndexMap = context.getNoteHashLeafIndexMap();
   const newNotes = context.getNewNotes();
   const nullifiedNoteHashCounters = context.getNullifiedNoteHashCounters();
   const nestedExecutions = context.getNestedExecutions();
@@ -68,7 +62,7 @@ export async function executePrivateFunction(
     partialWitness,
     callStackItem,
     returnValues: rawReturnValues,
-    noteHashReadRequestPartialWitnesses,
+    noteHashLeafIndexMap,
     newNotes,
     nullifiedNoteHashCounters,
     vk: Buffer.from(artifact.verificationKey!, 'hex'),

package/src/client/simulator.ts

@@ -2,7 +2,7 @@ import { type AztecNode, type FunctionCall, type Note, type TxExecutionRequest }
 import { CallContext, FunctionData } from '@aztec/circuits.js';
 import {
   type ArrayType,
-  type FunctionArtifactWithDebugMetadata,
+  type FunctionArtifact,
   FunctionSelector,
   FunctionType,
   encodeArguments,
@@ -19,6 +19,7 @@ import { ClientExecutionContext } from './client_execution_context.js';
 import { type DBOracle } from './db_oracle.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
 import { type ExecutionResult } from './execution_result.js';
+import { LogsCache } from './logs_cache.js';
 import { executePrivateFunction } from './private_execution.js';
 import { executeUnconstrainedFunction } from './unconstrained_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -64,7 +65,7 @@ export class AcirSimulator {
    */
   public async run(
     request: TxExecutionRequest,
-    entryPointArtifact: FunctionArtifactWithDebugMetadata,
+    entryPointArtifact: FunctionArtifact,
     contractAddress: AztecAddress,
     msgSender = AztecAddress.ZERO,
   ): Promise<ExecutionResult> {
@@ -100,6 +101,7 @@ export class AcirSimulator {
       request.authWitnesses,
       PackedValuesCache.create(request.argsOfCalls),
       new ExecutionNoteCache(),
+      new LogsCache(),
       this.db,
       this.node,
       startSideEffectCounter,
@@ -127,7 +129,7 @@ export class AcirSimulator {
    */
   public async runUnconstrained(
     request: FunctionCall,
-    entryPointArtifact: FunctionArtifactWithDebugMetadata,
+    entryPointArtifact: FunctionArtifact,
     contractAddress: AztecAddress,
   ) {
     if (entryPointArtifact.functionType !== FunctionType.UNCONSTRAINED) {
@@ -165,7 +167,7 @@ export class AcirSimulator {
     noteTypeId: Fr,
     note: Note,
   ) {
-    const artifact: FunctionArtifactWithDebugMetadata | undefined = await this.db.getFunctionArtifactByName(
+    const artifact: FunctionArtifact | undefined = await this.db.getFunctionArtifactByName(
       contractAddress,
       'compute_note_hash_and_nullifier',
     );

package/src/client/unconstrained_execution.ts

@@ -1,5 +1,5 @@
 import { type FunctionData } from '@aztec/circuits.js';
-import { type DecodedReturn, type FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/foundation/abi';
+import { type DecodedReturn, type FunctionArtifact, decodeReturnValues } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -16,7 +16,7 @@ import { type ViewDataOracle } from './view_data_oracle.js';
  */
 export async function executeUnconstrainedFunction(
   oracle: ViewDataOracle,
-  artifact: FunctionArtifactWithDebugMetadata,
+  artifact: FunctionArtifact,
   contractAddress: AztecAddress,
   functionData: FunctionData,
   args: Fr[],

package/src/client/view_data_oracle.ts

@@ -166,6 +166,16 @@ export class ViewDataOracle extends TypedOracle {
     return this.db.popCapsule();
   }
 
+  /**
+   * Gets public keys for an address.
+   * @param The address to look up
+   * @returns The public keys for a specific address
+   * TODO(#5834): Replace with `getCompleteAddress`.
+   */
+  public override getPublicKeysForAddress(address: AztecAddress) {
+    return this.db.getPublicKeysForAddress(address);
+  }
+
   /**
    * Gets some notes for a contract address and storage slot.
    * Returns a flattened array containing filtered notes.

package/src/mocks/fixtures.ts

@@ -116,6 +116,8 @@ export class PublicExecutionResultBuilder {
       contractStorageReads: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
+      unencryptedLogPreimagesLength: new Fr(4n), // empty logs have len 4
+      allUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       startSideEffectCounter: Fr.ZERO,
       endSideEffectCounter: Fr.ZERO,
       reverted: this._reverted,

package/src/public/abstract_phase_manager.ts

@@ -246,8 +246,10 @@ export abstract class AbstractPhaseManager {
       while (executionStack.length) {
         const current = executionStack.pop()!;
         const isExecutionRequest = !isPublicExecutionResult(current);
+        // TODO(6052): Extract correct new counter from nested calls
         const sideEffectCounter = lastSideEffectCounter(tx) + 1;
-        const availableGas = this.getAvailableGas(tx, previousPublicKernelOutput);
+        const availableGas = this.getAvailableGas(tx, kernelOutput);
+        const pendingNullifiers = this.getSiloedPendingNullifiers(kernelOutput);
 
         const result = isExecutionRequest
           ? await this.publicExecutor.simulate(
@@ -255,6 +257,7 @@ export abstract class AbstractPhaseManager {
               this.globalVariables,
               availableGas,
               tx.data.constants.txContext,
+              pendingNullifiers,
               transactionFee,
               sideEffectCounter,
             )
@@ -270,7 +273,9 @@ export abstract class AbstractPhaseManager {
           throw result.revertReason;
         }
 
-        newUnencryptedFunctionLogs.push(result.unencryptedLogs);
+        if (isExecutionRequest) {
+          newUnencryptedFunctionLogs.push(result.allUnencryptedLogs);
+        }
 
         this.log.debug(
           `Running public kernel circuit for ${result.execution.contractAddress.toString()}:${functionSelector}`,
@@ -320,6 +325,11 @@ export abstract class AbstractPhaseManager {
     return [publicKernelInputs, kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined, returns];
   }
 
+  /** Returns all pending private and public nullifiers.  */
+  private getSiloedPendingNullifiers(ko: PublicKernelCircuitPublicInputs) {
+    return [...ko.end.newNullifiers, ...ko.endNonRevertibleData.newNullifiers].filter(n => !n.isEmpty());
+  }
+
   protected getAvailableGas(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
     return tx.data.constants.txContext.gasSettings
       .getLimits() // No need to subtract teardown limits since they are already included in end.gasUsed
@@ -382,8 +392,6 @@ export abstract class AbstractPhaseManager {
       MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
     );
 
-    const unencryptedLogPreimagesLength = new Fr(result.unencryptedLogs.getSerializedLength());
-
     const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
       callContext: result.execution.callContext,
       proverAddress: AztecAddress.ZERO,
@@ -420,7 +428,7 @@ export abstract class AbstractPhaseManager {
         SideEffect.empty(),
         MAX_UNENCRYPTED_LOGS_PER_CALL,
       ),
-      unencryptedLogPreimagesLength,
+      unencryptedLogPreimagesLength: result.unencryptedLogPreimagesLength,
       historicalHeader: this.historicalHeader,
       globalVariables: this.globalVariables,
       startGasLeft: Gas.from(result.startGasLeft),

package/src/public/execution.ts

@@ -54,6 +54,15 @@ export interface PublicExecutionResult {
    * Note: These are preimages to `unencryptedLogsHashes`.
    */
   unencryptedLogs: UnencryptedFunctionL2Logs;
+  /**
+   * Length of the unencrypted log preimages emitted in this function call.
+   */
+  unencryptedLogPreimagesLength: Fr;
+  /**
+   * Unencrypted logs emitted during this call AND any nested calls.
+   * Useful for maintaining correct ordering in ts.
+   */
+  allUnencryptedLogs: UnencryptedFunctionL2Logs;
   /**
    * Whether the execution reverted.
    */