@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/public/public_processor/public_processor.ts

@@ -1,25 +1,39 @@
 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 { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
-import { type DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider, Timer, elapsed, executeTimeout } 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 { 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,8 +47,15 @@ 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';
 
 /**
@@ -43,13 +64,12 @@ import { PublicProcessorMetrics } from './public_processor_metrics.js';
 export class PublicProcessorFactory {
   constructor(
     private contractDataSource: ContractDataSource,
-    private dateProvider: DateProvider,
-    private telemetryClient: TelemetryClient = getTelemetryClient(),
+    private dateProvider: DateProvider = new DateProvider(),
+    protected telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {}
 
   /**
    * 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.
    * @returns A new instance of a PublicProcessor.
@@ -57,22 +77,17 @@ export class PublicProcessorFactory {
   public create(
     merkleTree: MerkleTreeWriteOperations,
     globalVariables: GlobalVariables,
-    skipFeeEnforcement: boolean,
+    config: PublicSimulatorConfig,
   ): PublicProcessor {
-    const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
-    const publicTxSimulator = this.createPublicTxSimulator(
-      merkleTree,
-      worldStateDB,
-      globalVariables,
-      /*doMerkleOperations=*/ true,
-      skipFeeEnforcement,
-      this.telemetryClient,
-    );
+    const contractsDB = new PublicContractsDB(this.contractDataSource);
+
+    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,
@@ -80,21 +95,12 @@ export class PublicProcessorFactory {
   }
 
   protected createPublicTxSimulator(
-    db: MerkleTreeWriteOperations,
-    worldStateDB: WorldStateDB,
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
-    doMerkleOperations: boolean,
-    skipFeeEnforcement: boolean,
-    telemetryClient: TelemetryClient,
-  ) {
-    return new PublicTxSimulator(
-      db,
-      worldStateDB,
-      globalVariables,
-      doMerkleOperations,
-      skipFeeEnforcement,
-      telemetryClient,
-    );
+    config?: Partial<PublicTxSimulatorConfig>,
+  ): PublicTxSimulatorInterface {
+    return new TelemetryCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, this.telemetryClient, config);
   }
 }
 
@@ -111,14 +117,16 @@ 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 opts: Pick<SequencerConfig, 'fakeProcessingDelayPerTxMs' | 'fakeThrowAfterProcessingTxCount'> = {},
   ) {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
   }
@@ -130,26 +138,19 @@ 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[]]> {
+    const { maxTransactions, maxBlockSize, deadline, maxBlockGas, maxBlobFields } = limits;
+    const { preprocessValidator, nullifierCache } = validator;
     const result: ProcessedTx[] = [];
+    const usedTxs: Tx[] = [];
     const failed: FailedTx[] = [];
     const timer = new Timer();
 
@@ -157,8 +158,9 @@ export class PublicProcessor implements Traceable {
     let returns: NestedProcessReturnValues[] = [];
     let totalPublicGas = new Gas(0, 0);
     let totalBlockGas = new Gas(0, 0);
+    let totalBlobFields = 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.`);
@@ -172,8 +174,8 @@ export class PublicProcessor implements Traceable {
       }
 
       // Skip this tx if it'd exceed max block size
-      const txHash = (await origTx.getTxHash()).toString();
-      const preTxSizeInBytes = origTx.getEstimatedPrivateTxEffectsSize();
+      const txHash = tx.getTxHash().toString();
+      const preTxSizeInBytes = tx.getEstimatedPrivateTxEffectsSize();
       if (maxBlockSize !== undefined && totalSizeInBytes + preTxSizeInBytes > maxBlockSize) {
         this.log.warn(`Skipping processing of tx ${txHash} sized ${preTxSizeInBytes} bytes due to block size limit`, {
           txHash,
@@ -185,7 +187,7 @@ export class PublicProcessor implements Traceable {
       }
 
       // Skip this tx if its gas limit would exceed the block gas limit
-      const txGasLimit = origTx.data.constants.txContext.gasSettings.gasLimits;
+      const txGasLimit = tx.data.constants.txContext.gasSettings.gasLimits;
       if (maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
         this.log.warn(`Skipping processing of tx ${txHash} due to block gas limit`, {
           txHash,
@@ -196,22 +198,19 @@ 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}`);
+          this.log.debug(`Skipping tx ${txHash.toString()} due to pre-process validation: ${reason}`);
           returns.push(new NestedProcessReturnValues([]));
           continue;
         } else {
@@ -222,15 +221,27 @@ 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);
 
