@aztec/simulator 0.42.0 → 0.44.0

package/src/public/abstract_phase_manager.ts

@@ -67,37 +67,17 @@ import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { HintsBuilder } from './hints_builder.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
-import { lastSideEffectCounter } from './utils.js';
 
-export enum PublicKernelPhase {
-  SETUP = 'setup',
-  APP_LOGIC = 'app-logic',
-  TEARDOWN = 'teardown',
-  TAIL = 'tail',
-}
-
-export const PhaseIsRevertible: Record<PublicKernelPhase, boolean> = {
-  [PublicKernelPhase.SETUP]: false,
-  [PublicKernelPhase.APP_LOGIC]: true,
-  [PublicKernelPhase.TEARDOWN]: true,
-  [PublicKernelPhase.TAIL]: false,
+export const PhaseIsRevertible: Record<PublicKernelType, boolean> = {
+  [PublicKernelType.NON_PUBLIC]: false,
+  [PublicKernelType.SETUP]: false,
+  [PublicKernelType.APP_LOGIC]: true,
+  [PublicKernelType.TEARDOWN]: true,
+  [PublicKernelType.TAIL]: false,
 };
 
-// REFACTOR: Unify both enums and move to types or circuit-types.
-export function publicKernelPhaseToKernelType(phase: PublicKernelPhase): PublicKernelType {
-  switch (phase) {
-    case PublicKernelPhase.SETUP:
-      return PublicKernelType.SETUP;
-    case PublicKernelPhase.APP_LOGIC:
-      return PublicKernelType.APP_LOGIC;
-    case PublicKernelPhase.TEARDOWN:
-      return PublicKernelType.TEARDOWN;
-    case PublicKernelPhase.TAIL:
-      return PublicKernelType.TAIL;
-  }
-}
-
 export type PublicProvingInformation = {
+  functionName: string; // informational only
   calldata: Fr[];
   bytecode: Buffer;
   inputs: PublicKernelCircuitPrivateInputs;
@@ -110,6 +90,7 @@ export function makeAvmProvingRequest(
 ): AvmProvingRequest {
   return {
     type: AVM_REQUEST,
+    functionName: info.functionName,
     bytecode: info.bytecode,
     calldata: info.calldata,
     avmHints: info.avmHints,
@@ -159,7 +140,7 @@ export abstract class AbstractPhaseManager {
     protected publicKernel: PublicKernelCircuitSimulator,
     protected globalVariables: GlobalVariables,
     protected historicalHeader: Header,
-    public phase: PublicKernelPhase,
+    public phase: PublicKernelType,
   ) {
     this.hintsBuilder = new HintsBuilder(db);
     this.log = createDebugLogger(`aztec:sequencer:${phase}`);
@@ -171,14 +152,15 @@ export abstract class AbstractPhaseManager {
    */
   abstract handle(tx: Tx, publicKernelPublicInputs: PublicKernelCircuitPublicInputs): Promise<PhaseResult>;
 
-  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelPhase, PublicCallRequest[]> {
+  public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelType, PublicCallRequest[]> {
     const data = tx.data.forPublic;
     if (!data) {
       return {
-        [PublicKernelPhase.SETUP]: [],
-        [PublicKernelPhase.APP_LOGIC]: [],
-        [PublicKernelPhase.TEARDOWN]: [],
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: [],
+        [PublicKernelType.APP_LOGIC]: [],
+        [PublicKernelType.TEARDOWN]: [],
+        [PublicKernelType.TAIL]: [],
       };
     }
     const publicCallsStack = tx.enqueuedPublicFunctionCalls.slice().reverse();
@@ -196,10 +178,11 @@ export abstract class AbstractPhaseManager {
 
     if (callRequestsStack.length === 0) {
       return {
-        [PublicKernelPhase.SETUP]: [],
-        [PublicKernelPhase.APP_LOGIC]: [],
-        [PublicKernelPhase.TEARDOWN]: [],
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: [],
+        [PublicKernelType.APP_LOGIC]: [],
+        [PublicKernelType.TEARDOWN]: [],
+        [PublicKernelType.TAIL]: [],
       };
     }
 
@@ -212,25 +195,28 @@ export abstract class AbstractPhaseManager {
 
     if (firstRevertibleCallIndex === 0) {
       return {
-        [PublicKernelPhase.SETUP]: [],
-        [PublicKernelPhase.APP_LOGIC]: publicCallsStack,
-        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: [],
+        [PublicKernelType.APP_LOGIC]: publicCallsStack,
+        [PublicKernelType.TEARDOWN]: teardownCallStack,
+        [PublicKernelType.TAIL]: [],
       };
     } else if (firstRevertibleCallIndex === -1) {
       // there's no app logic, split the functions between setup (many) and teardown (just one function call)
       return {
-        [PublicKernelPhase.SETUP]: publicCallsStack,
-        [PublicKernelPhase.APP_LOGIC]: [],
-        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: publicCallsStack,
+        [PublicKernelType.APP_LOGIC]: [],
+        [PublicKernelType.TEARDOWN]: teardownCallStack,
+        [PublicKernelType.TAIL]: [],
       };
     } else {
       return {
-        [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex),
-        [PublicKernelPhase.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
-        [PublicKernelPhase.TEARDOWN]: teardownCallStack,
-        [PublicKernelPhase.TAIL]: [],
+        [PublicKernelType.NON_PUBLIC]: [],
+        [PublicKernelType.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex),
+        [PublicKernelType.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
+        [PublicKernelType.TEARDOWN]: teardownCallStack,
+        [PublicKernelType.TAIL]: [],
       };
     }
   }
@@ -278,19 +264,17 @@ export abstract class AbstractPhaseManager {
       while (executionStack.length) {
         const current = executionStack.pop()!;
         const isExecutionRequest = !isPublicExecutionResult(current);
-        const sideEffectCounter = lastSideEffectCounter(kernelPublicOutput) + 1;
-        const availableGas = this.getAvailableGas(tx, kernelPublicOutput);
-        const pendingNullifiers = this.getSiloedPendingNullifiers(kernelPublicOutput);
-
         const result = isExecutionRequest
           ? await this.publicExecutor.simulate(
-              current,
+              /*executionRequest=*/ current,
               this.globalVariables,
-              availableGas,
+              /*availableGas=*/ this.getAvailableGas(tx, kernelPublicOutput),
               tx.data.constants.txContext,
-              pendingNullifiers,
+              /*pendingNullifiers=*/ this.getSiloedPendingNullifiers(kernelPublicOutput),
               transactionFee,
-              sideEffectCounter,
+              /*startSideEffectCounter=*/ AbstractPhaseManager.getMaxSideEffectCounter(kernelPublicOutput) + 1,
+              // NOTE: startSideEffectCounter is not the same as the executionRequest's sideEffectCounter
+              // (which counts the request itself)
             )
           : current;
 
@@ -302,15 +286,17 @@ export abstract class AbstractPhaseManager {
         const functionSelector = result.execution.functionSelector.toString();
         if (result.reverted && !result.revertReason) {
           throw new Error(
-            `Simulation of ${result.execution.contractAddress.toString()}:${functionSelector} reverted with no reason.`,
+            `Simulation of ${result.execution.contractAddress.toString()}:${functionSelector}(${
+              result.functionName
+            }) reverted with no reason.`,
           );
         }
 
         if (result.reverted && !PhaseIsRevertible[this.phase]) {
           this.log.debug(
-            `Simulation error on ${result.execution.contractAddress.toString()}:${functionSelector} with reason: ${
-              result.revertReason
-            }`,
+            `Simulation error on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+              result.functionName
+            }) with reason: ${result.revertReason}`,
           );
           throw result.revertReason;
         }
@@ -322,7 +308,9 @@ export abstract class AbstractPhaseManager {
 
         // Simulate the public kernel circuit.
         this.log.debug(
-          `Running public kernel circuit for ${result.execution.contractAddress.toString()}:${functionSelector}`,
+          `Running public kernel circuit for ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            result.functionName
+          })`,
         );
         const callData = await this.getPublicCallData(result, isExecutionRequest);
         const [privateInputs, publicInputs] = await this.runKernelCircuit(kernelPublicOutput, callData);
@@ -330,10 +318,11 @@ export abstract class AbstractPhaseManager {
 
         // Capture the inputs for later proving in the AVM and kernel.
         const publicProvingInformation: PublicProvingInformation = {
+          functionName: result.functionName,
           calldata: result.calldata,
           bytecode: result.bytecode!,
           inputs: privateInputs,
-          avmHints: result.avmHints,
+          avmHints: result.avmCircuitHints,
         };
         provingInformationList.push(publicProvingInformation);
 
@@ -342,7 +331,9 @@ export abstract class AbstractPhaseManager {
         // but the kernel carries the reverted flag forward. But if the simulator reverts, so should the kernel.
         if (result.reverted && kernelPublicOutput.revertCode.isOK()) {
           throw new Error(
-            `Public kernel circuit did not revert on ${result.execution.contractAddress.toString()}:${functionSelector}, but simulator did.`,
+            `Public kernel circuit did not revert on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+              result.functionName
+            }), but simulator did.`,
           );
         }
 
@@ -350,9 +341,9 @@ export abstract class AbstractPhaseManager {
         // So safely return the revert reason and the kernel output (which has had its revertible side effects dropped)
         if (result.reverted) {
           this.log.debug(
-            `Reverting on ${result.execution.contractAddress.toString()}:${functionSelector} with reason: ${
-              result.revertReason
-            }`,
+            `Reverting on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+              result.functionName
+            }) with reason: ${result.revertReason}`,
           );
           // TODO(@spalladino): Check gasUsed is correct. The AVM should take care of setting gasLeft to zero upon a revert.
           return {
@@ -407,11 +398,11 @@ export abstract class AbstractPhaseManager {
     // We take a deep copy (clone) of these inputs to be passed to the prover
     const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
     switch (this.phase) {
-      case PublicKernelPhase.SETUP:
+      case PublicKernelType.SETUP:
         return [inputs.clone(), await this.publicKernel.publicKernelCircuitSetup(inputs)];
-      case PublicKernelPhase.APP_LOGIC:
+      case PublicKernelType.APP_LOGIC:
         return [inputs.clone(), await this.publicKernel.publicKernelCircuitAppLogic(inputs)];
-      case PublicKernelPhase.TEARDOWN:
+      case PublicKernelType.TEARDOWN:
         return [inputs.clone(), await this.publicKernel.publicKernelCircuitTeardown(inputs)];
       default:
         throw new Error(`No public kernel circuit for inputs`);
@@ -508,6 +499,44 @@ export abstract class AbstractPhaseManager {
     return await Promise.all(nested.map(n => this.getPublicCallStackItem(n)));
   }
 
+  /**
+   * Looks at the side effects of a transaction and returns the highest counter
+   * @param tx - A transaction
+   * @returns The highest side effect counter in the transaction so far
+   */
+  static getMaxSideEffectCounter(inputs: PublicKernelCircuitPublicInputs): number {
+    const sideEffectCounters = [
+      ...inputs.endNonRevertibleData.newNoteHashes,
+      ...inputs.endNonRevertibleData.newNullifiers,
+      ...inputs.endNonRevertibleData.noteEncryptedLogsHashes,
+      ...inputs.endNonRevertibleData.encryptedLogsHashes,
+      ...inputs.endNonRevertibleData.unencryptedLogsHashes,
+      ...inputs.endNonRevertibleData.publicCallStack,
+      ...inputs.endNonRevertibleData.publicDataUpdateRequests,
+      ...inputs.end.newNoteHashes,
+      ...inputs.end.newNullifiers,
+      ...inputs.end.noteEncryptedLogsHashes,
+      ...inputs.end.encryptedLogsHashes,
+      ...inputs.end.unencryptedLogsHashes,
+      ...inputs.end.publicCallStack,
+      ...inputs.end.publicDataUpdateRequests,
+    ];
+
+    let max = 0;
+    for (const sideEffect of sideEffectCounters) {
+      if ('startSideEffectCounter' in sideEffect) {
+        // look at both start and end counters because for enqueued public calls start > 0 while end === 0
+        max = Math.max(max, sideEffect.startSideEffectCounter.toNumber(), sideEffect.endSideEffectCounter.toNumber());
+      } else if ('counter' in sideEffect) {
+        max = Math.max(max, sideEffect.counter);
+      } else {
+        throw new Error('Unknown side effect type');
+      }
+    }
+
+    return max;
+  }
+
   protected getBytecodeHash(_result: PublicExecutionResult) {
     // TODO: Determine how to calculate bytecode hash. Circuits just check it isn't zero for now.
     // See https://github.com/AztecProtocol/aztec3-packages/issues/378

package/src/public/app_logic_phase_manager.ts

@@ -3,7 +3,7 @@ import { type GlobalVariables, type Header, type PublicKernelCircuitPublicInputs
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { AbstractPhaseManager, PublicKernelPhase, makeAvmProvingRequest } from './abstract_phase_manager.js';
+import { AbstractPhaseManager, makeAvmProvingRequest } from './abstract_phase_manager.js';
 import { type ContractsDataSourcePublicDB } from './public_db_sources.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
@@ -19,7 +19,7 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     historicalHeader: Header,
     protected publicContractsDB: ContractsDataSourcePublicDB,
     protected publicStateDB: PublicStateDB,
-    phase: PublicKernelPhase = PublicKernelPhase.APP_LOGIC,
+    phase: PublicKernelType = PublicKernelType.APP_LOGIC,
   ) {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
@@ -47,6 +47,7 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
       // if so, this is removing contracts deployed in private setup
       await this.publicContractsDB.removeNewContracts(tx);
       await this.publicStateDB.rollbackToCheckpoint();
+      tx.filterRevertedLogs(kernelOutput);
     } else {
       tx.unencryptedLogs.addFunctionLogs(newUnencryptedLogs);
       // TODO(#6470): we should be adding contracts deployed in those logs to the publicContractsDB

package/src/public/db_interfaces.ts

@@ -67,6 +67,8 @@ export interface PublicContractsDB {
    * @returns The contract instance or undefined if not found.
    */
   getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 }
 
 /** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */

package/src/public/execution.ts

@@ -9,11 +9,8 @@ import {
   type NoteHash,
   type Nullifier,
   type PublicCallRequest,
-  PublicDataRead,
-  PublicDataUpdateRequest,
   type ReadRequest,
 } from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot, computePublicDataTreeValue } from '@aztec/circuits.js/hash';
 
 import { type Gas } from '../avm/avm_gas.js';
 
@@ -23,16 +20,37 @@ import { type Gas } from '../avm/avm_gas.js';
 export interface PublicExecutionResult {
   /** The execution that triggered this result. */
   execution: PublicExecution;
+
+  /** The side effect counter at the start of the function call. */
+  startSideEffectCounter: Fr;
+  /** The side effect counter after executing this function call */
+  endSideEffectCounter: Fr;
+  /** How much gas was available for this public execution. */
+  startGasLeft: Gas;
+  /** How much gas was left after this public execution. */
+  endGasLeft: Gas;
+  /** Transaction fee set for this tx. */
+  transactionFee: Fr;
+
+  /** Bytecode used for this execution. */
+  bytecode?: Buffer;
+  /** Calldata used for this execution. */
+  calldata: Fr[];
   /** The return values of the function. */
   returnValues: Fr[];
+  /** Whether the execution reverted. */
+  reverted: boolean;
+  /** The revert reason if the execution reverted. */
+  revertReason?: SimulationError;
+
+  /** The contract storage reads performed by the function. */
+  contractStorageReads: ContractStorageRead[];
+  /** The contract storage update requests performed by the function. */
+  contractStorageUpdateRequests: ContractStorageUpdateRequest[];
   /** The new note hashes to be inserted into the note hashes tree. */
   newNoteHashes: NoteHash[];
   /** The new l2 to l1 messages generated in this call. */
   newL2ToL1Messages: L2ToL1Message[];
-  /** The side effect counter at the start of the function call. */
-  startSideEffectCounter: Fr;
-  /** The side effect counter after executing this function call */
-  endSideEffectCounter: Fr;
   /** The new nullifiers to be inserted into the nullifier tree. */
   newNullifiers: Nullifier[];
   /** The note hash read requests emitted in this call. */
@@ -43,12 +61,6 @@ export interface PublicExecutionResult {
   nullifierNonExistentReadRequests: ReadRequest[];
   /** L1 to L2 message read requests emitted in this call. */
   l1ToL2MsgReadRequests: ReadRequest[];
-  /** The contract storage reads performed by the function. */
-  contractStorageReads: ContractStorageRead[];
-  /** The contract storage update requests performed by the function. */
-  contractStorageUpdateRequests: ContractStorageUpdateRequest[];
-  /** The results of nested calls. */
-  nestedExecutions: this[];
   /**
    * The hashed logs with side effect counter.
    * Note: required as we don't track the counter anywhere else.
@@ -64,22 +76,17 @@ export interface PublicExecutionResult {
    * Useful for maintaining correct ordering in ts.
    */
   allUnencryptedLogs: UnencryptedFunctionL2Logs;
-  /** Whether the execution reverted. */
-  reverted: boolean;
-  /** The revert reason if the execution reverted. */
-  revertReason?: SimulationError;
-  /** How much gas was available for this public execution. */
-  startGasLeft: Gas;
-  /** How much gas was left after this public execution. */
-  endGasLeft: Gas;
-  /** Transaction fee set for this tx. */
-  transactionFee: Fr;
-  /** Bytecode used for this execution. */
-  bytecode?: Buffer;
-  /** Calldata used for this execution. */
-  calldata: Fr[];
+
+  // TODO(dbanks12): add contract instance read requests
+
+  /** The results of nested calls. */
+  nestedExecutions: this[];
+
   /** Hints for proving AVM execution. */
-  avmHints: AvmExecutionHints;
+  avmCircuitHints: AvmExecutionHints;
+
+  /** The name of the function that was executed. Only used for logging. */
+  functionName: string;
 }
 
 /**
@@ -98,72 +105,6 @@ export function isPublicExecutionResult(
   return 'execution' in input && input.execution !== undefined;
 }
 
-/**
- * Collect all public storage reads across all nested executions
- * and convert them to PublicDataReads (to match kernel output).
- * @param execResult - The topmost execution result.
- * @returns All public data reads (in execution order).
- */
-export function collectPublicDataReads(execResult: PublicExecutionResult): PublicDataRead[] {
-  // HACK(#1622): part of temporary hack - may be able to remove this function after public state ordering is fixed
-  const thisExecPublicDataReads = execResult.contractStorageReads.map(read =>
-    contractStorageReadToPublicDataRead(read),
-  );
-  const unsorted = [
-    ...thisExecPublicDataReads,
-    ...[...execResult.nestedExecutions].flatMap(result => collectPublicDataReads(result)),
-  ];
-  return unsorted.sort((a, b) => a.sideEffectCounter! - b.sideEffectCounter!);
-}
-
-/**
- * Collect all public storage update requests across all nested executions
- * and convert them to PublicDataUpdateRequests (to match kernel output).
- * @param execResult - The topmost execution result.
- * @returns All public data reads (in execution order).
- */
-export function collectPublicDataUpdateRequests(execResult: PublicExecutionResult): PublicDataUpdateRequest[] {
-  // HACK(#1622): part of temporary hack - may be able to remove this function after public state ordering is fixed
-  const thisExecPublicDataUpdateRequests = execResult.contractStorageUpdateRequests.map(update =>
-    contractStorageUpdateRequestToPublicDataUpdateRequest(update),
-  );
-  const unsorted = [
-    ...thisExecPublicDataUpdateRequests,
-    ...[...execResult.nestedExecutions].flatMap(result => collectPublicDataUpdateRequests(result)),
-  ];
-  return unsorted.sort((a, b) => a.sideEffectCounter! - b.sideEffectCounter!);
-}
-
-/**
- * Convert a Contract Storage Read to a Public Data Read.
- * @param read - the contract storage read to convert
- * @param contractAddress - the contract address of the read
- * @returns The public data read.
- */
-function contractStorageReadToPublicDataRead(read: ContractStorageRead): PublicDataRead {
-  return new PublicDataRead(
-    computePublicDataTreeLeafSlot(read.contractAddress!, read.storageSlot),
-    computePublicDataTreeValue(read.currentValue),
-    read.sideEffectCounter!,
-  );
-}
-
-/**
- * Convert a Contract Storage Update Request to a Public Data Update Request.
- * @param update - the contract storage update request to convert
- * @param contractAddress - the contract address of the data update request.
- * @returns The public data update request.
- */
-function contractStorageUpdateRequestToPublicDataUpdateRequest(
-  update: ContractStorageUpdateRequest,
-): PublicDataUpdateRequest {
-  return new PublicDataUpdateRequest(
-    computePublicDataTreeLeafSlot(update.contractAddress!, update.storageSlot),
-    computePublicDataTreeValue(update.newValue),
-    update.sideEffectCounter!,
-  );
-}
-
 /**
  * Checks whether the child execution result is valid for a static call (no state modifications).
  * @param executionResult - The execution result of a public function

package/src/public/executor.ts

@@ -1,5 +1,7 @@
-import { Fr, type Gas, type GlobalVariables, type Header, type Nullifier, type TxContext } from '@aztec/circuits.js';
+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 { AvmContext } from '../avm/avm_context.js';
 import { AvmMachineState } from '../avm/avm_machine_state.js';
@@ -8,7 +10,8 @@ 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 PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
-import { convertAvmResultsToPxResult, createAvmExecutionEnvironment } from './transitional_adaptors.js';
+import { PublicSideEffectTrace } from './side_effect_trace.js';
+import { createAvmExecutionEnvironment } from './transitional_adaptors.js';
 
 /**
  * Handles execution of public functions.
@@ -25,82 +28,95 @@ export class PublicExecutor {
 
   /**
    * Executes a public execution request.
-   * @param execution - The execution to run.
+   * @param executionRequest - The execution to run.
    * @param globalVariables - The global variables to use.
-   * @returns The result of the run plus all nested runs.
+   * @param availableGas - The gas available at the start of this enqueued call.
+   * @param txContext - Transaction context.
+   * @param pendingSiloedNullifiers - The pending nullifier set from earlier parts of this TX.
+   * @param transactionFee - Fee offered for this TX.
+   * @param startSideEffectCounter - The counter of the first side-effect generated by this simulation.
+   * @returns The result of execution, including the results of all nested calls.
    */
   public async simulate(
-    execution: PublicExecution,
+    executionRequest: PublicExecution,
     globalVariables: GlobalVariables,
     availableGas: Gas,
     txContext: TxContext,
-    pendingNullifiers: Nullifier[],
+    pendingSiloedNullifiers: Nullifier[],
     transactionFee: Fr = Fr.ZERO,
-    sideEffectCounter: number = 0,
+    startSideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
-    const address = execution.contractAddress;
-    const selector = execution.functionSelector;
-    const startGas = availableGas;
+    const address = executionRequest.contractAddress;
+    const selector = executionRequest.functionSelector;
+    const fnName = (await this.contractsDb.getDebugFunctionName(address, selector)) ?? `${address}:${selector}`;
 
-    PublicExecutor.log.verbose(`[AVM] Executing public external function ${address.toString()}:${selector}.`);
+    PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}.`);
+    const timer = new Timer();
 
-    // Temporary code to construct the AVM context
-    // These data structures will permeate across the simulator when the public executor is phased out
     const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
+    const trace = new PublicSideEffectTrace(startSideEffectCounter);
+    const avmPersistableState = AvmPersistableStateManager.newWithPendingSiloedNullifiers(
+      hostStorage,
+      trace,
+      pendingSiloedNullifiers.map(n => n.value),
+    );
 
-    const startSideEffectCounter = sideEffectCounter;
-    const worldStateJournal = new AvmPersistableStateManager(hostStorage);
-    for (const nullifier of pendingNullifiers) {
-      worldStateJournal.nullifiers.cache.appendSiloed(nullifier.value);
-    }
-    // All the subsequent side effects will have a counter larger than the call's start counter.
-    worldStateJournal.trace.accessCounter = startSideEffectCounter + 1;
-
-    const executionEnv = createAvmExecutionEnvironment(
-      execution,
+    const avmExecutionEnv = createAvmExecutionEnvironment(
+      executionRequest,
       this.header,
       globalVariables,
       txContext.gasSettings,
       transactionFee,
     );
 
-    const machineState = new AvmMachineState(startGas);
-    const avmContext = new AvmContext(worldStateJournal, executionEnv, machineState);
+    const avmMachineState = new AvmMachineState(availableGas);
+    const avmContext = new AvmContext(avmPersistableState, avmExecutionEnv, avmMachineState);
     const simulator = new AvmSimulator(avmContext);
     const avmResult = await simulator.execute();
+    const bytecode = simulator.getBytecode()!;
 
     // 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.
+    // TODO(dbanks12): this should be unnecessary here or should be exposed by state manager
     await avmContext.persistableState.publicStorage.commitToDB();
 
     PublicExecutor.log.verbose(
-      `[AVM] ${address.toString()}:${selector} returned, reverted: ${avmResult.reverted}, reason: ${
-        avmResult.revertReason
+      `[AVM] ${fnName} returned, reverted: ${avmResult.reverted}${
+        avmResult.reverted ? ', reason: ' + avmResult.revertReason : ''
       }.`,
+      {
+        eventName: 'avm-simulation',
+        appCircuitName: fnName,
+        duration: timer.ms(),
+        bytecodeSize: bytecode!.length,
+      } satisfies AvmSimulationStats,
     );
 
-    const executionResult = convertAvmResultsToPxResult(
+    const publicExecutionResult = trace.toPublicExecutionResult(
+      avmExecutionEnv,
+      /*startGasLeft=*/ availableGas,
+      /*endGasLeft=*/ Gas.from(avmContext.machineState.gasLeft),
+      bytecode,
       avmResult,
-      startSideEffectCounter,
-      execution,
-      startGas,
-      avmContext,
-      simulator.getBytecode(),
+      fnName,
+      /*requestSideEffectCounter=*/ executionRequest.callContext.sideEffectCounter,
+      // NOTE: startSideEffectCounter is not the same as the executionRequest's sideEffectCounter
+      // (which counts the request itself)
     );
 
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5818): is this really needed?
     // should already be handled in simulation.
-    if (execution.callContext.isStaticCall) {
+    if (executionRequest.callContext.isStaticCall) {
       checkValidStaticCall(
-        executionResult.newNoteHashes,
-        executionResult.newNullifiers,
-        executionResult.contractStorageUpdateRequests,
-        executionResult.newL2ToL1Messages,
-        executionResult.unencryptedLogs,
+        publicExecutionResult.newNoteHashes,
+        publicExecutionResult.newNullifiers,
+        publicExecutionResult.contractStorageUpdateRequests,
+        publicExecutionResult.newL2ToL1Messages,
+        publicExecutionResult.unencryptedLogs,
       );
     }
 
-    return executionResult;
+    return publicExecutionResult;
   }
 }