@aztec/simulator 0.61.0 → 0.63.0

package/src/public/public_tx_context.ts

@@ -0,0 +1,411 @@
+import {
+  type AvmProvingRequest,
+  type MerkleTreeReadOperations,
+  type PublicExecutionRequest,
+  type SimulationError,
+  type Tx,
+  TxExecutionPhase,
+  TxHash,
+} from '@aztec/circuit-types';
+import {
+  type AvmCircuitPublicInputs,
+  Fr,
+  Gas,
+  type GasSettings,
+  type GlobalVariables,
+  type Header,
+  type PrivateToPublicAccumulatedData,
+  type PublicCallRequest,
+  RevertCode,
+  type StateReference,
+  countAccumulatedItems,
+} from '@aztec/circuits.js';
+import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+
+import { strict as assert } from 'assert';
+import { inspect } from 'util';
+
+import { AvmPersistableStateManager } from '../avm/index.js';
+import { DualSideEffectTrace } from './dual_side_effect_trace.js';
+import { PublicEnqueuedCallSideEffectTrace, SideEffectArrayLengths } from './enqueued_call_side_effect_trace.js';
+import { type EnqueuedPublicCallExecutionResult } from './execution.js';
+import { type WorldStateDB } from './public_db_sources.js';
+import { PublicSideEffectTrace } from './side_effect_trace.js';
+import { generateAvmCircuitPublicInputs, generateAvmProvingRequest } from './transitional_adapters.js';
+import { getCallRequestsByPhase, getExecutionRequestsByPhase } from './utils.js';
+
+/**
+ * The transaction-level context for public execution.
+ */
+export class PublicTxContext {
+  private log: DebugLogger;
+
+  /* Gas used including private, teardown gas _limit_, setup and app logic */
+  private gasUsed: Gas;
+  /* Gas actually used during teardown (different from limit) */
+  public teardownGasUsed: Gas = Gas.empty();
+
+  /* Entire transaction execution is done. */
+  private halted = false;
+  /* Where did reverts happen (if at all)? */
+  private revertCode: RevertCode = RevertCode.OK;
+  /* What caused a revert (if one occurred)? */
+  public revertReason: SimulationError | undefined;
+
+  public avmProvingRequest: AvmProvingRequest | undefined; // FIXME(dbanks12): remove
+
+  constructor(
+    public readonly state: PhaseStateManager,
+    private readonly globalVariables: GlobalVariables,
+    private readonly historicalHeader: Header, // FIXME(dbanks12): remove
+    private readonly startStateReference: StateReference,
+    private readonly startGasUsed: Gas,
+    private readonly gasSettings: GasSettings,
+    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 nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
+    private readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
+    public trace: PublicEnqueuedCallSideEffectTrace, // FIXME(dbanks12): should be private
+  ) {
+    this.log = createDebugLogger(`aztec:public_tx_context`);
+    this.gasUsed = startGasUsed;
+  }
+
+  public static async create(
+    db: MerkleTreeReadOperations,
+    worldStateDB: WorldStateDB,
+    tx: Tx,
+    globalVariables: GlobalVariables,
+  ) {
+    const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic!.nonRevertibleAccumulatedData;
+    const revertibleAccumulatedDataFromPrivate = tx.data.forPublic!.revertibleAccumulatedData;
+    const nonRevertibleNullifiersFromPrivate = nonRevertibleAccumulatedDataFromPrivate.nullifiers.filter(
+      n => !n.isEmpty(),
+    );
+    const _revertibleNullifiersFromPrivate = revertibleAccumulatedDataFromPrivate.nullifiers.filter(n => !n.isEmpty());
+
+    const innerCallTrace = new PublicSideEffectTrace();
+
+    const previousAccumulatedDataArrayLengths = new SideEffectArrayLengths(
+      /*publicDataReads*/ 0,
+      /*publicDataWrites*/ 0,
+      /*noteHashReadRequests*/ 0,
+      countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.noteHashes),
+      /*nullifierReadRequests*/ 0,
+      /*nullifierNonExistentReadRequests*/ 0,
+      countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.nullifiers),
+      /*l1ToL2MsgReadRequests*/ 0,
+      countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs),
+      /*unencryptedLogsHashes*/ 0,
+    );
+    const enqueuedCallTrace = new PublicEnqueuedCallSideEffectTrace(
+      /*startSideEffectCounter=*/ 0,
+      previousAccumulatedDataArrayLengths,
+    );
+    const trace = new DualSideEffectTrace(innerCallTrace, enqueuedCallTrace);
+
+    // Transaction level state manager that will be forked for revertible phases.
+    const txStateManager = AvmPersistableStateManager.newWithPendingSiloedNullifiers(
+      worldStateDB,
+      trace,
+      nonRevertibleNullifiersFromPrivate,
+    );
+
+    return new PublicTxContext(
+      new PhaseStateManager(txStateManager),
+      globalVariables,
+      tx.data.constants.historicalHeader,
+      await db.getStateReference(),
+      tx.data.gasUsed,
+      tx.data.constants.txContext.gasSettings,
+      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),
+      tx.data.forPublic!.nonRevertibleAccumulatedData,
+      tx.data.forPublic!.revertibleAccumulatedData,
+      enqueuedCallTrace,
+    );
+  }
+
+  /**
+   * Signal that the entire transaction execution is done.
+   * All phases have been processed.
+   * Actual transaction fee and actual total consumed gas can now be queried.
+   */
+  halt() {
+    this.halted = true;
+  }
+
+  /**
+   * Revert execution a phase. Populate revertReason & revertCode.
+   * If in setup, throw an error (transaction will be thrown out).
+   * NOTE: this does not "halt" the entire transaction execution.
+   */
+  revert(phase: TxExecutionPhase, revertReason: SimulationError | undefined = undefined, culprit = '') {
+    this.log.debug(`${TxExecutionPhase[phase]} phase reverted! ${culprit} failed with reason: ${revertReason}`);
+
+    if (revertReason && !this.revertReason) {
+      // don't override revertReason
+      // (if app logic and teardown both revert, we want app logic's reason)
+      this.revertReason = revertReason;
+    }
+    if (phase === TxExecutionPhase.SETUP) {
+      this.log.debug(`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) {
+      if (this.revertCode.equals(RevertCode.APP_LOGIC_REVERTED)) {
+        this.revertCode = RevertCode.BOTH_REVERTED;
+      } else {
+        this.revertCode = RevertCode.TEARDOWN_REVERTED;
+      }
+    }
+  }
+
+  /**
+   * Get the revert code.
+   * @returns The revert code.
+   */
+  getFinalRevertCode(): RevertCode {
+    assert(this.halted, 'Cannot know the final revert code until tx execution ends');
+    return this.revertCode;
+  }
+
+  /**
+   * Construct & return transaction hash.
+   * @returns The transaction's hash.
+   */
+  getTxHash(): TxHash {
+    // Private kernel functions are executed client side and for this reason tx hash is already set as first nullifier
+    const firstNullifier = this.nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
+    if (!firstNullifier || firstNullifier.isZero()) {
+      throw new Error(`Cannot get tx hash since first nullifier is missing`);
+    }
+    return new TxHash(firstNullifier.toBuffer());
+  }
+
+  /**
+   * Are there any call requests for the speciiied phase?
+   */
+  hasPhase(phase: TxExecutionPhase): boolean {
+    if (phase === TxExecutionPhase.SETUP) {
+      return this.setupCallRequests.length > 0;
+    } else if (phase === TxExecutionPhase.APP_LOGIC) {
+      return this.appLogicCallRequests.length > 0;
+    } else {
+      // phase === TxExecutionPhase.TEARDOWN
+      return this.teardownCallRequests.length > 0;
+    }
+  }
+
+  /**
+   * Get the call requests for the specified phase (including args hashes).
+   */
+  getCallRequestsForPhase(phase: TxExecutionPhase): PublicCallRequest[] {
+    switch (phase) {
+      case TxExecutionPhase.SETUP:
+        return this.setupCallRequests;
+      case TxExecutionPhase.APP_LOGIC:
+        return this.appLogicCallRequests;
+      case TxExecutionPhase.TEARDOWN:
+        return this.teardownCallRequests;
+    }
+  }
+
+  /**
+   * 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 for the specified phase?
+   */
+  getGasLeftForPhase(phase: TxExecutionPhase): Gas {
+    if (phase === TxExecutionPhase.TEARDOWN) {
+      return this.gasSettings.teardownGasLimits;
+    } else {
+      return this.gasSettings.gasLimits.sub(this.gasUsed);
+    }
+  }
+
+  /**
+   * Consume gas. Track gas for teardown phase separately.
+   */
+  consumeGas(phase: TxExecutionPhase, gas: Gas) {
+    if (phase === TxExecutionPhase.TEARDOWN) {
+      this.teardownGasUsed = this.teardownGasUsed.add(gas);
+    } else {
+      this.gasUsed = this.gasUsed.add(gas);
+    }
+  }
+
+  /**
+   * Compute the gas used using the actual gas used during teardown instead
+   * of the teardown gas limit.
+   * Note that this.gasUsed is initialized from private's gasUsed which includes
+   * teardown gas limit.
+   */
+  getActualGasUsed(): Gas {
+    assert(this.halted, 'Can only compute actual gas used after tx execution ends');
+    const requireTeardown = this.teardownCallRequests.length > 0;
+    const teardownGasLimits = requireTeardown ? this.gasSettings.teardownGasLimits : Gas.empty();
+    return this.gasUsed.sub(teardownGasLimits).add(this.teardownGasUsed);
+  }
+
+  /**
+   * The gasUsed as if the entire teardown gas limit was consumed.
+   */
+  getGasUsedForFee(): Gas {
+    return this.gasUsed;
+  }
+
+  /**
+   * Get the transaction fee as is available to the specified phase.
+   * Only teardown should have access to the actual transaction fee.
+   */
+  getTransactionFee(phase: TxExecutionPhase): Fr {
+    if (phase === TxExecutionPhase.TEARDOWN) {
+      return this.getTransactionFeeUnsafe();
+    } else {
+      return Fr.zero();
+    }
+  }
+
+  /**
+   * Compute the transaction fee.
+   * Should only be called during or after teardown.
+   */
+  private getTransactionFeeUnsafe(): Fr {
+    const txFee = this.gasUsed.computeFee(this.globalVariables.gasFees);
+    this.log.debug(`Computed tx fee`, {
+      txFee,
+      gasUsed: inspect(this.gasUsed),
+      gasFees: inspect(this.globalVariables.gasFees),
+    });
+    return txFee;
+  }
+
+  /**
+   * Generate the public inputs for the AVM circuit.
+   */
+  private generateAvmCircuitPublicInputs(endStateReference: StateReference): AvmCircuitPublicInputs {
+    assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
+    return generateAvmCircuitPublicInputs(
+      this.trace,
+      this.globalVariables,
+      this.startStateReference,
+      this.startGasUsed,
+      this.gasSettings,
+      this.setupCallRequests,
+      this.appLogicCallRequests,
+      this.teardownCallRequests,
+      this.nonRevertibleAccumulatedDataFromPrivate,
+      this.revertibleAccumulatedDataFromPrivate,
+      endStateReference,
+      /*endGasUsed=*/ this.gasUsed,
+      this.getTransactionFeeUnsafe(),
+      this.revertCode,
+    );
+  }
+
+  /**
+   * Generate the proving request for the AVM circuit.
+   */
+  generateProvingRequest(endStateReference: StateReference): AvmProvingRequest {
+    // TODO(dbanks12): Once we actually have tx-level proving, this will generate the entire
+    // proving request for the first time
+    this.avmProvingRequest!.inputs.output = this.generateAvmCircuitPublicInputs(endStateReference);
+    return this.avmProvingRequest!;
+  }
+
+  // TODO(dbanks12): remove once AVM proves entire public tx
+  async updateProvingRequest(
+    real: boolean,
+    phase: TxExecutionPhase,
+    worldStateDB: WorldStateDB,
+    stateManager: AvmPersistableStateManager,
+    executionRequest: PublicExecutionRequest,
+    result: EnqueuedPublicCallExecutionResult,
+    allocatedGas: Gas,
+  ) {
+    if (this.avmProvingRequest === undefined) {
+      // Propagate the very first avmProvingRequest of the tx for now.
+      // Eventually this will be the proof for the entire public portion of the transaction.
+      this.avmProvingRequest = await generateAvmProvingRequest(
+        real,
+        worldStateDB,
+        stateManager,
+        this.historicalHeader,
+        this.globalVariables,
+        executionRequest,
+        result,
+        allocatedGas,
+        this.getTransactionFee(phase),
+      );
+    }
+  }
+}
+
+/**
+ * Thin wrapper around the state manager to handle forking and merging for phases.
+ *
+ * This lets us keep track of whether the state has already been forked
+ * so that we can conditionally fork at the start of a phase.
+ *
+ * There is a state manager that lives at the level of the entire transaction,
+ * but for setup and teardown the active state manager will be a fork of the
+ * transaction level one.
+ */
+class PhaseStateManager {
+  private currentlyActiveStateManager: AvmPersistableStateManager | undefined;
+
+  constructor(private readonly txStateManager: AvmPersistableStateManager) {}
+
+  fork() {
+    assert(!this.currentlyActiveStateManager, 'Cannot fork when already forked');
+    this.currentlyActiveStateManager = this.txStateManager.fork();
+  }
+
+  getActiveStateManager() {
+    return this.currentlyActiveStateManager || this.txStateManager;
+  }
+
+  isForked() {
+    return !!this.currentlyActiveStateManager;
+  }
+
+  mergeForkedState() {
+    assert(this.currentlyActiveStateManager, 'No forked state to merge');
+    this.txStateManager.merge(this.currentlyActiveStateManager!);
+    // Drop the forked state manager now that it is merged
+    this.currentlyActiveStateManager = undefined;
+  }
+
+  discardForkedState() {
+    assert(this.currentlyActiveStateManager, 'No forked state to discard');
+    this.txStateManager.reject(this.currentlyActiveStateManager!);
+    // Drop the forked state manager. We don't want it!
+    this.currentlyActiveStateManager = undefined;
+  }
+}

package/src/public/public_tx_simulator.ts

@@ -0,0 +1,232 @@
+import {
+  type AvmProvingRequest,
+  type GasUsed,
+  type MerkleTreeReadOperations,
+  NestedProcessReturnValues,
+  type SimulationError,
+  type Tx,
+  TxExecutionPhase,
+  UnencryptedFunctionL2Logs,
+} from '@aztec/circuit-types';
+import { Gas, type GlobalVariables, MAX_L2_GAS_PER_ENQUEUED_CALL, type RevertCode } from '@aztec/circuits.js';
+import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+
+import { type EnqueuedPublicCallExecutionResult } from './execution.js';
+import { type PublicExecutor } from './executor.js';
+import { type WorldStateDB } from './public_db_sources.js';
+import { PublicTxContext } from './public_tx_context.js';
+
+export type ProcessedPhase = {
+  phase: TxExecutionPhase;
+  durationMs: number;
+  returnValues: NestedProcessReturnValues[];
+  reverted: boolean;
+  revertReason?: SimulationError;
+};
+
+export type PublicTxResult = {
+  avmProvingRequest: AvmProvingRequest;
+  /** Gas used during the execution of this tx */
+  gasUsed: GasUsed;
+  revertCode: RevertCode;
+  /** Revert reason, if any */
+  revertReason?: SimulationError;
+  processedPhases: ProcessedPhase[];
+};
+
+export class PublicTxSimulator {
+  private log: DebugLogger;
+
+  constructor(
+    private db: MerkleTreeReadOperations,
+    private globalVariables: GlobalVariables,
+    private worldStateDB: WorldStateDB,
+    private publicExecutor: PublicExecutor,
+    private realAvmProvingRequests: boolean = true,
+  ) {
+    this.log = createDebugLogger(`aztec:public_tx_simulator`);
+  }
+
+  static create(
+    db: MerkleTreeReadOperations,
+    publicExecutor: PublicExecutor,
+    globalVariables: GlobalVariables,
+    worldStateDB: WorldStateDB,
+    realAvmProvingRequests: boolean = true,
+  ) {
+    return new PublicTxSimulator(db, globalVariables, worldStateDB, publicExecutor, realAvmProvingRequests);
+  }
+
+  async simulate(tx: Tx): Promise<PublicTxResult> {
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
+
+    const context = await PublicTxContext.create(this.db, this.worldStateDB, tx, this.globalVariables);
+
+    // add new contracts to the contracts db so that their functions may be found and called
+    // TODO(#4073): This is catching only private deployments, when we add public ones, we'll
+    // have to capture contracts emitted in that phase as well.
+    // TODO(@spalladino): Should we allow emitting contracts in the fee preparation phase?
+    // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+    // if so, this should only add contracts that were deployed during private app logic.
+    // FIXME: we shouldn't need to directly modify worldStateDb here!
+    await this.worldStateDB.addNewContracts(tx);
+
+    const processedPhases: ProcessedPhase[] = [];
+    if (context.hasPhase(TxExecutionPhase.SETUP)) {
+      const setupResult: ProcessedPhase = await this.simulateSetupPhase(context);
+      processedPhases.push(setupResult);
+    }
+    if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
+      const appLogicResult: ProcessedPhase = await this.simulateAppLogicPhase(context);
+      processedPhases.push(appLogicResult);
+    }
+    if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+      const teardownResult: ProcessedPhase = await this.simulateTeardownPhase(context);
+      processedPhases.push(teardownResult);
+    }
+    context.halt();
+
+    const endStateReference = await this.db.getStateReference();
+
+    const avmProvingRequest = context.generateProvingRequest(endStateReference);
+    const avmCircuitPublicInputs = avmProvingRequest.inputs.output!;
+
+    const revertCode = context.getFinalRevertCode();
+    if (!revertCode.isOK()) {
+      // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+      // if so, this is removing contracts deployed in private setup
+      // You can't submit contracts in public, so this is only relevant for private-created side effects
+      // FIXME: we shouldn't need to directly modify worldStateDb here!
+      await this.worldStateDB.removeNewContracts(tx);
+      // FIXME(dbanks12): should not be changing immutable tx
+      tx.filterRevertedLogs(
+        tx.data.forPublic!.nonRevertibleAccumulatedData,
+        avmCircuitPublicInputs.accumulatedData.unencryptedLogsHashes,
+      );
+    }
+    // FIXME(dbanks12): should not be changing immutable tx
+    tx.unencryptedLogs.addFunctionLogs([new UnencryptedFunctionL2Logs(context.trace.getUnencryptedLogs())]);
+
+    return {
+      avmProvingRequest,
+      gasUsed: { totalGas: context.getActualGasUsed(), teardownGas: context.teardownGasUsed },
+      revertCode,
+      revertReason: context.revertReason,
+      processedPhases: processedPhases,
+    };
+  }
+
+  private async simulateSetupPhase(context: PublicTxContext): Promise<ProcessedPhase> {
+    return await this.simulatePhase(TxExecutionPhase.SETUP, context);
+  }
+
+  private async simulateAppLogicPhase(context: PublicTxContext): Promise<ProcessedPhase> {
+    // Fork the state manager so that we can rollback state if app logic or teardown reverts.
+    // Don't need to fork for setup since it's non-revertible (if setup fails, transaction is thrown out).
+    context.state.fork();
+
+    const result = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
+
+    if (result.reverted) {
+      // Drop the currently active forked state manager and rollback to end of setup.
+      context.state.discardForkedState();
+    } else {
+      if (!context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+        // Nothing to do after this (no teardown), so merge state updates now instead of letting teardown handle it.
+        context.state.mergeForkedState();
+      }
+    }
+
+    return result;
+  }
+
+  private async simulateTeardownPhase(context: PublicTxContext): Promise<ProcessedPhase> {
+    if (!context.state.isForked()) {
+      // If state isn't forked (app logic was empty or reverted), fork now
+      // so we can rollback to the end of setup if teardown reverts.
+      context.state.fork();
+    }
+
+    const result = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
+
+    if (result.reverted) {
+      // Drop the currently active forked state manager and rollback to end of setup.
+      context.state.discardForkedState();
+    } else {
+      // Merge state updates from teardown,
+      context.state.mergeForkedState();
+    }
+
+    return result;
+  }
+
+  private async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
+    const callRequests = context.getCallRequestsForPhase(phase);
+    const executionRequests = context.getExecutionRequestsForPhase(phase);
+    const txStateManager = context.state.getActiveStateManager();
+
+    this.log.debug(`Beginning processing in phase ${TxExecutionPhase[phase]} for tx ${context.getTxHash()}`);
+
+    const returnValues: NestedProcessReturnValues[] = [];
+    let reverted = false;
+    let revertReason: SimulationError | undefined;
+    const phaseTimer = new Timer();
+    for (let i = callRequests.length - 1; i >= 0; i--) {
+      if (reverted) {
+        break;
+      }
+
+      const callRequest = callRequests[i];
+      const executionRequest = executionRequests[i];
+
+      const availableGas = context.getGasLeftForPhase(phase);
+      // Gas allocated to an enqueued call can be different from the available gas
+      // if there is more gas available than the max allocation per enqueued call.
+      const allocatedGas = new Gas(
+        /*daGas=*/ availableGas.daGas,
+        /*l2Gas=*/ Math.min(availableGas.l2Gas, MAX_L2_GAS_PER_ENQUEUED_CALL),
+      );
+
+      const enqueuedCallResult = (await this.publicExecutor.simulate(
+        txStateManager,
+        executionRequest,
+        this.globalVariables, // todo get from context
+        allocatedGas,
+        context.getTransactionFee(phase),
+      )) as EnqueuedPublicCallExecutionResult;
+
+      // TODO(dbanks12): remove once AVM proves entire public tx
+      await context.updateProvingRequest(
+        this.realAvmProvingRequests,
+        phase,
+        this.worldStateDB,
+        txStateManager,
+        executionRequest,
+        enqueuedCallResult,
+        allocatedGas,
+      );
+
+      txStateManager.traceEnqueuedCall(callRequest, executionRequest.args, enqueuedCallResult.reverted!);
+
+      const gasUsed = allocatedGas.sub(Gas.from(enqueuedCallResult.endGasLeft));
+      context.consumeGas(phase, gasUsed);
+      returnValues.push(new NestedProcessReturnValues(enqueuedCallResult.returnValues));
+
+      if (enqueuedCallResult.reverted) {
+        reverted = true;
+        const culprit = `${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector}`;
+        revertReason = enqueuedCallResult.revertReason;
+        context.revert(phase, enqueuedCallResult.revertReason, culprit); // throws if in setup (non-revertible) phase
+      }
+    }
+
+    return {
+      phase,
+      durationMs: phaseTimer.ms(),
+      returnValues,
+      reverted,
+      revertReason,
+    };
+  }
+}