@aztec/simulator 0.37.0 → 0.38.0

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/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.
    */

package/src/public/executor.ts

@@ -4,6 +4,7 @@ import {
   Gas,
   type GlobalVariables,
   type Header,
+  type Nullifier,
   PublicCircuitPublicInputs,
   type TxContext,
 } from '@aztec/circuits.js';
@@ -26,7 +27,7 @@ import { PackedValuesCache } from '../common/packed_values_cache.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db.js';
 import { type PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
 import { PublicExecutionContext } from './public_execution_context.js';
-import { convertAvmResults, createAvmExecutionEnvironment, isAvmBytecode } from './transitional_adaptors.js';
+import { convertAvmResultsToPxResult, createAvmExecutionEnvironment, isAvmBytecode } from './transitional_adaptors.js';
 
 /**
  * Execute a public function and return the execution result.
@@ -46,15 +47,23 @@ export async function executePublicFunction(
   }
 
   if (isAvmBytecode(bytecode)) {
-    return await executePublicFunctionAvm(context);
+    return await executeTopLevelPublicFunctionAvm(context, bytecode);
   } else {
     return await executePublicFunctionAcvm(context, bytecode, nested);
   }
 }
 
-async function executePublicFunctionAvm(executionContext: PublicExecutionContext): Promise<PublicExecutionResult> {
+/**
+ * Execute a top-level public function call (the first call in an enqueued-call/execution-request) in the AVM.
+ * Translate the results back to the PublicExecutionResult format.
+ */
+async function executeTopLevelPublicFunctionAvm(
+  executionContext: PublicExecutionContext,
+  bytecode: Buffer,
+): Promise<PublicExecutionResult> {
   const address = executionContext.execution.contractAddress;
   const selector = executionContext.execution.functionData.selector;
+  const startGas = executionContext.availableGas;
   const log = createDebugLogger('aztec:simulator:public_execution');
   log.verbose(`[AVM] Executing public external function ${address.toString()}:${selector}.`);
 
@@ -65,7 +74,15 @@ async function executePublicFunctionAvm(executionContext: PublicExecutionContext
     executionContext.contractsDb,
     executionContext.commitmentsDb,
   );
+
+  // TODO(6207): add sideEffectCounter to persistableState construction
+  // or modify the PersistableStateManager to manage rollbacks across enqueued-calls and transactions.
   const worldStateJournal = new AvmPersistableStateManager(hostStorage);
+  const startSideEffectCounter = executionContext.execution.callContext.sideEffectCounter;
+  for (const nullifier of executionContext.pendingNullifiers) {
+    worldStateJournal.nullifiers.cache.appendSiloed(nullifier.value);
+  }
+  worldStateJournal.trace.accessCounter = startSideEffectCounter;
 
   const executionEnv = createAvmExecutionEnvironment(
     executionContext.execution,
@@ -75,18 +92,30 @@ async function executePublicFunctionAvm(executionContext: PublicExecutionContext
     executionContext.transactionFee,
   );
 
-  const machineState = new AvmMachineState(executionContext.availableGas);
-  const context = new AvmContext(worldStateJournal, executionEnv, machineState);
-  const simulator = new AvmSimulator(context);
+  const machineState = new AvmMachineState(startGas);
+  const avmContext = new AvmContext(worldStateJournal, executionEnv, machineState);
+  const simulator = new AvmSimulator(avmContext);
 
-  const result = await simulator.execute();
-  const newWorldState = context.persistableState.flush();
+  const avmResult = await simulator.executeBytecode(bytecode);
+
+  // Commit the journals state to the DBs since this is a top-level execution.
+  // Observe that this will write all the state changes to the DBs, not only the latest for each slot.
+  // However, the underlying DB keep a cache and will only write the latest state to disk.
+  await avmContext.persistableState.publicStorage.commitToDB();
 
   log.verbose(
-    `[AVM] ${address.toString()}:${selector} returned, reverted: ${result.reverted}, reason: ${result.revertReason}.`,
+    `[AVM] ${address.toString()}:${selector} returned, reverted: ${avmResult.reverted}, reason: ${
+      avmResult.revertReason
+    }.`,
   );
 
-  return await convertAvmResults(executionContext, newWorldState, result, machineState);
+  return convertAvmResultsToPxResult(
+    avmResult,
+    startSideEffectCounter,
+    executionContext.execution,
+    startGas,
+    avmContext,
+  );
 }
 
 async function executePublicFunctionAcvm(
@@ -159,6 +188,8 @@ async function executePublicFunctionAcvm(
       nestedExecutions: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
+      unencryptedLogPreimagesLength: new Fr(4n), // empty logs have len 4
+      allUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       reverted,
       revertReason,
       startGasLeft: context.availableGas,
@@ -182,6 +213,7 @@ async function executePublicFunctionAcvm(
     startSideEffectCounter,
     endSideEffectCounter,
     unencryptedLogsHashes: unencryptedLogsHashesPadded,
+    unencryptedLogPreimagesLength,
   } = PublicCircuitPublicInputs.fromFields(returnWitness);
   const returnValues = await context.unpackReturns(returnsHash);
 
@@ -207,6 +239,7 @@ async function executePublicFunctionAcvm(
 
   const nestedExecutions = context.getNestedExecutions();
   const unencryptedLogs = context.getUnencryptedLogs();
+  const allUnencryptedLogs = context.getAllUnencryptedLogs();
 
   // TODO(palla/gas): We should be loading these values from the returned PublicCircuitPublicInputs
   const startGasLeft = context.availableGas;
@@ -227,6 +260,8 @@ async function executePublicFunctionAcvm(
     nestedExecutions,
     unencryptedLogsHashes,
     unencryptedLogs,
+    unencryptedLogPreimagesLength,
+    allUnencryptedLogs,
     reverted: false,
     revertReason: undefined,
     startGasLeft,
@@ -258,6 +293,7 @@ export class PublicExecutor {
     globalVariables: GlobalVariables,
     availableGas: Gas,
     txContext: TxContext,
+    pendingNullifiers: Nullifier[],
     transactionFee: Fr = Fr.ZERO,
     sideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
@@ -277,6 +313,7 @@ export class PublicExecutor {
       availableGas,
       transactionFee,
       txContext.gasSettings,
+      pendingNullifiers,
     );
 
     const executionResult = await executePublicFunction(context, /*nested=*/ false);

package/src/public/public_execution_context.ts

@@ -7,6 +7,7 @@ import {
   type GasSettings,
   type GlobalVariables,
   type Header,
+  type Nullifier,
   PublicContextInputs,
 } from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
@@ -37,13 +38,18 @@ export class PublicExecutionContext extends TypedOracle {
     public readonly header: Header,
     public readonly globalVariables: GlobalVariables,
     private readonly packedValuesCache: PackedValuesCache,
-    private readonly sideEffectCounter: SideEffectCounter,
+    // TRANSITIONAL: once AVM-ACVM interoperability is removed (fully functional AVM), sideEffectCounter can be made private
+    public readonly sideEffectCounter: SideEffectCounter,
     public readonly stateDb: PublicStateDB,
     public readonly contractsDb: PublicContractsDB,
     public readonly commitmentsDb: CommitmentsDB,
     public readonly availableGas: Gas,
     public readonly transactionFee: Fr,
     public readonly gasSettings: GasSettings,
+    public readonly pendingNullifiers: Nullifier[],
+    // Unencrypted logs emitted during this call AND any nested calls
+    // Useful for maintaining correct ordering in ts
+    private allUnencryptedLogs: UnencryptedL2Log[] = [],
     private log = createDebugLogger('aztec:simulator:public_execution_context'),
   ) {
     super();
@@ -87,6 +93,13 @@ export class PublicExecutionContext extends TypedOracle {
     return new UnencryptedFunctionL2Logs(this.unencryptedLogs);
   }
 
+  /**
+   * Return the encrypted logs emitted during this execution, including nested calls.
+   */
+  public getAllUnencryptedLogs() {
+    return new UnencryptedFunctionL2Logs(this.allUnencryptedLogs);
+  }
+
   /**
    * Return the data read and updated during this execution.
    */
@@ -135,11 +148,10 @@ export class PublicExecutionContext extends TypedOracle {
    * Emit an unencrypted log.
    * @param log - The unencrypted log to be emitted.
    */
-  public override emitUnencryptedLog(log: UnencryptedL2Log) {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/885)
+  public override emitUnencryptedLog(log: UnencryptedL2Log, _counter: number) {
     this.unencryptedLogs.push(log);
+    this.allUnencryptedLogs.push(log);
     this.log.verbose(`Emitted unencrypted log: "${log.toHumanReadable()}"`);
-    return Fr.fromBuffer(log.hash());
   }
 
   /**
@@ -229,6 +241,8 @@ export class PublicExecutionContext extends TypedOracle {
       this.availableGas,
       this.transactionFee,
       this.gasSettings,
+      /*pendingNullifiers=*/ [],
+      this.allUnencryptedLogs,
       this.log,
     );
 

package/src/public/tail_phase_manager.ts

@@ -1,10 +1,4 @@
-import {
-  type PublicKernelRequest,
-  PublicKernelType,
-  type Tx,
-  UnencryptedFunctionL2Logs,
-  type UnencryptedL2Log,
-} from '@aztec/circuit-types';
+import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
 import {
   Fr,
   type GlobalVariables,
@@ -57,8 +51,6 @@ export class TailPhaseManager extends AbstractPhaseManager {
         throw err;
       },
     );
-    // Temporary hack. Should sort them in the tail circuit.
-    this.patchLogsOrdering(tx, previousPublicKernelOutput);
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
@@ -163,33 +155,9 @@ export class TailPhaseManager extends AbstractPhaseManager {
   }
 
   private sortLogsHashes<N extends number>(unencryptedLogsHashes: Tuple<SideEffect, N>): Tuple<SideEffect, N> {
+    // TODO(6052): logs here may have duplicate counters from nested calls
     return sortByCounter(
       unencryptedLogsHashes.map(n => ({ ...n, counter: n.counter.toNumber(), isEmpty: () => n.isEmpty() })),
     ).map(h => new SideEffect(h.value, new Fr(h.counter))) as Tuple<SideEffect, N>;
   }
-
-  // As above, this is a hack for unencrypted logs ordering, now they are sorted. Since the public kernel
-  // cannot keep track of side effects that happen after or before a nested call, we override the gathered logs.
-  // As a sanity check, we at least verify that the elements are the same, so we are only tweaking their ordering.
-  // See same fn in pxe_service.ts
-  // Added as part of resolving #5017
-  private patchLogsOrdering(tx: Tx, publicInputs: PublicKernelCircuitPublicInputs) {
-    const unencLogs = tx.unencryptedLogs.unrollLogs();
-    const sortedUnencLogs = publicInputs.end.unencryptedLogsHashes;
-
-    const finalUnencLogs: UnencryptedL2Log[] = [];
-    sortedUnencLogs.forEach((sideEffect: SideEffect) => {
-      if (!sideEffect.isEmpty()) {
-        const isLog = (log: UnencryptedL2Log) => Fr.fromBuffer(log.hash()).equals(sideEffect.value);
-        const thisLogIndex = unencLogs.findIndex(isLog);
-        finalUnencLogs.push(unencLogs[thisLogIndex]);
-      }
-    });
-    const unencryptedLogs = new UnencryptedFunctionL2Logs(finalUnencLogs);
-
-    tx.unencryptedLogs.functionLogs[0] = unencryptedLogs;
-    for (let i = 1; i < tx.unencryptedLogs.functionLogs.length; i++) {
-      tx.unencryptedLogs.functionLogs[i] = UnencryptedFunctionL2Logs.empty();
-    }
-  }
 }