@aztec/simulator 0.85.0 → 0.86.0

package/src/public/public_db_sources.ts

@@ -2,7 +2,6 @@ import { NULLIFIER_SUBTREE_HEIGHT, PUBLIC_DATA_SUBTREE_HEIGHT } from '@aztec/con
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import type { IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
 import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
 import { ContractInstanceDeployedEvent } from '@aztec/protocol-contracts/instance-deployer';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
@@ -15,18 +14,17 @@ import {
   computePublicBytecodeCommitment,
 } from '@aztec/stdlib/contract';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
-import type {
-  BatchInsertionResult,
-  IndexedTreeId,
-  MerkleTreeLeafType,
-  MerkleTreeWriteOperations,
-  SequentialInsertionResult,
-  TreeInfo,
-} from '@aztec/stdlib/interfaces/server';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
 import type { PublicDBAccessStats } from '@aztec/stdlib/stats';
-import { MerkleTreeId, NullifierLeaf, PublicDataTreeLeaf, type PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
-import type { BlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
+import {
+  MerkleTreeId,
+  NullifierLeaf,
+  PublicDataTreeLeaf,
+  type PublicDataTreeLeafPreimage,
+  getTreeName,
+} from '@aztec/stdlib/trees';
+import { TreeSnapshots, type Tx } from '@aztec/stdlib/tx';
 
 import type { PublicContractsDBInterface, PublicStateDBInterface } from './db_interfaces.js';
 import { TxContractCache } from './tx_contract_cache.js';
@@ -276,172 +274,69 @@ export class PublicContractsDB implements PublicContractsDBInterface {
 }
 
 /**
- * Proxy class that forwards all merkle tree operations to the underlying object.
+ * A high-level class that provides access to the merkle trees.
  *
- * NOTE: It might be possible to prune this to just the methods used in public.
- * Then we'd need to define a new interface, instead of MerkleTreeWriteOperations,
- * to be used by all our classes (that could be PublicStateDBInterface).
- */
-class ForwardMerkleTree implements MerkleTreeWriteOperations {
-  constructor(private readonly operations: MerkleTreeWriteOperations) {}
-
-  getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {
-    return this.operations.getTreeInfo(treeId);
-  }
-
-  getStateReference(): Promise<StateReference> {
-    return this.operations.getStateReference();
-  }
-
-  getInitialHeader(): BlockHeader {
-    return this.operations.getInitialHeader();
-  }
-
-  getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>> {
-    return this.operations.getSiblingPath(treeId, index);
-  }
-
-  getPreviousValueIndex<ID extends IndexedTreeId>(
-    treeId: ID,
-    value: bigint,
-  ): Promise<
-    | {
-        index: bigint;
-        alreadyPresent: boolean;
-      }
-    | undefined
-  > {
-    return this.operations.getPreviousValueIndex(treeId, value);
-  }
-
-  getLeafPreimage<ID extends IndexedTreeId>(treeId: ID, index: bigint): Promise<IndexedTreeLeafPreimage | undefined> {
-    return this.operations.getLeafPreimage(treeId, index);
-  }
-
-  findLeafIndices<ID extends MerkleTreeId>(
-    treeId: ID,
-    values: MerkleTreeLeafType<ID>[],
-  ): Promise<(bigint | undefined)[]> {
-    return this.operations.findLeafIndices(treeId, values);
-  }
-
-  findLeafIndicesAfter<ID extends MerkleTreeId>(
-    treeId: ID,
-    values: MerkleTreeLeafType<ID>[],
-    startIndex: bigint,
-  ): Promise<(bigint | undefined)[]> {
-    return this.operations.findLeafIndicesAfter(treeId, values, startIndex);
-  }
-
-  getLeafValue<ID extends MerkleTreeId>(
-    treeId: ID,
-    index: bigint,
-  ): Promise<MerkleTreeLeafType<typeof treeId> | undefined> {
-    return this.operations.getLeafValue(treeId, index);
-  }
-
-  getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(
-    treeId: ID,
-    leafIndices: bigint[],
-  ): Promise<(bigint | undefined)[]> {
-    return this.operations.getBlockNumbersForLeafIndices(treeId, leafIndices);
-  }
-
-  createCheckpoint(): Promise<void> {
-    return this.operations.createCheckpoint();
-  }
-
-  commitCheckpoint(): Promise<void> {
-    return this.operations.commitCheckpoint();
-  }
-
-  revertCheckpoint(): Promise<void> {
-    return this.operations.revertCheckpoint();
-  }
-
-  appendLeaves<ID extends MerkleTreeId>(treeId: ID, leaves: MerkleTreeLeafType<ID>[]): Promise<void> {
-    return this.operations.appendLeaves(treeId, leaves);
-  }
-
-  updateArchive(header: BlockHeader): Promise<void> {
-    return this.operations.updateArchive(header);
-  }
-
-  batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number, ID extends IndexedTreeId>(
-    treeId: ID,
-    leaves: Buffer[],
-    subtreeHeight: number,
-  ): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>> {
-    return this.operations.batchInsert(treeId, leaves, subtreeHeight);
-  }
-
-  sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(
-    treeId: ID,
-    leaves: Buffer[],
-  ): Promise<SequentialInsertionResult<TreeHeight>> {
-    return this.operations.sequentialInsert(treeId, leaves);
-  }
-
-  close(): Promise<void> {
-    return this.operations.close();
-  }
-}
-
-/**
- * A class that provides access to the merkle trees, and other helper methods.
+ * This class is just a helper wrapper around a merkle db. Anything that you can do with it
+ * can also be done directly with the merkle db. This class should NOT be exposed or used
+ * outside of `simulator/src/public`.
+ *
+ * NOTE: This class is currently written in such a way that it would generate the
+ * necessary hints if used with a hinting merkle db. This is a bit of a leak of concepts.
+ * Eventually we can have everything depend on a config/factory at the TxSimulator level
+ * to decide whether to use hints or not (same with tracing, etc).
  */
-export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInterface {
+export class PublicTreesDB implements PublicStateDBInterface {
   private logger = createLogger('simulator:public-trees-db');
 
-  constructor(db: MerkleTreeWriteOperations) {
-    super(db);
-  }
+  constructor(private readonly db: MerkleTreeWriteOperations) {}
 
-  /**
-   * Reads a value from public storage, returning zero if none.
-   * @param contract - Owner of the storage.
-   * @param slot - Slot to read in the contract storage.
-   * @returns The current value in the storage slot.
-   */
   public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
+    const timer = new Timer();
     const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
 
-    const lowLeafResult = await this.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
     if (!lowLeafResult) {
       throw new Error('Low leaf not found');
     }
 
-    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
-    await this.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
     // Unconditionally fetching the preimage for the hints. Move it to the hinting layer?
-    const preimage = (await this.getLeafPreimage(
+    const preimage = (await this.db.getLeafPreimage(
       MerkleTreeId.PUBLIC_DATA_TREE,
       lowLeafResult.index,
     )) as PublicDataTreeLeafPreimage;
 
-    return lowLeafResult.alreadyPresent ? preimage.leaf.value : Fr.ZERO;
+    const result = lowLeafResult.alreadyPresent ? preimage.leaf.value : Fr.ZERO;
+    this.logger.debug(`Storage read (contract=${contract}, slot=${slot}, value=${result})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'storage-read',
+    } satisfies PublicDBAccessStats);
+
+    return result;
   }
 
-  /**
-   * Records a write to public storage.
-   * @param contract - Owner of the storage.
-   * @param slot - Slot to read in the contract storage.
-   * @param newValue - The new value to store.
-   * @returns The slot of the written leaf in the public data tree.
-   */
   public async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
+    const timer = new Timer();
     const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
     const publicDataWrite = new PublicDataWrite(leafSlot, newValue);
-    await this.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()]);
+    await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()]);
+
+    this.logger.debug(`Storage write (contract=${contract}, slot=${slot}, value=${newValue})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'storage-write',
+    } satisfies PublicDBAccessStats);
   }
 
   public async getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined> {
     const timer = new Timer();
-    const leafValue = await this.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
-    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
-    await this.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+    const leafValue = await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
 
-    this.logger.debug(`[DB] Fetched L1 to L2 message leaf value`, {
+    this.logger.debug(`Fetched L1 to L2 message leaf value (leafIndex=${leafIndex}, value=${leafValue})`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-l1-to-l2-message-leaf-value',
@@ -451,11 +346,11 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
 
   public async getNoteHash(leafIndex: bigint): Promise<Fr | undefined> {
     const timer = new Timer();
-    const leafValue = await this.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
-    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
-    await this.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+    const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
 
-    this.logger.debug(`[DB] Fetched note hash leaf value`, {
+    this.logger.debug(`Fetched note hash leaf value (leafIndex=${leafIndex}, value=${leafValue})`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-note-hash',
@@ -463,19 +358,30 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
     return leafValue;
   }
 
+  public async writeNoteHash(noteHash: Fr): Promise<void> {
+    const timer = new Timer();
+    await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [noteHash]);
+
+    this.logger.debug(`Wrote note hash (noteHash=${noteHash})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'write-note-hash',
+    } satisfies PublicDBAccessStats);
+  }
+
   public async checkNullifierExists(nullifier: Fr): Promise<boolean> {
     const timer = new Timer();
-    const lowLeafResult = await this.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
     if (!lowLeafResult) {
       throw new Error('Low leaf not found');
     }
-    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
-    await this.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
-    // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
-    await this.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
     const exists = lowLeafResult.alreadyPresent;
 
-    this.logger.debug(`[DB] Checked nullifier exists`, {
+    this.logger.debug(`Checked nullifier exists (nullifier=${nullifier}, exists=${exists})`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'check-nullifier-exists',
@@ -483,30 +389,71 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
     return exists;
   }
 
+  public async writeNullifier(siloedNullifier: Fr): Promise<void> {
+    const timer = new Timer();
+    await this.db.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()]);
+
+    this.logger.debug(`Wrote nullifier (nullifier=${siloedNullifier})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'write-nullifier',
+    } satisfies PublicDBAccessStats);
+  }
+
   public async padTree(treeId: MerkleTreeId, leavesToInsert: number): Promise<void> {
+    const timer = new Timer();
+
     switch (treeId) {
       // Indexed trees.
       case MerkleTreeId.NULLIFIER_TREE:
-        await this.batchInsert(
+        await this.db.batchInsert(
           treeId,
           Array(leavesToInsert).fill(NullifierLeaf.empty().toBuffer()),
           NULLIFIER_SUBTREE_HEIGHT,
         );
         break;
       case MerkleTreeId.PUBLIC_DATA_TREE:
-        await this.batchInsert(
+        await this.db.batchInsert(
           treeId,
           Array(leavesToInsert).fill(PublicDataTreeLeaf.empty().toBuffer()),
           PUBLIC_DATA_SUBTREE_HEIGHT,
         );
         break;
-      // Non-indexed trees.
+      // Append-only trees.
       case MerkleTreeId.L1_TO_L2_MESSAGE_TREE:
       case MerkleTreeId.NOTE_HASH_TREE:
-        await this.appendLeaves(treeId, Array(leavesToInsert).fill(Fr.ZERO));
+        await this.db.appendLeaves(treeId, Array(leavesToInsert).fill(Fr.ZERO));
         break;
       default:
         throw new Error(`Padding not supported for tree ${treeId}`);
     }
+
+    this.logger.debug(`Padded tree (tree=${getTreeName(treeId)}, leavesToInsert=${leavesToInsert})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'pad-tree',
+    } satisfies PublicDBAccessStats);
+  }
+
+  public async createCheckpoint(): Promise<void> {
+    await this.db.createCheckpoint();
+  }
+
+  public async commitCheckpoint(): Promise<void> {
+    await this.db.commitCheckpoint();
+  }
+
+  public async revertCheckpoint(): Promise<void> {
+    await this.db.revertCheckpoint();
+  }
+
+  public async getTreeSnapshots(): Promise<TreeSnapshots> {
+    const stateReference = await this.db.getStateReference();
+    return new TreeSnapshots(
+      stateReference.l1ToL2MessageTree,
+      stateReference.partial.noteHashTree,
+      stateReference.partial.nullifierTree,
+      stateReference.partial.publicDataTree,
+    );
   }
 }

package/src/public/public_processor/public_processor.ts

@@ -44,7 +44,7 @@ export class PublicProcessorFactory {
   constructor(
     private contractDataSource: ContractDataSource,
     private dateProvider: DateProvider,
-    private telemetryClient: TelemetryClient = getTelemetryClient(),
+    protected telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {}
 
   /**
@@ -59,10 +59,9 @@ export class PublicProcessorFactory {
     globalVariables: GlobalVariables,
     skipFeeEnforcement: boolean,
   ): PublicProcessor {
-    const treesDB = new PublicTreesDB(merkleTree);
     const contractsDB = new PublicContractsDB(this.contractDataSource);
     const publicTxSimulator = this.createPublicTxSimulator(
-      treesDB,
+      merkleTree,
       contractsDB,
       globalVariables,
       /*doMerkleOperations=*/ true,
@@ -71,7 +70,7 @@ export class PublicProcessorFactory {
 
     return new PublicProcessor(
       globalVariables,
-      treesDB,
+      merkleTree,
       contractsDB,
       publicTxSimulator,
       this.dateProvider,
@@ -80,14 +79,14 @@ export class PublicProcessorFactory {
   }
 
   protected createPublicTxSimulator(
-    treesDB: PublicTreesDB,
+    merkleTree: MerkleTreeWriteOperations,
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
     skipFeeEnforcement: boolean,
   ): PublicTxSimulator {
     return new TelemetryPublicTxSimulator(
-      treesDB,
+      merkleTree,
       contractsDB,
       globalVariables,
       doMerkleOperations,
@@ -110,9 +109,10 @@ class PublicProcessorTimeoutError extends Error {
  */
 export class PublicProcessor implements Traceable {
   private metrics: PublicProcessorMetrics;
+
   constructor(
     protected globalVariables: GlobalVariables,
-    protected treesDB: PublicTreesDB,
+    private merkleTree: MerkleTreeWriteOperations,
     protected contractsDB: PublicContractsDB,
     protected publicTxSimulator: PublicTxSimulator,
     private dateProvider: DateProvider,
@@ -221,7 +221,7 @@ 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.treesDB);
+      const checkpoint = await ForkCheckpoint.new(this.merkleTree);
 
       try {
         const [processedTx, returnValues] = await this.processTx(tx, deadline);
@@ -240,16 +240,8 @@ export class PublicProcessor implements Traceable {
           continue;
         }
 
-        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.contractsDB.addNewContracts(tx);
-          this.contractsDB.commitContractsForTx();
-        }
-
+        // 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);
         returns = returns.concat(returnValues);
@@ -332,12 +324,12 @@ 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.treesDB.appendLeaves(
+    await this.merkleTree.appendLeaves(
       MerkleTreeId.NOTE_HASH_TREE,
       padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
     );
     try {
-      await this.treesDB.batchInsert(
+      await this.merkleTree.batchInsert(
         MerkleTreeId.NULLIFIER_TREE,
         padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
         NULLIFIER_SUBTREE_HEIGHT,
@@ -352,11 +344,6 @@ export class PublicProcessor implements Traceable {
       }
     }
 
-    // The only public data write should be for fee payment
-    await this.treesDB.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);
   }
@@ -398,14 +385,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.merkleTree);
 
     this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${feePayer}`);
 
-    const balance = await this.treesDB.storageRead(feeJuiceAddress, balanceSlot);
+    const balance = await treesDB.storageRead(feeJuiceAddress, balanceSlot);
 
     if (balance.lt(txFee)) {
       throw new Error(
@@ -414,7 +403,7 @@ export class PublicProcessor implements Traceable {
     }
 
     const updatedBalance = balance.sub(txFee);
-    await this.treesDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
+    await treesDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
 
     return new PublicDataWrite(leafSlot, updatedBalance);
   }
@@ -426,7 +415,7 @@ export class PublicProcessor implements Traceable {
     const gasFees = this.globalVariables.gasFees;
     const transactionFee = tx.data.gasUsed.computeFee(gasFees);
 
-    const feePaymentPublicDataWrite = await this.getFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
+    const feePaymentPublicDataWrite = await this.performFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
 
     const processedTx = await makeProcessedTxFromPrivateOnlyTx(
       tx,
@@ -445,6 +434,15 @@ export class PublicProcessor implements Traceable {
         .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
         .map(log => ContractClassRegisteredEvent.fromLog(log)),
     );
+
+    // Fee payment insertion has already been done. Do the rest.
+    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.contractsDB.addNewContracts(tx);
+    this.contractsDB.commitContractsForTx();
+
     return [processedTx, undefined];
   }
 

package/src/public/public_tx_simulator/measured_public_tx_simulator.ts

@@ -2,11 +2,12 @@ import type { Fr } from '@aztec/foundation/fields';
 import { Timer } from '@aztec/foundation/timer';
 import type { Gas } from '@aztec/stdlib/gas';
 import type { AvmSimulationStats } from '@aztec/stdlib/stats';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import { type GlobalVariables, PublicCallRequestWithCalldata, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
 
 import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
 import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
-import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
+import type { PublicContractsDB } from '../public_db_sources.js';
 import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { PublicTxContext } from './public_tx_context.js';
 import { type ProcessedPhase, type PublicTxResult, PublicTxSimulator } from './public_tx_simulator.js';
@@ -16,14 +17,14 @@ import { type ProcessedPhase, type PublicTxResult, PublicTxSimulator } from './p
  */
 export class MeasuredPublicTxSimulator extends PublicTxSimulator {
   constructor(
-    treesDB: PublicTreesDB,
+    merkleTree: MerkleTreeWriteOperations,
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean = false,
     skipFeeEnforcement: boolean = false,
     protected readonly metrics: ExecutorMetricsInterface,
   ) {
-    super(treesDB, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement);
+    super(merkleTree, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement);
   }
 
   public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {