@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/public/public_processor/public_processor.ts

@@ -1,25 +1,40 @@
 import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { type DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider, Timer, elapsed, execWithSignal } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import { PublicDataWrite } from '@aztec/stdlib/avm';
+import {
+  AvmCircuitInputs,
+  AvmCircuitPublicInputs,
+  AvmExecutionHints,
+  type AvmProvingRequest,
+  PublicDataWrite,
+  PublicSimulatorConfig,
+} from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { computeTransactionFee } from '@aztec/stdlib/fees';
 import { Gas } from '@aztec/stdlib/gas';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type {
+  MerkleTreeWriteOperations,
+  PublicProcessorLimits,
+  PublicProcessorValidator,
+  SequencerConfig,
+} from '@aztec/stdlib/interfaces/server';
+import { type DebugLog, type DebugLogStore, NullDebugLogStore } from '@aztec/stdlib/logs';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type FailedTx,
   GlobalVariables,
   NestedProcessReturnValues,
   type ProcessedTx,
+  StateReference,
   Tx,
-  TxExecutionPhase,
-  type TxValidator,
   makeProcessedTxFromPrivateOnlyTx,
   makeProcessedTxFromTxWithPublicCalls,
 } from '@aztec/stdlib/tx';
@@ -33,67 +48,70 @@ import {
 } from '@aztec/telemetry-client';
 import { ForkCheckpoint } from '@aztec/world-state/native';
 
-import { WorldStateDB } from '../public_db_sources.js';
-import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+import { AssertionError } from 'assert';
+
+import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
+import {
+  type PublicTxSimulatorConfig,
+  type PublicTxSimulatorInterface,
+  TelemetryCppPublicTxSimulator,
+} from '../public_tx_simulator/index.js';
+import { GuardedMerkleTreeOperations } from './guarded_merkle_tree.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
 
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
  */
 export class PublicProcessorFactory {
+  private log: Logger;
   constructor(
     private contractDataSource: ContractDataSource,
-    private dateProvider: DateProvider,
-    private telemetryClient: TelemetryClient = getTelemetryClient(),
-  ) {}
+    private dateProvider: DateProvider = new DateProvider(),
+    protected telemetryClient: TelemetryClient = getTelemetryClient(),
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('simulator:public-processor-factory', bindings);
+  }
 
   /**
    * Creates a new instance of a PublicProcessor.
-   * @param historicalHeader - The header of a block previous to the one in which the tx is included.
    * @param globalVariables - The global variables for the block being processed.
-   * @param skipFeeEnforcement - Allows disabling balance checks for fee estimations.
+   * @param contractsDB - Optional pre-populated contracts DB; a fresh one is constructed if omitted.
    * @returns A new instance of a PublicProcessor.
    */
   public create(
     merkleTree: MerkleTreeWriteOperations,
     globalVariables: GlobalVariables,
-    skipFeeEnforcement: boolean,
+    config: PublicSimulatorConfig,
+    contractsDB: PublicContractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings()),
   ): PublicProcessor {
-    const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
-    const publicTxSimulator = this.createPublicTxSimulator(
-      merkleTree,
-      worldStateDB,
-      globalVariables,
-      /*doMerkleOperations=*/ true,
-      skipFeeEnforcement,
-      this.telemetryClient,
-    );
+    const guardedFork = new GuardedMerkleTreeOperations(merkleTree);
+    const publicTxSimulator = this.createPublicTxSimulator(guardedFork, contractsDB, globalVariables, config);
 
     return new PublicProcessor(
-      merkleTree,
       globalVariables,
-      worldStateDB,
+      guardedFork,
+      contractsDB,
       publicTxSimulator,
       this.dateProvider,
       this.telemetryClient,
+      createLogger('simulator:public-processor', this.log.getBindings()),
     );
   }
 
   protected createPublicTxSimulator(
-    db: MerkleTreeWriteOperations,
-    worldStateDB: WorldStateDB,
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
-    doMerkleOperations: boolean,
-    skipFeeEnforcement: boolean,
-    telemetryClient: TelemetryClient,
-  ) {
-    return new PublicTxSimulator(
-      db,
-      worldStateDB,
+    config?: Partial<PublicTxSimulatorConfig>,
+  ): PublicTxSimulatorInterface {
+    return new TelemetryCppPublicTxSimulator(
+      merkleTree,
+      contractsDB,
       globalVariables,
-      doMerkleOperations,
-      skipFeeEnforcement,
-      telemetryClient,
+      this.telemetryClient,
+      config,
+      this.log.getBindings(),
     );
   }
 }
