@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -1,36 +1,49 @@
-import type { Fr } from '@aztec/foundation/fields';
+import { AVM_MAX_PROCESSABLE_L2_GAS, DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ProtocolContractAddress, ProtocolContractsList } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import type { AvmProvingRequest, RevertCode } from '@aztec/stdlib/avm';
+import {
+  AvmCircuitInputs,
+  AvmCircuitPublicInputs,
+  AvmExecutionHints,
+  type AvmProvingRequest,
+  AvmTxHint,
+  type RevertCode,
+} from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
 import type { Gas, GasUsed } from '@aztec/stdlib/gas';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
-import type { PublicCallRequest } from '@aztec/stdlib/kernel';
-import type { AvmSimulationStats } from '@aztec/stdlib/stats';
+import type { DebugLog } from '@aztec/stdlib/logs';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import {
   type GlobalVariables,
   NestedProcessReturnValues,
-  PublicExecutionRequest,
+  PublicCallRequestWithCalldata,
   Tx,
   TxExecutionPhase,
 } from '@aztec/stdlib/tx';
-import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { strict as assert } from 'assert';
 
-import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
-import { type AvmPersistableStateManager, AvmSimulator } from '../avm/index.js';
-import { NullifierCollisionError } from '../avm/journal/nullifiers.js';
-import { ExecutorMetrics } from '../executor_metrics.js';
-import type { WorldStateDB } from '../public_db_sources.js';
+import { AvmSimulator } from '../avm/index.js';
+import { getPublicFunctionDebugName } from '../debug_fn_name.js';
+import { HintingMerkleWriteOperations, HintingPublicContractsDB } from '../hinting_db_sources.js';
+import { type PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
+import {
+  L2ToL1MessageLimitReachedError,
+  NoteHashLimitReachedError,
+  NullifierCollisionError,
+  NullifierLimitReachedError,
+} from '../side_effect_errors.js';
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { PublicTxContext } from './public_tx_context.js';
+import type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
 
 export type ProcessedPhase = {
   phase: TxExecutionPhase;
-  durationMs: number;
+  durationMs?: number;
   returnValues: NestedProcessReturnValues[];
   reverted: boolean;
   revertReason?: SimulationError;
@@ -44,28 +57,72 @@ export type PublicTxResult = {
   /** Revert reason, if any */
   revertReason?: SimulationError;
   processedPhases: ProcessedPhase[];
+  logs: DebugLog[];
+};
+
+export type PublicTxSimulatorConfig = {
+  proverId: Fr;
+  doMerkleOperations: boolean;
+  skipFeeEnforcement: boolean;
+  clientInitiatedSimulation: boolean;
+  maxDebugLogMemoryReads: number;
 };
 
-export class PublicTxSimulator {
-  metrics: ExecutorMetrics;
+// The errors below are only thrown here in the public tx simulator,
+// and only during revertible phases (revertible insertions, app logic and teardown).
+// These are strictly "checked" errors (not exported and never propagated).
+// They are used internally for control flow to trigger rollbacks to the post-setup state.
+
+/**
+ * Error thrown when public tx simulation reverts in a known/checked way during revertible insertions.
+ */
+class TxSimRevertibleInsertionsRevert extends Error {
+  constructor() {
+    super('Public Tx Simulation reverted during Revertible Insertions');
+    this.name = 'TxSimRevertibleInsertionsRevert';
+  }
+}
 
-  private log: Logger;
+/**
+ * Error thrown when public tx simulation reverts during app logic.
+ */
+class TxSimAppLogicRevert extends Error {
+  constructor() {
+    super('Public Tx Simulation reverted during App Logic');
+    this.name = 'TxSimAppLogicRevert';
+  }
+}
+
+/**
+ * Error thrown when public tx simulation reverts during teardown.
+ */
+class TxSimTeardownRevert extends Error {
+  constructor() {
+    super('Public Tx Simulation reverted during Teardown');
+    this.name = 'TxSimTeardownRevert';
+  }
+}
+
+export class PublicTxSimulator implements PublicTxSimulatorInterface {
+  protected log: Logger;
+  private config: PublicTxSimulatorConfig;
 
   constructor(
-    private db: MerkleTreeReadOperations,
-    private worldStateDB: WorldStateDB,
-    private globalVariables: GlobalVariables,
-    private doMerkleOperations: boolean = false,
-    private skipFeeEnforcement: boolean = false,
-    telemetryClient: TelemetryClient = getTelemetryClient(),
+    protected merkleTree: MerkleTreeWriteOperations,
+    protected contractsDB: PublicContractsDB,
+    protected globalVariables: GlobalVariables,
+    config?: Partial<PublicTxSimulatorConfig>,
   ) {
+    this.config = {
+      proverId: config?.proverId ?? Fr.ZERO,
+      doMerkleOperations: config?.doMerkleOperations ?? false,
+      skipFeeEnforcement: config?.skipFeeEnforcement ?? false,
+      clientInitiatedSimulation: config?.clientInitiatedSimulation ?? false,
+      maxDebugLogMemoryReads: config?.maxDebugLogMemoryReads ?? DEFAULT_MAX_DEBUG_LOG_MEMORY_READS,
+    };
     this.log = createLogger(`simulator:public_tx_simulator`);
-    this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
   }
 
-  get tracer(): Tracer {
-    return this.metrics.tracer;
-  }
   /**
    * Simulate a transaction's public portion including all of its phases.
    * @param tx - The transaction to simulate.
@@ -73,74 +130,114 @@ export class PublicTxSimulator {
    */
   public async simulate(tx: Tx): Promise<PublicTxResult> {
     try {
-      const startTime = process.hrtime.bigint();
+      const txHash = this.computeTxHash(tx);
+      this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, { txHash });
 
-      const txHash = await tx.getTxHash();
-      this.log.debug(`Simulating ${tx.enqueuedPublicFunctionCalls.length} public calls for tx ${txHash}`, { txHash });
+      // Create hinting DBs.
+      const hints = new AvmExecutionHints(
+        this.globalVariables,
+        AvmTxHint.fromTx(tx, this.globalVariables.gasFees),
+        ProtocolContractsList, // imported from file
+      );
+      const hintingMerkleTree = await HintingMerkleWriteOperations.create(this.merkleTree, hints);
+      const hintingTreesDB = new PublicTreesDB(hintingMerkleTree);
+      const hintingContractsDB = new HintingPublicContractsDB(this.contractsDB, hints);
 
       const context = await PublicTxContext.create(
-        this.db,
-        this.worldStateDB,
+        hintingTreesDB,
+        hintingContractsDB,
         tx,
         this.globalVariables,
-        this.doMerkleOperations,
+        ProtocolContractsList, // imported from file
+        this.config.doMerkleOperations,
+        this.config.proverId,
       );
 
-      const nonRevertStart = process.hrtime.bigint();
-      await this.insertNonRevertiblesFromPrivate(context);
-      // add new contracts to the contracts db so that their functions may be found and called
-      // TODO(#6464): Should we allow emitting contracts in the private setup phase?
-      await this.worldStateDB.addNewNonRevertibleContracts(tx);
-      const nonRevertEnd = process.hrtime.bigint();
-      this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
+      // This will throw if there is a nullifier collision.
+      // In that case the transaction will be thrown out.
+      await this.insertNonRevertiblesFromPrivate(context, tx);
 
       const processedPhases: ProcessedPhase[] = [];
       if (context.hasPhase(TxExecutionPhase.SETUP)) {
-        const setupResult: ProcessedPhase = await this.simulateSetupPhase(context);
+        // This will throw if the setup phase reverts.
+        // In that case the transaction will be thrown out.
+        const setupResult = await this.simulatePhase(TxExecutionPhase.SETUP, context);
+        if (setupResult.reverted) {
+          throw new Error(
+            `Setup phase reverted! The transaction will be thrown out. ${setupResult.revertReason?.message}`,
+          );
+        }
         processedPhases.push(setupResult);
       }
 
-      const revertStart = process.hrtime.bigint();
-      const success = await this.insertRevertiblesFromPrivate(context);
-      if (success) {
-        // add new contracts to the contracts db so that their functions may be found and called
-        await this.worldStateDB.addNewRevertibleContracts(tx);
-        const revertEnd = process.hrtime.bigint();
-        this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
+      // The checkpoint we should go back to if anything from now on reverts.
+      await context.state.fork();
+
+      try {
+        // This will throw if there is a nullifier collision or other insertion error (limit reached).
+        await this.insertRevertiblesFromPrivate(context, tx);
 
-        // Only proceed with app logic if there was no revert during revertible insertion
+        // Only proceed with app logic if there was no revert during revertible insertion.
         if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
-          const appLogicResult: ProcessedPhase = await this.simulateAppLogicPhase(context);
+          const appLogicResult = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
           processedPhases.push(appLogicResult);
+          if (appLogicResult.reverted) {
+            throw new TxSimAppLogicRevert();
+          }
+        }
+      } catch (e: any) {
+        if (e instanceof TxSimRevertibleInsertionsRevert || e instanceof TxSimAppLogicRevert) {
+          // We revert to the post-setup state.
+          await context.state.discardForkedState();
+          // But we also create a new fork so that the teardown phase can transparently
+          // commit or rollback at the end of teardown.
+          await context.state.fork();
+        } else {
+          // Unchecked/unknown error - re-throw as-is
+          throw e;
         }
-      } else {
-        this.log.debug(`Revertible insertions failed. Skipping app logic.`);
       }
 
-      if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
-        const teardownResult: ProcessedPhase = await this.simulateTeardownPhase(context);
-        processedPhases.push(teardownResult);
+      try {
+        if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+          const teardownResult = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
+          processedPhases.push(teardownResult);
+          if (teardownResult.reverted) {
+            throw new TxSimTeardownRevert();
+          }
+        }
+        // We commit the forked state and we are done.
+        await context.state.mergeForkedState();
+      } catch (e: any) {
+        if (e instanceof TxSimTeardownRevert) {
+          // We revert to the post-setup state and we are done.
+          await context.state.discardForkedState();
+        } else {
+          // Unchecked/unknown error - re-throw as-is
+          throw e;
+        }
       }
 
-      await context.halt();
-      await this.payFee(context);
+      context.halt();
 
-      const endStateReference = await this.db.getStateReference();
+      // Such transactions should be filtered by GasTxValidator.
+      assert(
+        context.getActualGasUsed().l2Gas <= AVM_MAX_PROCESSABLE_L2_GAS,
+        `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the AVM maximum processable gas of ${AVM_MAX_PROCESSABLE_L2_GAS}`,
+      );
+      await this.payFee(context);
 
-      const avmProvingRequest = await context.generateProvingRequest(endStateReference);
+      const publicInputs = await context.generateAvmCircuitPublicInputs();
+      const avmProvingRequest = PublicTxSimulator.generateProvingRequest(publicInputs, hints);
 
       const revertCode = context.getFinalRevertCode();
 
-      if (!revertCode.isOK()) {
-        await tx.filterRevertedLogs();
-      }
       // Commit contracts from this TX to the block-level cache and clear tx cache
       // If the tx reverted, only commit non-revertible contracts
       // NOTE: You can't create contracts in public, so this is only relevant for private-created contracts
-      this.worldStateDB.commitContractsForTx(/*onlyNonRevertibles=*/ !revertCode.isOK());
-
-      const endTime = process.hrtime.bigint();
-      this.log.debug(`Public TX simulator took ${Number(endTime - startTime) / 1_000_000} ms\n`);
+      // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+      // However things should work as they are now because the hinted db would still pick up the new contracts.
+      this.contractsDB.commitContractsForTx(/*onlyNonRevertibles=*/ !revertCode.isOK());
 
       return {
         avmProvingRequest,
@@ -153,101 +250,46 @@ export class PublicTxSimulator {
         revertCode,
         revertReason: context.revertReason,
         processedPhases: processedPhases,
+        logs: context.state.getActiveStateManager().getLogs(),
       };
     } finally {
       // Make sure there are no new contracts in the tx-level cache.
       // They should either be committed to block-level cache or cleared.
-      this.worldStateDB.clearContractsForTx();
+      // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+      // However things should work as they are now because the hinted db would still pick up the new contracts.
+      this.contractsDB.clearContractsForTx();
     }
   }
 
-  /**
-   * Simulate the setup phase of a transaction's public execution.
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */
-  private async simulateSetupPhase(context: PublicTxContext): Promise<ProcessedPhase> {
-    return await this.simulatePhase(TxExecutionPhase.SETUP, context);
-  }
-
-  /**
-   * Simulate the app logic phase of a transaction's public execution.
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */
-  private async simulateAppLogicPhase(context: PublicTxContext): Promise<ProcessedPhase> {
-    assert(context.state.isForked(), 'App logic phase should operate with forked state.');
-
-    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.
-      await 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.
-        await context.state.mergeForkedState();
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Simulate the teardown phase of a transaction's public execution.
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */
-  private async simulateTeardownPhase(context: PublicTxContext): Promise<ProcessedPhase> {
-    if (!context.state.isForked()) {
-      // If state isn't forked (app logic reverted), fork now
-      // so we can rollback to the end of setup if teardown reverts.
-      await 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.
-      await context.state.discardForkedState();
-    } else {
-      // Merge state updates from teardown,
-      await context.state.mergeForkedState();
-    }
-
-    return result;
+  protected computeTxHash(tx: Tx) {
+    return tx.getTxHash();
   }
 
   /**
-   * Simulate a phase of a transaction's public execution.
-   * @param phase - The current phase
+   * Simulate the setup phase of a transaction's public execution.
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
    * @returns The phase result.
    */
-  private async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
+  protected async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
     const callRequests = context.getCallRequestsForPhase(phase);
-    const executionRequests = context.getExecutionRequestsForPhase(phase);
 
     this.log.debug(`Processing phase ${TxExecutionPhase[phase]} for tx ${context.txHash}`, {
       txHash: context.txHash.toString(),
       phase: TxExecutionPhase[phase],
       callRequests: callRequests.length,
-      executionRequests: executionRequests.length,
     });
 
     const returnValues: NestedProcessReturnValues[] = [];
     let reverted = false;
     let revertReason: SimulationError | undefined;
-    const phaseTimer = new Timer();
-    for (let i = callRequests.length - 1; i >= 0; i--) {
+    for (let i = 0; i < callRequests.length; i++) {
       if (reverted) {
         break;
       }
 
       const callRequest = callRequests[i];
-      const executionRequest = executionRequests[i];
 
-      const enqueuedCallResult = await this.simulateEnqueuedCall(phase, context, callRequest, executionRequest);
+      const enqueuedCallResult = await this.simulateEnqueuedCall(phase, context, callRequest);
 
       returnValues.push(new NestedProcessReturnValues(enqueuedCallResult.output));
 
@@ -259,7 +301,6 @@ export class PublicTxSimulator {
 
     return {
       phase,
-      durationMs: phaseTimer.ms(),
       returnValues,
       reverted,
       revertReason,
@@ -270,31 +311,23 @@ export class PublicTxSimulator {
    * Simulate an enqueued public call.
    * @param phase - The current phase of public execution
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @param callRequest - The enqueued call to execute
-   * @param executionRequest - The execution request (includes args)
+   * @param callRequest - The public function call request, including the calldata.
    * @returns The result of execution.
    */
-  @trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, _callRequest, executionRequest) => ({
-    [Attributes.TX_HASH]: context.txHash.toString(),
-    [Attributes.TARGET_ADDRESS]: executionRequest.callContext.contractAddress.toString(),
-    [Attributes.SENDER_ADDRESS]: executionRequest.callContext.msgSender.toString(),
-    [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString(),
-  }))
-  private async simulateEnqueuedCall(
+  protected async simulateEnqueuedCall(
     phase: TxExecutionPhase,
     context: PublicTxContext,
-    callRequest: PublicCallRequest,
-    executionRequest: PublicExecutionRequest,
+    callRequest: PublicCallRequestWithCalldata,
   ): Promise<AvmFinalizedCallResult> {
     const stateManager = context.state.getActiveStateManager();
-    const address = executionRequest.callContext.contractAddress;
-    const fnName = await getPublicFunctionDebugName(this.worldStateDB, address, executionRequest.args);
+    const contractAddress = callRequest.request.contractAddress;
+    const fnName = await getPublicFunctionDebugName(this.contractsDB, contractAddress, callRequest.calldata);
 
     const allocatedGas = context.getGasLeftAtPhase(phase);
 
     const result = await this.simulateEnqueuedCallInternal(
-      context.state.getActiveStateManager(),
-      executionRequest,
+      stateManager,
+      callRequest,
       allocatedGas,
       /*transactionFee=*/ context.getTransactionFee(phase),
       fnName,
@@ -306,11 +339,9 @@ export class PublicTxSimulator {
       `Simulated enqueued public call (${fnName}) consumed ${gasUsed.l2Gas} L2 gas ending with ${result.gasLeft.l2Gas} L2 gas left.`,
     );
 
-    stateManager.traceEnqueuedCall(callRequest, executionRequest.args, result.reverted);
-
     if (result.reverted) {
-      const culprit = `${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector}`;
-      context.revert(phase, result.revertReason, culprit); // throws if in setup (non-revertible) phase
+      const culprit = `${contractAddress}:${callRequest.functionSelector}`;
+      context.revert(phase, result.revertReason, culprit);
     }
 
     return result;
@@ -324,32 +355,24 @@ export class PublicTxSimulator {
    * while still simulating phases and generating a proving request.
    *
    * @param stateManager - The state manager for AvmSimulation
-   * @param context - The context of the currently executing public transaction portion
-   * @param executionRequest - The execution request (includes args)
+   * @param callRequest - The public function call request, including the calldata.
    * @param allocatedGas - The gas allocated to the enqueued call
    * @param fnName - The name of the function
    * @returns The result of execution.
    */
-  @trackSpan(
-    'PublicTxSimulator.simulateEnqueuedCallInternal',
-    (_stateManager, _executionRequest, _allocatedGas, _transactionFee, fnName) => ({
-      [Attributes.APP_CIRCUIT_NAME]: fnName,
-    }),
-  )
-  private async simulateEnqueuedCallInternal(
-    stateManager: AvmPersistableStateManager,
-    executionRequest: PublicExecutionRequest,
+  protected async simulateEnqueuedCallInternal(
+    stateManager: PublicPersistableStateManager,
+    { request, calldata }: PublicCallRequestWithCalldata,
     allocatedGas: Gas,
     transactionFee: Fr,
     fnName: string,
   ): Promise<AvmFinalizedCallResult> {
-    const address = executionRequest.callContext.contractAddress;
-    const sender = executionRequest.callContext.msgSender;
+    const address = request.contractAddress;
+    const sender = request.msgSender;
 
     this.log.debug(
       `Executing enqueued public call to external function ${fnName}@${address} with ${allocatedGas.l2Gas} allocated L2 gas.`,
     );
-    const timer = new Timer();
 
     const simulator = await AvmSimulator.create(
       stateManager,
@@ -357,87 +380,126 @@ export class PublicTxSimulator {
       sender,
       transactionFee,
       this.globalVariables,
-      executionRequest.callContext.isStaticCall,
-      executionRequest.args,
+      request.isStaticCall,
+      calldata,
       allocatedGas,
+      this.config.clientInitiatedSimulation,
+      this.config.maxDebugLogMemoryReads,
     );
     const avmCallResult = await simulator.execute();
-    const result = avmCallResult.finalize();
-
-    this.log.verbose(
-      result.reverted
-        ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason}.`
-        : `Simulation of enqueued public call ${fnName} completed successfully.`,
-      {
-        eventName: 'avm-simulation',
-        appCircuitName: fnName,
-        duration: timer.ms(),
-      } satisfies AvmSimulationStats,
-    );
-
-    if (result.reverted) {
-      this.metrics.recordFunctionSimulationFailure();
-    } else {
-      this.metrics.recordFunctionSimulation(timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, fnName);
-    }
-
-    return result;
+    return avmCallResult.finalize();
   }
 
   /**
    * Insert the non-revertible accumulated data from private into the public state.
    */
-  public async insertNonRevertiblesFromPrivate(context: PublicTxContext) {
+  protected async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
     const stateManager = context.state.getActiveStateManager();
-    try {
-      await stateManager.writeSiloedNullifiersFromPrivate(context.nonRevertibleAccumulatedDataFromPrivate.nullifiers);
-    } catch (e) {
-      if (e instanceof NullifierCollisionError) {
-        throw new NullifierCollisionError(
-          `Nullifier collision encountered when inserting non-revertible nullifiers from private.\nDetails: ${e.message}\nStack:${e.stack}`,
-        );
-      }
+
+    for (const siloedNullifier of context.nonRevertibleAccumulatedDataFromPrivate.nullifiers.filter(
+      n => !n.isEmpty(),
+    )) {
+      await stateManager.writeSiloedNullifier(siloedNullifier);
     }
     for (const noteHash of context.nonRevertibleAccumulatedDataFromPrivate.noteHashes) {
       if (!noteHash.isEmpty()) {
         await stateManager.writeUniqueNoteHash(noteHash);
       }
     }
+    for (const l2ToL1Message of context.nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs) {
+      if (!l2ToL1Message.isEmpty()) {
+        stateManager.writeScopedL2ToL1Message(l2ToL1Message);
+      }
+    }
+
+    // add new contracts to the contracts db so that their functions may be found and called
+    // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+    // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+    // However things should work as they are now because the hinted db would still pick up the new contracts.
+    await this.contractsDB.addNewNonRevertibleContracts(tx);
   }
 
   /**
    * Insert the revertible accumulated data from private into the public state.
-   * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
+   * Throws TxSimRevertibleInsertionsRevert if there is some checked error during revertible insertions.
+   * This function checks for the following errors:
+   * - NullifierLimitReachedError
+   * - NullifierCollisionError
+   * - NoteHashLimitReachedError
+   * - L2ToL1MessageLimitReachedError
    */
-  public async insertRevertiblesFromPrivate(context: PublicTxContext): /*success=*/ Promise<boolean> {
-    // Fork the state manager so we can rollback to end of setup if app logic reverts.
-    await context.state.fork();
+  protected async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
     const stateManager = context.state.getActiveStateManager();
+
     try {
-      await stateManager.writeSiloedNullifiersFromPrivate(context.revertibleAccumulatedDataFromPrivate.nullifiers);
-    } catch (e) {
-      if (e instanceof NullifierCollisionError) {
-        // Instead of throwing, revert the app_logic phase
+      for (const siloedNullifier of context.revertibleAccumulatedDataFromPrivate.nullifiers.filter(n => !n.isEmpty())) {
+        await stateManager.writeSiloedNullifier(siloedNullifier);
+      }
+    } catch (e: any) {
+      if (e instanceof NullifierLimitReachedError || e instanceof NullifierCollisionError) {
         context.revert(
           TxExecutionPhase.APP_LOGIC,
           new SimulationError(
-            `Nullifier collision encountered when inserting revertible nullifiers from private\nDetails: ${e.message}\nError stack: ${e.stack}`,
+            `Error encountered when inserting revertible nullifiers from private.\nDetails: ${e.message}`,
             [],
           ),
-          /*culprit=*/ 'insertRevertiblesFromPrivate',
         );
-        return /*success=*/ false;
+        throw new TxSimRevertibleInsertionsRevert();
       } else {
+        // Unchecked/unknown error - re-throw as-is
         throw e;
       }
     }
-    for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes) {
-      if (!noteHash.isEmpty()) {
-        // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
-        await stateManager.writeSiloedNoteHash(noteHash);
+
+    try {
+      for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes) {
+        if (!noteHash.isEmpty()) {
+          // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
+          await stateManager.writeSiloedNoteHash(noteHash);
+        }
+      }
+    } catch (e: any) {
+      if (e instanceof NoteHashLimitReachedError) {
+        context.revert(
+          TxExecutionPhase.APP_LOGIC,
+          new SimulationError(
+            `Error encountered when inserting revertible note hashes from private.\nDetails: ${e.message}`,
+            [],
+          ),
+        );
+        throw new TxSimRevertibleInsertionsRevert();
+      } else {
+        // Unchecked/unknown error - re-throw as-is
+        throw e;
       }
     }
-    return /*success=*/ true;
+
+    try {
+      for (const l2ToL1Message of context.revertibleAccumulatedDataFromPrivate.l2ToL1Msgs) {
+        if (!l2ToL1Message.isEmpty()) {
+          stateManager.writeScopedL2ToL1Message(l2ToL1Message);
+        }
+      }
+    } catch (e: any) {
+      if (e instanceof L2ToL1MessageLimitReachedError) {
+        context.revert(
+          TxExecutionPhase.APP_LOGIC,
+          new SimulationError(
+            `Error encountered when inserting revertible L2-to-L1 messages from private.\nDetails: ${e.message}`,
+            [],
+          ),
+        );
+        throw new TxSimRevertibleInsertionsRevert();
+      } else {
+        // Unchecked/unknown error - re-throw as-is
+        throw e;
+      }
+    }
+
+    // add new contracts to the contracts db so that their functions may be found and called
+    // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+    // However things should work as they are now because the hinted db would still pick up the new contracts.
+    await this.contractsDB.addNewRevertibleContracts(tx);
   }
 
   private async payFee(context: PublicTxContext) {
@@ -459,16 +521,28 @@ export class PublicTxSimulator {
     // When mocking the balance of the fee payer, the circuit should not be able to prove the simulation
 
     if (currentBalance.lt(txFee)) {
-      if (!this.skipFeeEnforcement) {
-        throw new Error(
-          `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`,
-        );
-      } else {
-        currentBalance = txFee;
-      }
+      // Without "skipFeeEnforcement", such transactions should be filtered by GasTxValidator.
+      assert(
+        this.config.skipFeeEnforcement,
+        `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`,
+      );
+      currentBalance = txFee;
     }
 
     const updatedBalance = currentBalance.sub(txFee);
     await stateManager.writeStorage(feeJuiceAddress, balanceSlot, updatedBalance, true);
   }
+
+  /**
+   * Generate the proving request for the AVM circuit.
+   */
+  private static generateProvingRequest(
+    publicInputs: AvmCircuitPublicInputs,
+    hints: AvmExecutionHints,
+  ): AvmProvingRequest {
+    return {
+      type: ProvingRequestType.PUBLIC_VM,
+      inputs: new AvmCircuitInputs(hints, publicInputs),
+    };
+  }
 }