@aztec/simulator 0.43.0 → 0.44.0

package/src/avm/opcodes/external_calls.ts

@@ -1,7 +1,6 @@
 import { FunctionSelector, Gas } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
-import { convertAvmResultsToPxResult, createPublicExecution } from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
 import { gasLeftToGas } from '../avm_gas.js';
 import { Field, TypeTag, Uint8 } from '../avm_memory_types.js';
@@ -24,7 +23,6 @@ abstract class ExternalCall extends Instruction {
     OperandType.UINT32,
     OperandType.UINT32,
     OperandType.UINT32,
-    /* temporary function selector */
     OperandType.UINT32,
   ];
 
@@ -37,8 +35,8 @@ abstract class ExternalCall extends Instruction {
     private retOffset: number,
     private retSize: number,
     private successOffset: number,
-    // Function selector is temporary since eventually public contract bytecode will be one blob
-    // containing all functions, and function selector will become an application-level mechanism
+    // NOTE: Function selector is likely temporary since eventually public contract bytecode will be one
+    // blob containing all functions, and function selector will become an application-level mechanism
     // (e.g. first few bytes of calldata + compiler-generated jump table)
     private functionSelectorOffset: number,
   ) {
@@ -81,7 +79,6 @@ abstract class ExternalCall extends Instruction {
     const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
     context.machineState.consumeGas(allocatedGas);
 
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
@@ -89,32 +86,9 @@ abstract class ExternalCall extends Instruction {
       callType,
       FunctionSelector.fromField(functionSelector),
     );
-    const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
 
-    const oldStyleExecution = createPublicExecution(startSideEffectCounter, nestedContext.environment, calldata);
     const simulator = new AvmSimulator(nestedContext);
     const nestedCallResults: AvmContractCallResults = await simulator.execute();
-    const pxResults = convertAvmResultsToPxResult(
-      nestedCallResults,
-      startSideEffectCounter,
-      oldStyleExecution,
-      Gas.from(allocatedGas),
-      nestedContext,
-      simulator.getBytecode(),
-    );
-    // store the old PublicExecutionResult object to maintain a recursive data structure for the old kernel
-    context.persistableState.transitionalExecutionResult.nestedExecutions.push(pxResults);
-    // END TRANSITIONAL
-
-    // const nestedContext = context.createNestedContractCallContext(
-    //   callAddress.toFr(),
-    //   calldata,
-    //   allocatedGas,
-    //   this.type,
-    //   FunctionSelector.fromField(functionSelector),
-    // );
-    // const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
-
     const success = !nestedCallResults.reverted;
 
     // TRANSITIONAL: We rethrow here so that the MESSAGE gets propagated.
@@ -143,12 +117,16 @@ abstract class ExternalCall extends Instruction {
     // Refund unused gas
     context.machineState.refundGas(gasLeftToGas(nestedContext.machineState));
 
-    // TODO: Should we merge the changes from a nested call in the case of a STATIC call?
-    if (success) {
-      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
-    } else {
-      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
-    }
+    // Accept the nested call's state and trace the nested call
+    await context.persistableState.processNestedCall(
+      /*nestedState=*/ nestedContext.persistableState,
+      /*success=*/ success,
+      /*nestedEnvironment=*/ nestedContext.environment,
+      /*startGasLeft=*/ Gas.from(allocatedGas),
+      /*endGasLeft=*/ Gas.from(nestedContext.machineState.gasLeft),
+      /*bytecode=*/ simulator.getBytecode()!,
+      /*avmCallResults=*/ nestedCallResults,
+    );
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

package/src/avm/test_utils.ts

@@ -0,0 +1,53 @@
+import { Fr } from '@aztec/circuits.js';
+import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { type jest } from '@jest/globals';
+import { mock } from 'jest-mock-extended';
+
+import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from '../public/db_interfaces.js';
+import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace_interface.js';
+import { type HostStorage } from './journal/host_storage.js';
+
+export function mockGetBytecode(hs: HostStorage, bytecode: Buffer) {
+  (hs as jest.Mocked<HostStorage>).contractsDb.getBytecode.mockResolvedValue(bytecode);
+}
+
+export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {
+  (trace as jest.Mocked<PublicSideEffectTraceInterface>).fork.mockReturnValue(
+    nestedTrace ?? mock<PublicSideEffectTraceInterface>(),
+  );
+}
+
+export function mockStorageRead(hs: HostStorage, value: Fr) {
+  (hs.publicStateDb as jest.Mocked<PublicStateDB>).storageRead.mockResolvedValue(value);
+}
+
+export function mockStorageReadWithMap(hs: HostStorage, mockedStorage: Map<bigint, Fr>) {
+  (hs.publicStateDb as jest.Mocked<PublicStateDB>).storageRead.mockImplementation((_address, slot) =>
+    Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),
+  );
+}
+
+export function mockNoteHashExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getCommitmentIndex.mockResolvedValue(leafIndex.toBigInt());
+}
+
+export function mockNullifierExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+}
+
+export function mockL1ToL2MessageExists(hs: HostStorage, leafIndex: Fr, value: Fr, valueAtOtherIndices?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
+    if (index == leafIndex.toBigInt()) {
+      return Promise.resolve(value);
+    } else {
+      // any indices other than mockAtLeafIndex will return a different value
+      // (or undefined if no value is specified for other indices)
+      return Promise.resolve(valueAtOtherIndices!);
+    }
+  });
+}
+
+export function mockGetContractInstance(hs: HostStorage, contractInstance: ContractInstanceWithAddress) {
+  (hs.contractsDb as jest.Mocked<PublicContractsDB>).getContractInstance.mockResolvedValue(contractInstance);
+}