+        // 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`);
+        }
+
+        const txBlobFields = processedTx.txEffect.getNumBlobFields();
+
         // If the actual size of this tx would exceed block size, skip it
-        const txSize = processedTx.txEffect.getDASize();
+        const txSize = txBlobFields * Fr.SIZE_IN_BYTES;
         if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
-          this.log.warn(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
+          this.log.debug(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
             txHash,
             sizeInBytes: txSize,
             totalSizeInBytes,
@@ -238,63 +249,91 @@ export class PublicProcessor implements Traceable {
           });
           // 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();
+        // If the actual blob fields of this tx would exceed the limit, skip it
+        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,
+            },
+          );
+          // Need to revert the checkpoint here and don't go any further
+          await checkpoint.revert();
+          this.contractsDB.revertCheckpoint();
+          continue;
         }
 
+        // 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);
 
         totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
         totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
         totalSizeInBytes += txSize;
+        totalBlobFields += txBlobFields;
       } 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.`);
+          // We hit the transaction execution deadline.
+          // There may still be a transaction executing on a worker thread (C++ via NAPI).
+          // Signal cancellation AND WAIT for the simulation to actually stop.
+          // This is critical because C++ might be in the middle of a slow operation (e.g., pad_trees)
+          // and won't check the cancellation flag until that operation completes.
+          // Without waiting, we'd proceed to revert checkpoints while C++ is still writing to state.
+          // Wait for C++ to stop gracefully.
+          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.
+
+          // First we revert a checkpoint as managed by the ForkCheckpoint. This will revert whatever is the current checkpoint
+          // which may not be the one originally created by this object. But that is ok, we do this to fulfil the ForkCheckpoint
+          // lifecycle expectations and ensure it doesn't attempt to commit later on.
+          await checkpoint.revert();
+
+          // Now we want to revert any/all remaining checkpoints, destroying any outstanding state updates.
+          // This needs to be done directly on the underlying fork as the guarded fork has been stopped.
+          await this.guardedMerkleTree.getUnderlyingFork().revertAllCheckpoints();
+
+          // 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
+        await checkpoint.revert();
+        await this.guardedMerkleTree.getUnderlyingFork().revertAllCheckpoints();
+        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();
+        this.contractsDB.commitCheckpointOkIfNone();
       }
     }
 
@@ -310,17 +349,33 @@ export class PublicProcessor implements Traceable {
       totalSizeInBytes,
     });
 
-    return [result, failed, returns];
+    return [result, failed, usedTxs, returns];
   }
 
-  @trackSpan('PublicProcessor.processTx', async tx => ({ [Attributes.TX_HASH]: (await tx.getTxHash()).toString() }))
-  private async processTx(tx: Tx, deadline?: Date): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+  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): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
 
     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(),
@@ -341,10 +396,7 @@ export class PublicProcessor implements Traceable {
     return [processedTx, returnValues ?? []];
   }
 
-  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,31 +405,20 @@ 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);
   }
@@ -385,17 +426,29 @@ export class PublicProcessor implements Traceable {
   /** Processes the given tx within deadline. Returns timeout if deadline is hit. */
   private async processTxWithinDeadline(
     tx: Tx,
-    deadline?: Date,
+    deadline: Date | undefined,
   ): Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> {
-    const processFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> = tx.hasPublicCalls()
+    const innerProcessFn: () => Promise<[ProcessedTx, NestedProcessReturnValues[] | undefined]> = 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) {
       return await processFn();
     }
 
-    const txHash = await tx.getTxHash();
+    const txHash = tx.getTxHash();
     const timeout = +deadline - this.dateProvider.now();
     if (timeout <= 0) {
       throw new PublicProcessorTimeoutError();
@@ -419,14 +472,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 +490,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]> {
     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)),
-    );
+    // Fee payment insertion has already been done. Do the rest.
+    await this.doTreeInsertionsForPrivateOnlyTx(processedTx);
+
+    await 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[]]> {
     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,
+    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)),
     );
 
-    this.metrics.recordClassRegistration(
-      ...siloedContractClassLogs
-        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
-        .map(log => ContractClassRegisteredEvent.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];
+  }
 
-    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),
+    };
   }
 }