@@ -105,6 +123,17 @@ class PublicProcessorTimeoutError extends Error {
   }
 }
 
+class PublicProcessorAbortError extends Error {
+  constructor(message: string = 'Aborted while processing tx') {
+    super(message);
+    this.name = 'PublicProcessorAbortError';
+  }
+}
+
+function isPublicProcessorInterruptError(err: any) {
+  return err?.name === 'PublicProcessorTimeoutError' || err?.name === 'PublicProcessorAbortError';
+}
+
 /**
  * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
  * any public function calls in them. Txs with private calls only are unaffected.
@@ -112,13 +141,15 @@ class PublicProcessorTimeoutError extends Error {
 export class PublicProcessor implements Traceable {
   private metrics: PublicProcessorMetrics;
   constructor(
-    protected db: MerkleTreeWriteOperations,
     protected globalVariables: GlobalVariables,
-    protected worldStateDB: WorldStateDB,
-    protected publicTxSimulator: PublicTxSimulator,
+    private guardedMerkleTree: GuardedMerkleTreeOperations,
+    protected contractsDB: PublicContractsDB,
+    protected publicTxSimulator: PublicTxSimulatorInterface,
     private dateProvider: DateProvider,
     telemetryClient: TelemetryClient = getTelemetryClient(),
-    private log = createLogger('simulator:public-processor'),
+    private log: Logger,
+    private opts: Pick<SequencerConfig, 'fakeProcessingDelayPerTxMs' | 'fakeThrowAfterProcessingTxCount'> = {},
+    private debugLogStore: DebugLogStore = new NullDebugLogStore(),
   ) {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
   }
@@ -130,63 +161,65 @@ export class PublicProcessor implements Traceable {
   /**
    * Run each tx through the public circuit and the public kernel circuit if needed.
    * @param txs - Txs to process.
-   * @param processedTxHandler - Handler for processed txs in the context of block building or proving.
+   * @param limits - Limits for processing the txs.
+   * @param validator - Pre-process validator and nullifier cache to use for processing the txs.
    * @returns The list of processed txs with their circuit simulation outputs.
    */
   public async process(
     txs: Iterable<Tx> | AsyncIterable<Tx>,
-    limits: {
-      maxTransactions?: number;
-      maxBlockSize?: number;
-      maxBlockGas?: Gas;
-      deadline?: Date;
-    } = {},
-    validators: {
-      preprocessValidator?: TxValidator<Tx>;
-      postprocessValidator?: TxValidator<ProcessedTx>;
-      nullifierCache?: { addNullifiers: (nullifiers: Buffer[]) => void };
-    } = {},
-  ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
-    const { maxTransactions, maxBlockSize, deadline, maxBlockGas } = limits;
-    const { preprocessValidator, postprocessValidator, nullifierCache } = validators;
+    limits: PublicProcessorLimits = {},
+    validator: PublicProcessorValidator = {},
+  ): Promise<[ProcessedTx[], FailedTx[], Tx[], NestedProcessReturnValues[], DebugLog[]]> {
+    const { maxTransactions, deadline, maxBlockGas, maxBlobFields, isBuildingProposal, signal } = limits;
+    const { preprocessValidator, nullifierCache } = validator;
     const result: ProcessedTx[] = [];
+    const usedTxs: Tx[] = [];
     const failed: FailedTx[] = [];
+    const debugLogs: DebugLog[] = [];
     const timer = new Timer();
 
     let totalSizeInBytes = 0;
     let returns: NestedProcessReturnValues[] = [];
     let totalPublicGas = new Gas(0, 0);
     let totalBlockGas = new Gas(0, 0);
+    let totalBlobFields = 0;
+    let silentlySkippedCount = 0;
+    let totalSilentlySkippedDurationMs = 0;
 
-    for await (const origTx of txs) {
+    for await (const tx of txs) {
       // Only process up to the max tx limit
       if (maxTransactions !== undefined && result.length >= maxTransactions) {
         this.log.debug(`Stopping tx processing due to reaching the max tx limit.`);
         break;
       }
 
-      // Bail if we've hit the deadline
+      // Bail if we've hit the deadline or have been interrupted.
       if (deadline && this.dateProvider.now() > +deadline) {
         this.log.warn(`Stopping tx processing due to timeout.`);
         break;
       }
+      if (signal?.aborted) {
+        this.log.warn(`Stopping tx processing due to abort signal.`);
+        break;
+      }
 
-      // Skip this tx if it'd exceed max block size
-      const txHash = (await origTx.getTxHash()).toString();
-      const preTxSizeInBytes = origTx.getEstimatedPrivateTxEffectsSize();
-      if (maxBlockSize !== undefined && totalSizeInBytes + preTxSizeInBytes > maxBlockSize) {
-        this.log.warn(`Skipping processing of tx ${txHash} sized ${preTxSizeInBytes} bytes due to block size limit`, {
-          txHash,
-          sizeInBytes: preTxSizeInBytes,
-          totalSizeInBytes,
-          maxBlockSize,
-        });
+      const txHash = tx.getTxHash().toString();
+
+      // Skip this tx if its estimated blob fields would exceed the limit.
+      // Only done during proposal building: during re-execution we must process the exact txs from the proposal.
+      const txBlobFields = tx.getPrivateTxEffectsSizeInFields();
+      if (isBuildingProposal && maxBlobFields !== undefined && totalBlobFields + txBlobFields > maxBlobFields) {
+        this.log.warn(
+          `Skipping tx ${txHash} with ${txBlobFields} fields from private side effects due to blob fields limit`,
+          { txHash, txBlobFields, totalBlobFields, maxBlobFields },
+        );
         continue;
       }
 
-      // Skip this tx if its gas limit would exceed the block gas limit
-      const txGasLimit = origTx.data.constants.txContext.gasSettings.gasLimits;
-      if (maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
+      // Skip this tx if its gas limit would exceed the block gas limit (either da or l2).
+      // Only done during proposal building: during re-execution we must process the exact txs from the proposal.
+      const txGasLimit = tx.data.constants.txContext.gasSettings.gasLimits;
+      if (isBuildingProposal && maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
         this.log.warn(`Skipping processing of tx ${txHash} due to block gas limit`, {
           txHash,
           txGasLimit,
@@ -196,24 +229,16 @@ export class PublicProcessor implements Traceable {
         continue;
       }
 
-      // The processor modifies the tx objects in place, so we need to clone them.
-      const tx = Tx.clone(origTx);
-
       // We validate the tx before processing it, to avoid unnecessary work.
       if (preprocessValidator) {
         const result = await preprocessValidator.validateTx(tx);
-        const txHash = await tx.getTxHash();
+        const txHash = tx.getTxHash();
         if (result.result === 'invalid') {
           const reason = result.reason.join(', ');
-          this.log.warn(`Rejecting tx ${txHash.toString()} due to pre-process validation fail: ${reason}`);
+          this.log.debug(`Rejecting tx ${txHash.toString()} due to pre-process validation fail: ${reason}`);
           failed.push({ tx, error: new Error(`Tx failed preprocess validation: ${reason}`) });
           returns.push(new NestedProcessReturnValues([]));
           continue;
-        } else if (result.result === 'skipped') {
-          const reason = result.reason.join(', ');
-          this.log.warn(`Skipping tx ${txHash.toString()} due to pre-process validation: ${reason}`);
-          returns.push(new NestedProcessReturnValues([]));
-          continue;
         } else {
           this.log.trace(`Tx ${txHash.toString()} is valid before processing.`);
         }
@@ -222,79 +247,128 @@ export class PublicProcessor implements Traceable {
       // We checkpoint the transaction here, then within the try/catch we
       // 1. Revert the checkpoint if the tx fails or needs to be discarded for any reason
       // 2. Commit the transaction in the finally block. Note that by using the ForkCheckpoint lifecycle only the first commit/revert takes effect
-      const checkpoint = await ForkCheckpoint.new(this.worldStateDB);
+      // By doing this, every transaction starts on a fresh checkpoint and it's state updates only make it to the fork if this checkpoint is committed.
+      // Note: We use the underlying fork here not the guarded one, this ensures that it's not impacted by stopping the guarded version
+      const checkpoint = await ForkCheckpoint.new(this.guardedMerkleTree.getUnderlyingFork());
+      const startStateReference = await this.guardedMerkleTree.getUnderlyingFork().getStateReference();
+      this.contractsDB.createCheckpoint();
 
       try {
-        const [processedTx, returnValues] = await this.processTx(tx, deadline);
+        const [txProcessingTimeMs, [processedTx, returnValues, txDebugLogs]] = await elapsed(() =>
+          this.processTx(tx, deadline, signal),
+        );
+
+        // Inject a fake processing failure after N txs if requested
+        const fakeThrowAfter = this.opts.fakeThrowAfterProcessingTxCount;
+        if (fakeThrowAfter !== undefined && result.length + failed.length + 1 >= fakeThrowAfter) {
+          throw new Error(`Fake error after processing ${fakeThrowAfter} txs`);
+        }
 
-        // If the actual size of this tx would exceed block size, skip it
-        const txSize = processedTx.txEffect.getDASize();
-        if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
-          this.log.warn(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
-            txHash,
-            sizeInBytes: txSize,
-            totalSizeInBytes,
-            maxBlockSize,
-          });
+        const txBlobFields = processedTx.txEffect.getNumBlobFields();
+        const txSize = txBlobFields * Fr.SIZE_IN_BYTES;
+
+        // If the actual blob fields of this tx would exceed the limit, skip it.
+        // Note: maxBlobFields already accounts for block end blob fields and previous blocks in checkpoint.
+        if (maxBlobFields !== undefined && totalBlobFields + txBlobFields > maxBlobFields) {
+          this.log.debug(
+            `Skipping processed tx ${txHash} with ${txBlobFields} blob fields due to max blob fields limit.`,
+            {
+              txHash,
+              txBlobFields,
+              totalBlobFields,
+              maxBlobFields,
+              txProcessingTimeMs,
+            },
+          );
+          silentlySkippedCount += 1;
+          totalSilentlySkippedDurationMs += txProcessingTimeMs;
+          this.metrics.recordSilentlySkipped(txProcessingTimeMs);
           // Need to revert the checkpoint here and don't go any further
           await checkpoint.revert();
+          this.contractsDB.revertCheckpoint();
           continue;
         }
 
-        // Re-validate the transaction
-        if (postprocessValidator) {
-          // Only accept processed transactions that are not double-spends,
-          // public functions emitting nullifiers would pass earlier check but fail here.
-          // Note that we're checking all nullifiers generated in the private execution twice,
-          // we could store the ones already checked and skip them here as an optimization.
-          // TODO(palla/txs): Can we get into this case? AVM validates this. We should be able to remove it.
-          const result = await postprocessValidator.validateTx(processedTx);
-          if (result.result !== 'valid') {
-            const reason = result.reason.join(', ');
-            this.log.error(`Rejecting tx ${processedTx.hash} after processing: ${reason}.`);
-            failed.push({ tx, error: new Error(`Tx failed post-process validation: ${reason}`) });
-            // Need to revert the checkpoint here and don't go any further
-            await checkpoint.revert();
-            continue;
-          } else {
-            this.log.trace(`Tx ${txHash.toString()} is valid post processing.`);
-          }
-        }
-
-        if (!tx.hasPublicCalls()) {
-          // If there are no public calls, perform all tree insertions for side effects from private
-          // When there are public calls, the PublicTxSimulator & AVM handle tree insertions.
-          await this.doTreeInsertionsForPrivateOnlyTx(processedTx);
-          // Add any contracts registered/deployed in this private-only tx to the block-level cache
-          // (add to tx-level cache and then commit to block-level cache)
-          await this.worldStateDB.addNewContracts(tx);
-          this.worldStateDB.commitContractsForTx();
+        // During re-execution, check if the actual gas used by this tx would push the block over the gas limit.
+        // Unlike the proposal-building check (which uses declared gas limits pessimistically before processing),
+        // this uses actual gas and stops processing when the limit is exceeded.
+        if (
+          !isBuildingProposal &&
+          maxBlockGas !== undefined &&
+          totalBlockGas.add(processedTx.gasUsed.totalGas).gtAny(maxBlockGas)
+        ) {
+          this.log.warn(`Stopping re-execution since tx ${txHash} would push block gas over limit`, {
+            txHash,
+            txGas: processedTx.gasUsed.totalGas,
+            totalBlockGas,
+            maxBlockGas,
+          });
+          await checkpoint.revert();
+          this.contractsDB.revertCheckpoint();
+          break;
         }
 
+        // FIXME(fcarreiro): it's ugly to have to notify the validator of nullifiers.
+        // I'd rather pass the validators the processedTx as well and let them deal with it.
         nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map(n => n.toBuffer()));
         result.push(processedTx);
+        usedTxs.push(tx);
         returns = returns.concat(returnValues);
+        debugLogs.push(...txDebugLogs);
+
+        this.debugLogStore.storeLogs(processedTx.hash.toString(), txDebugLogs);
 
         totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
         totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
         totalSizeInBytes += txSize;
+        totalBlobFields += txBlobFields;
+
+        // Commit the tx-level contracts checkpoint on success
+        this.contractsDB.commitCheckpoint();
       } catch (err: any) {
-        // Roll back state to start of TX before proceeding to next TX
-        await checkpoint.revert();
-        if (err?.name === 'PublicProcessorTimeoutError') {
-          this.log.warn(`Stopping tx processing due to timeout.`);
+        if (isPublicProcessorInterruptError(err)) {
+          const interruptReason = err.name === 'PublicProcessorTimeoutError' ? 'timeout' : 'abort signal';
+          this.log.warn(`Stopping tx processing due to ${interruptReason}.`);
+          // The tx may still be executing on a worker thread (C++ via NAPI).
+          // Signal cancellation AND WAIT for the simulation to actually stop before touching fork checkpoints.
+          await this.publicTxSimulator.cancel?.();
+
+          // Now stop the guarded fork to prevent any further TS-side access to the world state.
+          await this.guardedMerkleTree.stop();
+
+          // We now know there can't be any further access to world state. The fork is in a state where there is:
+          // 1. At least one outstanding checkpoint that has not been committed (the one created before we processed the tx).
+          // 2. Possible state updates on that checkpoint or any others created during execution.
+
+          // Revert all checkpoints at or above this checkpoint's depth (inclusive), destroying any outstanding state
+          // updates from this tx and any nested checkpoints created during execution. This preserves any checkpoints
+          // created by callers below our depth.
+          await checkpoint.revertToCheckpoint();
+
+          // Revert any contracts added to the DB for the tx.
+          this.contractsDB.revertCheckpoint();
+
+          // Ensure we're at the same state as when we started processing this tx.
+          await this.checkWorldStateUnchanged(startStateReference, txHash, err);
+
+          // We should now be in a position where the fork is in a clean state and no further updates can be made to it.
           break;
         }
-        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-        this.log.warn(`Failed to process tx ${txHash.toString()}: ${errorMessage} ${err?.stack}`);
 
+        // Roll back state to start of TX before proceeding to next TX.
+        // Reverts all checkpoints at or above this checkpoint's depth, preserving any caller checkpoints below.
+        await checkpoint.revertToCheckpoint();
+        this.contractsDB.revertCheckpoint();
+        const errorMessage = err instanceof Error || err instanceof AssertionError ? err.message : 'Unknown error';
+        this.log.warn(`Failed to process tx ${txHash.toString()}: ${errorMessage} ${err?.stack}`);
         failed.push({ tx, error: err instanceof Error ? err : new Error(errorMessage) });
         returns.push(new NestedProcessReturnValues([]));
+
+        // Ensure we're at the same state as when we started processing this tx.
+        await this.checkWorldStateUnchanged(startStateReference, txHash, err);
       } finally {
-        // Base case is we always commit the checkpoint. Using the ForkCheckpoint means this has no effect if the tx was reverted
+        // Base case is we always commit the checkpoint. Using the ForkCheckpoint means this has no effect if the tx was previously reverted
         await checkpoint.commit();
-        // The tx-level contracts cache should not live on to the next tx
-        this.worldStateDB.clearContractsForTx();
       }
     }
 
@@ -302,25 +376,58 @@ export class PublicProcessor implements Traceable {
     const rate = duration > 0 ? totalPublicGas.l2Gas / duration : 0;
     this.metrics.recordAllTxs(totalPublicGas, rate);
 
-    this.log.info(`Processed ${result.length} successful txs and ${failed.length} failed txs in ${duration}s`, {
-      duration,
-      rate,
-      totalPublicGas,
-      totalBlockGas,
-      totalSizeInBytes,
-    });
+    const silentlySkippedDurationMs = Math.round(totalSilentlySkippedDurationMs);
+    this.log.info(
+      `Processed ${result.length} successful txs and ${failed.length} failed txs ` +
+        `(${silentlySkippedCount} silently skipped, ${silentlySkippedDurationMs}ms wasted) ` +
+        `in ${duration}s`,
+      {
+        blockNumber: this.globalVariables.blockNumber,
+        successfulCount: result.length,
+        failedCount: failed.length,
+        duration,
+        rate,
+        totalPublicGas,
+        totalBlockGas,
+        totalSizeInBytes,
+        silentlySkippedCount,
+        silentlySkippedDurationMs,
+      },
+    );
 
-    return [result, failed, returns];
+    return [result, failed, usedTxs, returns, debugLogs];
   }
 
-  @trackSpan('PublicProcessor.processTx', async tx => ({ [Attributes.TX_HASH]: (await tx.getTxHash()).toString() }))
-  private async processTx(tx: Tx, deadline?: Date): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
-    const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
+  private async checkWorldStateUnchanged(
+    startStateReference: StateReference,
+    txHash: `0x${string}`,
+    cause: Error,
+  ): Promise<void> {
+    const endStateReference = await this.guardedMerkleTree.getUnderlyingFork().getStateReference();
+    if (!startStateReference.equals(endStateReference)) {
+      this.log.warn(`Fork state reference changed by tx ${txHash} after error in public processor`, {
+        expected: startStateReference.toInspect(),
+        actual: endStateReference.toInspect(),
+        cause,
+      });
+      throw new Error(`Fork state reference changed by tx ${txHash} after error in public processor`, { cause });
+    }
+  }
+
+  @trackSpan('PublicProcessor.processTx', tx => ({ [Attributes.TX_HASH]: tx.getTxHash().toString() }))
+  private async processTx(
+    tx: Tx,
+    deadline: Date | undefined,
+    signal: AbortSignal | undefined,
+  ): Promise<[ProcessedTx, NestedProcessReturnValues[], DebugLog[]]> {
+    const [time, [processedTx, returnValues, debugLogs]] = await elapsed(() =>
+      this.processTxWithinDeadline(tx, deadline, signal),
+    );
 
     this.log.verbose(
       !tx.hasPublicCalls()
         ? `Processed tx ${processedTx.hash} with no public calls in ${time}ms`
-        : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls in ${time}ms`,
+        : `Processed tx ${processedTx.hash} with ${tx.numberOfPublicCalls()} public calls in ${time}ms`,
       {
         txHash: processedTx.hash,
         txFee: processedTx.txEffect.transactionFee.toBigInt(),
@@ -338,13 +445,10 @@ export class PublicProcessor implements Traceable {
       },
     );
 
-    return [processedTx, returnValues ?? []];
+    return [processedTx, returnValues ?? [], debugLogs];
   }
 
-  private async doTreeInsertionsForPrivateOnlyTx(
-    processedTx: ProcessedTx,
-    txValidator?: TxValidator<ProcessedTx>,
-  ): Promise<void> {
+  private async doTreeInsertionsForPrivateOnlyTx(processedTx: ProcessedTx): Promise<void> {
     const treeInsertionStart = process.hrtime.bigint();
 
     // Update the state so that the next tx in the loop has the correct .startState
@@ -353,65 +457,77 @@ export class PublicProcessor implements Traceable {
     // b) always had a txHandler with the same db passed to it as this.db, which updated the db in buildBaseRollupHints in this loop
     // To see how this ^ happens, move back to one shared db in test_context and run orchestrator_multi_public_functions.test.ts
     // The below is taken from buildBaseRollupHints:
-    await this.db.appendLeaves(
+    await this.guardedMerkleTree.appendLeaves(
       MerkleTreeId.NOTE_HASH_TREE,
       padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
     );
     try {
-      await this.db.batchInsert(
+      await this.guardedMerkleTree.batchInsert(
         MerkleTreeId.NULLIFIER_TREE,
         padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
         NULLIFIER_SUBTREE_HEIGHT,
       );
-    } catch (error) {
-      if (txValidator) {
-        // Ideally the validator has already caught this above, but just in case:
-        throw new Error(`Transaction ${processedTx.hash} invalid after processing public functions`);
-      } else {
-        // We have no validator and assume this call should blindly process txs with duplicates being caught later
-        this.log.warn(`Detected duplicate nullifier after public processing for: ${processedTx.hash}.`);
-      }
+    } catch (cause) {
+      throw new Error(`Transaction ${processedTx.hash} failed with duplicate nullifiers`, { cause });
     }
 
-    // The only public data write should be for fee payment
-    await this.db.sequentialInsert(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      processedTx.txEffect.publicDataWrites.map(x => x.toBuffer()),
-    );
     const treeInsertionEnd = process.hrtime.bigint();
     this.metrics.recordTreeInsertions(Number(treeInsertionEnd - treeInsertionStart) / 1_000);
   }
 
-  /** Processes the given tx within deadline. Returns timeout if deadline is hit. */
+  /** Processes the given tx within deadline or until the signal is aborted. */
   private async processTxWithinDeadline(
     tx: Tx,
-    deadline?: Date,
-  ): Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> {
-    const processFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> = tx.hasPublicCalls()
-      ? () => this.processTxWithPublicCalls(tx)
-      : () => this.processPrivateOnlyTx(tx);
+    deadline: Date | undefined,
+    signal: AbortSignal | undefined,
+  ): Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined, DebugLog[]]> {
+    const innerProcessFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined, DebugLog[]]> =
+      tx.hasPublicCalls() ? () => this.processTxWithPublicCalls(tx) : () => this.processPrivateOnlyTx(tx);
+
+    // Fake a delay per tx if instructed (used for tests)
+    const fakeDelayPerTxMs = this.opts.fakeProcessingDelayPerTxMs;
+    const processFn =
+      fakeDelayPerTxMs && fakeDelayPerTxMs > 0
+        ? async () => {
+            const result = await innerProcessFn();
+            this.log.warn(`Sleeping ${fakeDelayPerTxMs}ms after processing tx ${tx.getTxHash().toString()}`);
+            await sleep(fakeDelayPerTxMs);
+            return result;
+          }
+        : innerProcessFn;
 
-    if (!deadline) {
+    const processingSignal = this.getProcessingSignal(tx, deadline, signal);
+    if (!processingSignal) {
       return await processFn();
     }
 
-    const txHash = await tx.getTxHash();
+    return await execWithSignal(
+      () => processFn(),
+      processingSignal,
+      signal =>
+        signal.reason?.name === 'TimeoutError' ? new PublicProcessorTimeoutError() : new PublicProcessorAbortError(),
+    );
+  }
+
+  private getProcessingSignal(tx: Tx, deadline: Date | undefined, signal: AbortSignal | undefined) {
+    if (!deadline) {
+      return signal;
+    }
+
     const timeout = +deadline - this.dateProvider.now();
     if (timeout <= 0) {
       throw new PublicProcessorTimeoutError();
     }
 
+    const txHash = tx.getTxHash();
     this.log.debug(`Processing tx ${txHash.toString()} within ${timeout}ms`, {
       deadline: deadline.toISOString(),
       now: new Date(this.dateProvider.now()).toISOString(),
       txHash,
     });
 
-    return await executeTimeout(
-      () => processFn(),
-      timeout,
-      () => new PublicProcessorTimeoutError(),
-    );
+    const timeoutSignal = AbortSignal.timeout(timeout);
+    return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
   }
 
   /**
@@ -419,14 +535,16 @@ export class PublicProcessor implements Traceable {
    * This is used in private only txs, since for txs with public calls
    * the avm handles the fee payment itself.
    */
-  private async getFeePaymentPublicDataWrite(txFee: Fr, feePayer: AztecAddress): Promise<PublicDataWrite> {
+  private async performFeePaymentPublicDataWrite(txFee: Fr, feePayer: AztecAddress): Promise<PublicDataWrite> {
     const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
     const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
     const leafSlot = await computeFeePayerBalanceLeafSlot(feePayer);
+    // This high-level db is used as a convenient helper. It could be done with the merkleTree directly.
+    const treesDB = new PublicTreesDB(this.guardedMerkleTree);
 
     this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${feePayer}`);
 
-    const balance = await this.worldStateDB.storageRead(feeJuiceAddress, balanceSlot);
+    const balance = await treesDB.storageRead(feeJuiceAddress, balanceSlot);
 
     if (balance.lt(txFee)) {
       throw new Error(
@@ -435,87 +553,96 @@ export class PublicProcessor implements Traceable {
     }
 
     const updatedBalance = balance.sub(txFee);
-    await this.worldStateDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
+    await treesDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
 
     return new PublicDataWrite(leafSlot, updatedBalance);
   }
 
-  @trackSpan('PublicProcessor.processPrivateOnlyTx', async (tx: Tx) => ({
-    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
+  @trackSpan('PublicProcessor.processPrivateOnlyTx', (tx: Tx) => ({
+    [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
-  private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx, undefined]> {
+  private async processPrivateOnlyTx(tx: Tx): Promise<[ProcessedTx, undefined, DebugLog[]]> {
     const gasFees = this.globalVariables.gasFees;
-    const transactionFee = tx.data.gasUsed.computeFee(gasFees);
+    const transactionFee = computeTransactionFee(gasFees, tx.data.constants.txContext.gasSettings, tx.data.gasUsed);
 
-    const feePaymentPublicDataWrite = await this.getFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
+    const feePaymentPublicDataWrite = await this.performFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
 
-    const processedTx = await makeProcessedTxFromPrivateOnlyTx(
+    const processedTx = makeProcessedTxFromPrivateOnlyTx(
       tx,
       transactionFee,
       feePaymentPublicDataWrite,
       this.globalVariables,
     );
 
-    const siloedContractClassLogs = await tx.filterContractClassLogs(
-      tx.data.getNonEmptyContractClassLogsHashes(),
-      true,
+    this.metrics.recordClassPublication(
+      ...tx
+        .getContractClassLogs()
+        .filter(log => ContractClassPublishedEvent.isContractClassPublishedEvent(log))
+        .map(log => ContractClassPublishedEvent.fromLog(log)),
     );
 
-    this.metrics.recordClassRegistration(
-      ...siloedContractClassLogs
-        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
-        .map(log => ContractClassRegisteredEvent.fromLog(log)),
-    );
-    return [processedTx, undefined];
+    // Fee payment insertion has already been done. Do the rest.
+    await this.doTreeInsertionsForPrivateOnlyTx(processedTx);
+
+    this.contractsDB.addNewContracts(tx);
+
+    return [processedTx, undefined, []];
   }
 
-  @trackSpan('PublicProcessor.processTxWithPublicCalls', async tx => ({
-    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
+  @trackSpan('PublicProcessor.processTxWithPublicCalls', tx => ({
+    [Attributes.TX_HASH]: tx.getTxHash().toString(),
   }))
-  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[], DebugLog[]]> {
     const timer = new Timer();
 
-    const { avmProvingRequest, gasUsed, revertCode, revertReason, processedPhases } =
-      await this.publicTxSimulator.simulate(tx);
-
-    if (!avmProvingRequest) {
-      this.metrics.recordFailedTx();
-      throw new Error('Avm proving result was not generated.');
-    }
-
-    processedPhases.forEach(phase => {
-      if (phase.reverted) {
-        this.metrics.recordRevertedPhase(phase.phase);
-      } else {
-        this.metrics.recordPhaseDuration(phase.phase, phase.durationMs);
-      }
-    });
-
-    const siloedContractClassLogs = await tx.filterContractClassLogs(
-      tx.data.getNonEmptyContractClassLogsHashes(),
-      true,
-    );
-
-    this.metrics.recordClassRegistration(
-      ...siloedContractClassLogs
-        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
-        .map(log => ContractClassRegisteredEvent.fromLog(log)),
+    const result = await this.publicTxSimulator.simulate(tx);
+    // TODO: use the callStackMetadata here to extract more data about public execution
+    const { hints, publicInputs, publicTxEffect, gasUsed, revertCode /*callStackMetadata*/ } = result;
+
+    const contractClassLogs = revertCode.isOK()
+      ? tx.getContractClassLogs()
+      : tx.getSplitContractClassLogs(false /* revertible */);
+    this.metrics.recordClassPublication(
+      ...contractClassLogs
+        .filter(log => ContractClassPublishedEvent.isContractClassPublishedEvent(log))
+        .map(log => ContractClassPublishedEvent.fromLog(log)),
     );
 
-    const phaseCount = processedPhases.length;
+    // TODO(fcarreiro): remove phase count metric.
     const durationMs = timer.ms();
-    this.metrics.recordTx(phaseCount, durationMs, gasUsed.publicGas);
+    this.metrics.recordTx(/*phaseCount=*/ 1, durationMs, gasUsed.publicGas);
 
-    const processedTx = await makeProcessedTxFromTxWithPublicCalls(
+    // Extract the return values from the call stack metadata.
+    const appLogicReturnValues: NestedProcessReturnValues[] = result.getAppLogicReturnValues();
+    // Extract the revert reason from the call stack metadata.
+    const revertReason = result.findRevertReason();
+    // Create proving request if we have hints and public inputs.
+    const avmProvingRequest =
+      hints && publicInputs ? PublicProcessor.generateProvingRequest(publicInputs, hints) : undefined;
+
+    const processedTx = makeProcessedTxFromTxWithPublicCalls(
       tx,
+      this.globalVariables,
       avmProvingRequest,
+      publicTxEffect,
       gasUsed,
       revertCode,
       revertReason,
     );
 
-    const returnValues = processedPhases.find(({ phase }) => phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
+    return [processedTx, appLogicReturnValues, result.logs ?? []];
+  }
 
-    return [processedTx, returnValues];
+  /**
+   * Generate the proving request for the AVM circuit.
+   */
+  private static generateProvingRequest(
+    publicInputs: AvmCircuitPublicInputs,
+    hints: AvmExecutionHints = AvmExecutionHints.empty(),
+  ): AvmProvingRequest {
+    return {
+      type: ProvingRequestType.PUBLIC_VM,
+      inputs: new AvmCircuitInputs(hints, publicInputs),
+    };
   }
 }