package/src/client/client_execution_context.ts

@@ -22,7 +22,13 @@ import {
 } from '@aztec/circuits.js';
 import { Aes128 } from '@aztec/circuits.js/barretenberg';
 import { computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
-import { type FunctionAbi, type FunctionArtifact, countArgumentsSize } from '@aztec/foundation/abi';
+import {
+  EventSelector,
+  type FunctionAbi,
+  type FunctionArtifact,
+  type NoteSelector,
+  countArgumentsSize,
+} from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { pedersenHash } from '@aztec/foundation/crypto';
 import { Fr, GrumpkinScalar, type Point } from '@aztec/foundation/fields';
@@ -288,7 +294,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   public override notifyCreatedNote(
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
     noteItems: Fr[],
     innerNoteHash: Fr,
     counter: number,
@@ -382,7 +388,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     preimage: Fr[],
   ) {
     const event = new Event(preimage);
-    const l1EventPayload = new L1EventPayload(event, contractAddress, randomness, eventTypeId);
+    const l1EventPayload = new L1EventPayload(event, contractAddress, randomness, EventSelector.fromField(eventTypeId));
     const taggedEvent = new TaggedLog(l1EventPayload);
 
     const ephSk = GrumpkinScalar.random();
@@ -404,7 +410,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   public override computeEncryptedNoteLog(
     contractAddress: AztecAddress,
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
     ovKeys: KeyValidationRequest,
     ivpkM: Point,
     preimage: Fr[],

package/src/client/execution_note_cache.ts

@@ -63,7 +63,6 @@ export class ExecutionNoteCache {
       nullifiedNoteHashCounter = note.counter;
       this.newNotes.set(contractAddress.toBigInt(), notes);
     }
-
     return nullifiedNoteHashCounter;
   }
 

package/src/client/execution_result.ts

@@ -8,6 +8,7 @@ import {
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import { type IsEmpty, type PrivateCallStackItem, PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
+import { type NoteSelector } from '@aztec/foundation/abi';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm/index.js';
@@ -21,7 +22,7 @@ export interface NoteAndSlot {
   /** The storage slot of the note. */
   storageSlot: Fr;
   /** The note type identifier. */
-  noteTypeId: Fr;
+  noteTypeId: NoteSelector;
 }
 
 export class CountedLog<TLog extends UnencryptedL2Log | EncryptedL2NoteLog | EncryptedL2Log> implements IsEmpty {

package/src/client/index.ts

@@ -1,3 +1,5 @@
 export * from './simulator.js';
 export * from './db_oracle.js';
 export * from './execution_result.js';
+export * from './pick_notes.js';
+export * from './execution_note_cache.js';

package/src/client/simulator.ts

@@ -5,6 +5,7 @@ import {
   type FunctionArtifact,
   FunctionSelector,
   FunctionType,
+  type NoteSelector,
   encodeArguments,
 } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
@@ -140,7 +141,7 @@ export class AcirSimulator {
     contractAddress: AztecAddress,
     nonce: Fr,
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
     computeNullifier: boolean,
     note: Note,
   ) {
@@ -210,7 +211,12 @@ export class AcirSimulator {
    * @param note - The note.
    * @returns The note hash.
    */
-  public async computeInnerNoteHash(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: Fr, note: Note) {
+  public async computeInnerNoteHash(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    noteTypeId: NoteSelector,
+    note: Note,
+  ) {
     const { innerNoteHash } = await this.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       Fr.ZERO,

package/src/client/view_data_oracle.ts

@@ -42,6 +42,14 @@ export class ViewDataOracle extends TypedOracle {
     return Promise.resolve(this.contractAddress);
   }
 
+  public override getChainId(): Promise<Fr> {
+    return Promise.resolve(this.aztecNode.getChainId().then(id => new Fr(id)));
+  }
+
+  public override getVersion(): Promise<Fr> {
+    return Promise.resolve(this.aztecNode.getVersion().then(v => new Fr(v)));
+  }
+
   /**
    * Retrieve keys associated with a specific master public key and app address.
    * @param pkMHash - The master public key hash.

package/src/mocks/fixtures.ts

@@ -143,7 +143,8 @@ export class PublicExecutionResultBuilder {
       endGasLeft: Gas.test(),
       transactionFee: Fr.ZERO,
       calldata: [],
-      avmHints: AvmExecutionHints.empty(),
+      avmCircuitHints: AvmExecutionHints.empty(),
+      functionName: 'unknown',
       ...overrides,
     };
   }

package/src/public/abstract_phase_manager.ts

@@ -77,6 +77,7 @@ export const PhaseIsRevertible: Record<PublicKernelType, boolean> = {
 };
 
 export type PublicProvingInformation = {
+  functionName: string; // informational only
   calldata: Fr[];
   bytecode: Buffer;
   inputs: PublicKernelCircuitPrivateInputs;
@@ -89,6 +90,7 @@ export function makeAvmProvingRequest(
 ): AvmProvingRequest {
   return {
     type: AVM_REQUEST,
+    functionName: info.functionName,
     bytecode: info.bytecode,
     calldata: info.calldata,
     avmHints: info.avmHints,
@@ -264,13 +266,15 @@ export abstract class AbstractPhaseManager {
         const isExecutionRequest = !isPublicExecutionResult(current);
         const result = isExecutionRequest
           ? await this.publicExecutor.simulate(
-              current,
+              /*executionRequest=*/ current,
               this.globalVariables,
               /*availableGas=*/ this.getAvailableGas(tx, kernelPublicOutput),
               tx.data.constants.txContext,
               /*pendingNullifiers=*/ this.getSiloedPendingNullifiers(kernelPublicOutput),
               transactionFee,
               /*startSideEffectCounter=*/ AbstractPhaseManager.getMaxSideEffectCounter(kernelPublicOutput) + 1,
+              // NOTE: startSideEffectCounter is not the same as the executionRequest's sideEffectCounter
+              // (which counts the request itself)
             )
           : current;
 
@@ -282,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;
         }
@@ -302,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);
@@ -310,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);
 
@@ -322,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.`,
           );
         }
 
@@ -330,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 {

package/src/public/app_logic_phase_manager.ts

@@ -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/execution.ts

@@ -20,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. */
@@ -40,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.
@@ -61,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;
 }
 
 /**

package/src/public/executor.ts

@@ -1,5 +1,5 @@
 import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
-import { Fr, type Gas, type GlobalVariables, type Header, type Nullifier, type TxContext } from '@aztec/circuits.js';
+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';
 
@@ -10,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.
@@ -27,54 +28,57 @@ 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,
     startSideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
-    const address = execution.contractAddress;
-    const selector = execution.functionSelector;
-    const startGas = availableGas;
-    const fnName = await this.contractsDb.getDebugFunctionName(address, selector);
+    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 ${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 worldStateJournal = new AvmPersistableStateManager(hostStorage);
-    for (const nullifier of pendingNullifiers) {
-      worldStateJournal.nullifiers.cache.appendSiloed(nullifier.value);
-    }
-    worldStateJournal.trace.accessCounter = startSideEffectCounter;
-
-    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();
+    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(
@@ -83,33 +87,36 @@ export class PublicExecutor {
       }.`,
       {
         eventName: 'avm-simulation',
-        appCircuitName: fnName ?? 'unknown',
+        appCircuitName: fnName,
         duration: timer.ms(),
         bytecodeSize: bytecode!.length,
       } satisfies AvmSimulationStats,
     );
 
-    const executionResult = convertAvmResultsToPxResult(
-      avmResult,
-      startSideEffectCounter,
-      execution,
-      startGas,
-      avmContext,
+    const publicExecutionResult = trace.toPublicExecutionResult(
+      avmExecutionEnv,
+      /*startGasLeft=*/ availableGas,
+      /*endGasLeft=*/ Gas.from(avmContext.machineState.gasLeft),
       bytecode,
+      avmResult,
+      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;
   }
 }