@aztec/simulator 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/public/public_tx_simulator/measured_public_tx_simulator.ts

@@ -0,0 +1,106 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { Timer } from '@aztec/foundation/timer';
+import type { Gas } from '@aztec/stdlib/gas';
+import type { AvmSimulationStats } from '@aztec/stdlib/stats';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { type GlobalVariables, PublicCallRequestWithCalldata, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+
+import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
+import type { PublicContractsDB } from '../public_db_sources.js';
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
+import { PublicTxContext } from './public_tx_context.js';
+import { type ProcessedPhase, type PublicTxResult, PublicTxSimulator } from './public_tx_simulator.js';
+
+/**
+ * A public tx simulator that tracks miscellaneous simulation metrics without telemetry.
+ */
+export class MeasuredPublicTxSimulator extends PublicTxSimulator {
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    doMerkleOperations: boolean = false,
+    skipFeeEnforcement: boolean = false,
+    clientInitiatedSimulation: boolean = false,
+    protected readonly metrics: ExecutorMetricsInterface,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement, clientInitiatedSimulation);
+  }
+
+  public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
+    this.metrics.startRecordingTxSimulation(txLabel);
+    let avmResult: PublicTxResult | undefined;
+    try {
+      avmResult = await super.simulate(tx);
+    } finally {
+      this.metrics.stopRecordingTxSimulation(txLabel, avmResult?.revertCode);
+    }
+    return avmResult;
+  }
+
+  protected override async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
+    const timer = new Timer();
+    await super.insertNonRevertiblesFromPrivate(context, tx);
+    this.metrics.recordPrivateEffectsInsertion(timer.us(), 'non-revertible');
+  }
+
+  protected override async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<boolean> {
+    const timer = new Timer();
+    const result = await super.insertRevertiblesFromPrivate(context, tx);
+    this.metrics.recordPrivateEffectsInsertion(timer.us(), 'revertible');
+    return result;
+  }
+
+  protected override async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
+    const timer = new Timer();
+    const result = await super.simulatePhase(phase, context);
+    result.durationMs = timer.ms();
+    return result;
+  }
+
+  protected override async simulateEnqueuedCallInternal(
+    stateManager: PublicPersistableStateManager,
+    callRequest: PublicCallRequestWithCalldata,
+    allocatedGas: Gas,
+    transactionFee: Fr,
+    fnName: string,
+  ): Promise<AvmFinalizedCallResult> {
+    const timer = new Timer();
+    const result = await super.simulateEnqueuedCallInternal(
+      stateManager,
+      callRequest,
+      allocatedGas,
+      transactionFee,
+      fnName,
+    );
+
+    this.log.verbose(
+      result.reverted
+        ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason?.message}.`
+        : `Simulation of enqueued public call ${fnName} completed successfully.`,
+      {
+        eventName: 'avm-simulation',
+        appCircuitName: fnName,
+        duration: timer.ms(),
+      } satisfies AvmSimulationStats,
+    );
+
+    if (result.reverted) {
+      this.metrics.recordEnqueuedCallSimulationFailure(
+        fnName,
+        timer.ms(),
+        allocatedGas.sub(result.gasLeft).l2Gas,
+        result.totalInstructions,
+      );
+    } else {
+      this.metrics.recordEnqueuedCallSimulation(
+        fnName,
+        timer.ms(),
+        allocatedGas.sub(result.gasLeft).l2Gas,
+        result.totalInstructions,
+      );
+    }
+    return result;
+  }
+}

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -1,41 +1,39 @@
 import {
-  MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  MAX_ENQUEUED_CALLS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  NULLIFIER_SUBTREE_HEIGHT,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { assertLength } from '@aztec/foundation/serialize';
 import {
-  AvmCircuitInputs,
-  type AvmCircuitPublicInputs,
-  type AvmProvingRequest,
+  AvmAccumulatedData,
+  AvmAccumulatedDataArrayLengths,
+  AvmCircuitPublicInputs,
   PublicDataWrite,
   RevertCode,
 } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { SimulationError } from '@aztec/stdlib/errors';
-import { computeTransactionFee } from '@aztec/stdlib/fees';
+import { computeEffectiveGasFees, computeTransactionFee } from '@aztec/stdlib/fees';
 import { Gas, GasSettings } from '@aztec/stdlib/gas';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
 import {
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
-  type PrivateToPublicAccumulatedData,
+  PrivateToPublicAccumulatedData,
   PublicCallRequest,
+  PublicCallRequestArrayLengths,
   countAccumulatedItems,
-  mergeAccumulatedData,
 } from '@aztec/stdlib/kernel';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { PublicLog } from '@aztec/stdlib/logs';
+import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type GlobalVariables,
-  type PublicExecutionRequest,
-  type StateReference,
+  PublicCallRequestWithCalldata,
   TreeSnapshots,
   type Tx,
   TxExecutionPhase,
@@ -45,10 +43,11 @@ import {
 import { strict as assert } from 'assert';
 import { inspect } from 'util';
 
-import { AvmPersistableStateManager } from '../avm/index.js';
-import type { WorldStateDB } from '../public_db_sources.js';
-import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
-import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js';
+import type { PublicContractsDBInterface } from '../db_interfaces.js';
+import type { PublicTreesDB } from '../public_db_sources.js';
+import { SideEffectTrace } from '../side_effect_trace.js';
+import { PublicPersistableStateManager } from '../state_manager/state_manager.js';
+import { getCallRequestsWithCalldataByPhase } from '../utils.js';
 
 /**
  * The transaction-level context for public execution.
@@ -67,75 +66,66 @@ export class PublicTxContext {
   private revertCode: RevertCode = RevertCode.OK;
   /* What caused a revert (if one occurred)? */
   public revertReason: SimulationError | undefined;
-
-  public avmProvingRequest: AvmProvingRequest | undefined; // FIXME(dbanks12): remove
-
-  constructor(
+  private constructor(
     public readonly txHash: TxHash,
     public readonly state: PhaseStateManager,
+    private readonly startTreeSnapshots: TreeSnapshots,
     private readonly globalVariables: GlobalVariables,
-    private readonly startStateReference: StateReference,
     private readonly gasSettings: GasSettings,
     private readonly gasUsedByPrivate: Gas,
     private readonly gasAllocatedToPublic: Gas,
-    private readonly setupCallRequests: PublicCallRequest[],
-    private readonly appLogicCallRequests: PublicCallRequest[],
-    private readonly teardownCallRequests: PublicCallRequest[],
-    private readonly setupExecutionRequests: PublicExecutionRequest[],
-    private readonly appLogicExecutionRequests: PublicExecutionRequest[],
-    private readonly teardownExecutionRequests: PublicExecutionRequest[],
+    private readonly gasAllocatedToPublicTeardown: Gas,
+    private readonly setupCallRequests: PublicCallRequestWithCalldata[],
+    private readonly appLogicCallRequests: PublicCallRequestWithCalldata[],
+    private readonly teardownCallRequests: PublicCallRequestWithCalldata[],
     public readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly feePayer: AztecAddress,
-    public trace: SideEffectTrace, // FIXME(dbanks12): should be private
+    private readonly trace: SideEffectTrace,
   ) {
     this.log = createLogger(`simulator:public_tx_context`);
   }
 
   public static async create(
-    db: MerkleTreeReadOperations,
-    worldStateDB: WorldStateDB,
+    treesDB: PublicTreesDB,
+    contractsDB: PublicContractsDBInterface,
     tx: Tx,
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
   ) {
     const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic!.nonRevertibleAccumulatedData;
 
-    const previousAccumulatedDataArrayLengths = new SideEffectArrayLengths(
-      /*publicDataWrites*/ 0,
-      /*protocolPublicDataWrites*/ 0,
-      /*noteHashes*/ 0,
-      /*nullifiers=*/ 0,
-      countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs),
-      /*publicLogs*/ 0,
-    );
-
-    const trace = new SideEffectTrace(/*startSideEffectCounter=*/ 0, previousAccumulatedDataArrayLengths);
+    const trace = new SideEffectTrace();
 
     const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
 
     // Transaction level state manager that will be forked for revertible phases.
-    const txStateManager = AvmPersistableStateManager.create(worldStateDB, trace, doMerkleOperations, firstNullifier);
+    const txStateManager = PublicPersistableStateManager.create(
+      treesDB,
+      contractsDB,
+      trace,
+      doMerkleOperations,
+      firstNullifier,
+      globalVariables.timestamp,
+    );
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
     const gasUsedByPrivate = tx.data.gasUsed;
-    // Gas allocated to public is "whatever's left" after private, but with some max applied.
-    const gasAllocatedToPublic = applyMaxToAvailableGas(gasSettings.gasLimits.sub(gasUsedByPrivate));
+    const gasAllocatedToPublic = gasSettings.gasLimits.sub(gasUsedByPrivate);
+    const gasAllocatedToPublicTeardown = gasSettings.teardownGasLimits;
 
     return new PublicTxContext(
-      await tx.getTxHash(),
+      tx.getTxHash(),
       new PhaseStateManager(txStateManager),
+      await txStateManager.getTreeSnapshots(),
       globalVariables,
-      await db.getStateReference(),
       gasSettings,
       gasUsedByPrivate,
       gasAllocatedToPublic,
-      getCallRequestsByPhase(tx, TxExecutionPhase.SETUP),
-      getCallRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC),
-      getCallRequestsByPhase(tx, TxExecutionPhase.TEARDOWN),
-      getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP),
-      getExecutionRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC),
-      getExecutionRequestsByPhase(tx, TxExecutionPhase.TEARDOWN),
+      gasAllocatedToPublicTeardown,
+      getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP),
+      getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.APP_LOGIC),
+      getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.TEARDOWN),
       tx.data.forPublic!.nonRevertibleAccumulatedData,
       tx.data.forPublic!.revertibleAccumulatedData,
       tx.data.feePayer,
@@ -148,10 +138,8 @@ export class PublicTxContext {
    * All phases have been processed.
    * Actual transaction fee and actual total consumed gas can now be queried.
    */
-  async halt() {
-    if (this.state.isForked()) {
-      await this.state.mergeForkedState();
-    }
+  halt() {
+    assert(!this.state.isForked(), 'Cannot halt when state is forked');
     this.halted = true;
   }
 
@@ -161,7 +149,7 @@ export class PublicTxContext {
    * NOTE: this does not "halt" the entire transaction execution.
    */
   revert(phase: TxExecutionPhase, revertReason: SimulationError | undefined = undefined, culprit = '') {
-    this.log.warn(`${TxExecutionPhase[phase]} phase reverted! ${culprit} failed with reason: ${revertReason}`);
+    this.log.warn(`${TxExecutionPhase[phase]} phase reverted! ${culprit} failed with reason: ${revertReason?.message}`);
 
     if (revertReason && !this.revertReason) {
       // don't override revertReason
@@ -170,11 +158,6 @@ export class PublicTxContext {
     }
     if (phase === TxExecutionPhase.SETUP) {
       this.log.warn(`Setup phase reverted! The transaction will be thrown out.`);
-      if (revertReason) {
-        throw revertReason;
-      } else {
-        throw new Error(`Setup phase reverted! The transaction will be thrown out. ${culprit} failed`);
-      }
     } else if (phase === TxExecutionPhase.APP_LOGIC) {
       this.revertCode = RevertCode.APP_LOGIC_REVERTED;
     } else if (phase === TxExecutionPhase.TEARDOWN) {
@@ -212,7 +195,7 @@ export class PublicTxContext {
   /**
    * Get the call requests for the specified phase (including args hashes).
    */
-  getCallRequestsForPhase(phase: TxExecutionPhase): PublicCallRequest[] {
+  getCallRequestsForPhase(phase: TxExecutionPhase): PublicCallRequestWithCalldata[] {
     switch (phase) {
       case TxExecutionPhase.SETUP:
         return this.setupCallRequests;
@@ -223,26 +206,13 @@ export class PublicTxContext {
     }
   }
 
-  /**
-   * Get the call requests for the specified phase (including actual args).
-   */
-  getExecutionRequestsForPhase(phase: TxExecutionPhase): PublicExecutionRequest[] {
-    switch (phase) {
-      case TxExecutionPhase.SETUP:
-        return this.setupExecutionRequests;
-      case TxExecutionPhase.APP_LOGIC:
-        return this.appLogicExecutionRequests;
-      case TxExecutionPhase.TEARDOWN:
-        return this.teardownExecutionRequests;
-    }
-  }
-
   /**
    * How much gas is left as of the specified phase?
    */
   getGasLeftAtPhase(phase: TxExecutionPhase): Gas {
     if (phase === TxExecutionPhase.TEARDOWN) {
-      return applyMaxToAvailableGas(this.gasSettings.teardownGasLimits);
+      const gasLeftForPublicTeardown = this.gasAllocatedToPublicTeardown.sub(this.teardownGasUsed);
+      return gasLeftForPublicTeardown;
     } else {
       const gasLeftForPublic = this.gasAllocatedToPublic.sub(this.gasUsedByPublic);
       return gasLeftForPublic;
@@ -322,124 +292,124 @@ export class PublicTxContext {
   /**
    * Generate the public inputs for the AVM circuit.
    */
-  private async generateAvmCircuitPublicInputs(endStateReference: StateReference): Promise<AvmCircuitPublicInputs> {
+  public async generateAvmCircuitPublicInputs(): Promise<AvmCircuitPublicInputs> {
     assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
     const stateManager = this.state.getActiveStateManager();
 
-    const startTreeSnapshots = new TreeSnapshots(
-      this.startStateReference.l1ToL2MessageTree,
-      this.startStateReference.partial.noteHashTree,
-      this.startStateReference.partial.nullifierTree,
-      this.startStateReference.partial.publicDataTree,
+    // We get the side effects from the AVM.
+    // The AVM will already have handled the conditional insertion of most private side-effects.
+    // (depending on the revert code of each stage). Only l2ToL1Msgs and publicLogs still need to be "merged".
+    const {
+      publicDataWrites: avmPublicDataWrites,
+      noteHashes: avmNoteHashes,
+      nullifiers: avmNullifiers,
+      l2ToL1Msgs: avmL2ToL1Msgs,
+      publicLogs: avmPublicLogs,
+    } = this.trace.getSideEffects();
+
+    // Private generates PrivateLogs, and public execution generates PublicLogs.
+    // Since these are two different categories, they should not be merged.
+    const finalPublicLogs = avmPublicLogs;
+
+    // We squash public data writes.
+    // Maps slot to value. Maps in TS are iterable in insertion order, which is exactly what we want for
+    // squashing "to the left", where the first occurrence of a slot uses the value of the last write to it,
+    // and the rest occurrences are omitted.
+    // Note: you can't write public state from private, so we only squash what we got from the AVM.
+    const finalPublicDataWrites = (() => {
+      const squashedPublicDataWrites: Map<bigint, Fr> = new Map();
+      for (const publicDataWrite of avmPublicDataWrites) {
+        squashedPublicDataWrites.set(publicDataWrite.leafSlot.toBigInt(), publicDataWrite.newValue);
+      }
+      return Array.from(squashedPublicDataWrites.entries()).map(
+        ([slot, value]) => new PublicDataWrite(new Fr(slot), value),
+      );
+    })();
+
+    // Count before padding.
+    const accumulatedDataArrayLengths = new AvmAccumulatedDataArrayLengths(
+      avmNoteHashes.length,
+      avmNullifiers.length,
+      avmL2ToL1Msgs.length,
+      finalPublicLogs.length,
+      finalPublicDataWrites.length,
     );
 
-    // Will be patched/padded at the end of this fn
-    const endTreeSnapshots = new TreeSnapshots(
-      endStateReference.l1ToL2MessageTree,
-      endStateReference.partial.noteHashTree,
-      endStateReference.partial.nullifierTree,
-      endStateReference.partial.publicDataTree,
+    const accumulatedData = new AvmAccumulatedData(
+      /*noteHashes=*/ padArrayEnd(
+        avmNoteHashes.map(n => n.value),
+        Fr.zero(),
+        MAX_NOTE_HASHES_PER_TX,
+      ),
+      /*nullifiers=*/ padArrayEnd(
+        avmNullifiers.map(n => n.value),
+        Fr.zero(),
+        MAX_NULLIFIERS_PER_TX,
+      ),
+      /*l2ToL1Msgs=*/ padArrayEnd(avmL2ToL1Msgs, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
+      /*publicLogs=*/ padArrayEnd(finalPublicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_TX),
+      /*publicDataWrites=*/ padArrayEnd(
+        finalPublicDataWrites,
+        PublicDataWrite.empty(),
+        MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+      ),
     );
 
-    const avmCircuitPublicInputs = this.trace.toAvmCircuitPublicInputs(
-      this.globalVariables,
-      startTreeSnapshots,
-      /*startGasUsed=*/ this.gasUsedByPrivate,
-      this.gasSettings,
-      this.feePayer,
-      this.setupCallRequests,
-      this.appLogicCallRequests,
-      /*teardownCallRequest=*/ this.teardownCallRequests.length
-        ? this.teardownCallRequests[0]
-        : PublicCallRequest.empty(),
-      endTreeSnapshots,
-      /*endGasUsed=*/ this.getTotalGasUsed(),
-      /*transactionFee=*/ this.getTransactionFeeUnsafe(),
-      /*reverted=*/ !this.revertCode.isOK(),
-    );
+    // Now we finally have enough information to pad the trees.
+    // NOTE(fcarreiro): a bit weird that a method that generates the PIs does this,
+    // but we do need the end tree snapshots. We can consider moving things to the caller.
+    const numNoteHashesToPad = MAX_NOTE_HASHES_PER_TX - avmNoteHashes.length;
+    const numNullifiersToPad = MAX_NULLIFIERS_PER_TX - avmNullifiers.length;
+    await stateManager.padTree(MerkleTreeId.NOTE_HASH_TREE, numNoteHashesToPad);
+    await stateManager.padTree(MerkleTreeId.NULLIFIER_TREE, numNullifiersToPad);
+    const endTreeSnapshots = await stateManager.getTreeSnapshots();
 
-    const getArrayLengths = (from: PrivateToPublicAccumulatedData) =>
+    // This converts the private accumulated data to the avm accumulated data format.
+    const convertAccumulatedData = (from: PrivateToPublicAccumulatedData) =>
+      new PrivateToAvmAccumulatedData(from.noteHashes, from.nullifiers, from.l2ToL1Msgs);
+    const getPreviousAccumulatedDataArrayLengths = (from: PrivateToPublicAccumulatedData) =>
       new PrivateToAvmAccumulatedDataArrayLengths(
         countAccumulatedItems(from.noteHashes),
         countAccumulatedItems(from.nullifiers),
         countAccumulatedItems(from.l2ToL1Msgs),
       );
-    const convertAccumulatedData = (from: PrivateToPublicAccumulatedData) =>
-      new PrivateToAvmAccumulatedData(from.noteHashes, from.nullifiers, from.l2ToL1Msgs);
-    // Temporary overrides as these entries aren't yet populated in trace
-    avmCircuitPublicInputs.previousNonRevertibleAccumulatedDataArrayLengths = getArrayLengths(
-      this.nonRevertibleAccumulatedDataFromPrivate,
-    );
-    avmCircuitPublicInputs.previousRevertibleAccumulatedDataArrayLengths = getArrayLengths(
-      this.revertibleAccumulatedDataFromPrivate,
-    );
-    avmCircuitPublicInputs.previousNonRevertibleAccumulatedData = convertAccumulatedData(
-      this.nonRevertibleAccumulatedDataFromPrivate,
-    );
-    avmCircuitPublicInputs.previousRevertibleAccumulatedData = convertAccumulatedData(
-      this.revertibleAccumulatedDataFromPrivate,
-    );
-
-    const msgsFromPrivate = this.revertCode.isOK()
-      ? mergeAccumulatedData(
-          avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs,
-          avmCircuitPublicInputs.previousRevertibleAccumulatedData.l2ToL1Msgs,
-        )
-      : avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs;
-    avmCircuitPublicInputs.accumulatedData.l2ToL1Msgs = assertLength(
-      mergeAccumulatedData(msgsFromPrivate, avmCircuitPublicInputs.accumulatedData.l2ToL1Msgs),
-      MAX_L2_TO_L1_MSGS_PER_TX,
-    );
-
-    // Maps slot to value. Maps in TS are iterable in insertion order, which is exactly what we want for
-    // squashing "to the left", where the first occurrence of a slot uses the value of the last write to it,
-    // and the rest occurrences are omitted
-    const squashedPublicDataWrites: Map<bigint, Fr> = new Map();
-    for (const publicDataWrite of avmCircuitPublicInputs.accumulatedData.publicDataWrites) {
-      squashedPublicDataWrites.set(publicDataWrite.leafSlot.toBigInt(), publicDataWrite.value);
-    }
 
-    avmCircuitPublicInputs.accumulatedData.publicDataWrites = padArrayEnd(
-      Array.from(squashedPublicDataWrites.entries()).map(([slot, value]) => new PublicDataWrite(new Fr(slot), value)),
-      PublicDataWrite.empty(),
-      MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-    );
-    const numNoteHashesToPad =
-      MAX_NOTE_HASHES_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.noteHashes);
-    await stateManager.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd([], Fr.ZERO, numNoteHashesToPad));
-    const numNullifiersToPad =
-      MAX_NULLIFIERS_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.nullifiers);
-    await stateManager.db.batchInsert(
-      MerkleTreeId.NULLIFIER_TREE,
-      padArrayEnd([], Fr.ZERO, numNullifiersToPad).map(nullifier => nullifier.toBuffer()),
-      NULLIFIER_SUBTREE_HEIGHT,
-    );
-
-    const paddedState = await stateManager.db.getStateReference();
-    avmCircuitPublicInputs.endTreeSnapshots = new TreeSnapshots(
-      paddedState.l1ToL2MessageTree,
-      paddedState.partial.noteHashTree,
-      paddedState.partial.nullifierTree,
-      paddedState.partial.publicDataTree,
-    );
-
-    return avmCircuitPublicInputs;
-  }
-
-  /**
-   * Generate the proving request for the AVM circuit.
-   */
-  async generateProvingRequest(endStateReference: StateReference): Promise<AvmProvingRequest> {
-    const hints = this.trace.getAvmCircuitHints();
-    return {
-      type: ProvingRequestType.PUBLIC_VM,
-      inputs: new AvmCircuitInputs(
-        'public_dispatch',
-        [],
-        hints,
-        await this.generateAvmCircuitPublicInputs(endStateReference),
+    return new AvmCircuitPublicInputs(
+      this.globalVariables,
+      this.startTreeSnapshots,
+      /*startGasUsed=*/ this.gasUsedByPrivate,
+      this.gasSettings,
+      computeEffectiveGasFees(this.globalVariables.gasFees, this.gasSettings),
+      this.feePayer,
+      /*publicCallRequestArrayLengths=*/ new PublicCallRequestArrayLengths(
+        this.setupCallRequests.length,
+        this.appLogicCallRequests.length,
+        this.teardownCallRequests.length > 0,
+      ),
+      /*publicSetupCallRequests=*/ padArrayEnd(
+        this.setupCallRequests.map(r => r.request),
+        PublicCallRequest.empty(),
+        MAX_ENQUEUED_CALLS_PER_TX,
+      ),
+      /*publicAppLogicCallRequests=*/ padArrayEnd(
+        this.appLogicCallRequests.map(r => r.request),
+        PublicCallRequest.empty(),
+        MAX_ENQUEUED_CALLS_PER_TX,
       ),
-    };
+      /*publicTeardownCallRequests=*/ this.teardownCallRequests.length > 0
+        ? this.teardownCallRequests[0].request
+        : PublicCallRequest.empty(),
+      getPreviousAccumulatedDataArrayLengths(this.nonRevertibleAccumulatedDataFromPrivate),
+      getPreviousAccumulatedDataArrayLengths(this.revertibleAccumulatedDataFromPrivate),
+      convertAccumulatedData(this.nonRevertibleAccumulatedDataFromPrivate),
+      convertAccumulatedData(this.revertibleAccumulatedDataFromPrivate),
+      endTreeSnapshots,
+      this.getTotalGasUsed(),
+      accumulatedDataArrayLengths,
+      accumulatedData,
+      /*transactionFee=*/ this.getTransactionFeeUnsafe(),
+      /*isReverted=*/ !this.revertCode.isOK(),
+    );
   }
 }
 
@@ -456,9 +426,9 @@ export class PublicTxContext {
 class PhaseStateManager {
   private log: Logger;
 
-  private currentlyActiveStateManager: AvmPersistableStateManager | undefined;
+  private currentlyActiveStateManager: PublicPersistableStateManager | undefined;
 
-  constructor(private readonly txStateManager: AvmPersistableStateManager) {
+  constructor(private readonly txStateManager: PublicPersistableStateManager) {
     this.log = createLogger(`simulator:public_phase_state_manager`);
   }
 
@@ -492,13 +462,3 @@ class PhaseStateManager {
     this.currentlyActiveStateManager = undefined;
   }
 }
-
-/**
- * Apply L2 gas maximum.
- */
-function applyMaxToAvailableGas(availableGas: Gas) {
-  return new Gas(
-    /*daGas=*/ availableGas.daGas,
-    /*l2Gas=*/ Math.min(availableGas.l2Gas, MAX_L2_GAS_PER_TX_PUBLIC_PORTION),
-  );
-}