@aztec/simulator 0.80.0 → 0.82.0

package/src/public/avm/journal/nullifiers.ts

@@ -1,6 +1,6 @@
 import type { Fr } from '@aztec/foundation/fields';
 
-import type { WorldStateDB } from '../../public_db_sources.js';
+import type { PublicTreesDB } from '../../public_db_sources.js';
 
 /**
  * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
@@ -10,7 +10,7 @@ import type { WorldStateDB } from '../../public_db_sources.js';
 export class NullifierManager {
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    private readonly hostNullifiers: WorldStateDB,
+    private readonly hostNullifiers: PublicTreesDB,
     /** Cache of siloed nullifiers. */
     private cache: Set<bigint> = new Set(),
     /** Parent nullifier manager to fall back on */

package/src/public/avm/journal/public_storage.ts

@@ -1,7 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { PublicStateDB } from '../../../common/db_interfaces.js';
+import type { PublicStateDBInterface } from '../../../common/db_interfaces.js';
 
 type PublicStorageReadResult = {
   value: Fr;
@@ -19,7 +19,7 @@ export class PublicStorage {
 
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    private readonly hostPublicStorage: PublicStateDB,
+    private readonly hostPublicStorage: PublicStateDBInterface,
     /** Parent's storage. Checked on this' cache-miss. */
     private readonly parent?: PublicStorage,
   ) {

package/src/public/avm/test_utils.ts

@@ -1,47 +1,34 @@
 import { Fr } from '@aztec/foundation/fields';
-import {
-  type ContractClassPublic,
-  type ContractInstanceWithAddress,
-  computePublicBytecodeCommitment,
-} from '@aztec/stdlib/contract';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import type { jest } from '@jest/globals';
 import { mock } from 'jest-mock-extended';
 
-import type { WorldStateDB } from '../../public/public_db_sources.js';
+import type { PublicContractsDB, PublicTreesDB } from '../../public/public_db_sources.js';
 import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
 
-export async function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
-  const commitment = await computePublicBytecodeCommitment(bytecode);
-  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
-}
-
 export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {
   (trace as jest.Mocked<PublicSideEffectTraceInterface>).fork.mockReturnValue(
     nestedTrace ?? mock<PublicSideEffectTraceInterface>(),
   );
 }
 
-export function mockStorageRead(worldStateDB: WorldStateDB, value: Fr) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockResolvedValue(value);
+export function mockStorageRead(worldStateDB: PublicTreesDB, value: Fr) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).storageRead.mockResolvedValue(value);
 }
 
 export function mockNoteHashCount(mockedTrace: PublicSideEffectTraceInterface, count: number) {
   (mockedTrace as jest.Mocked<PublicSideEffectTraceInterface>).getNoteHashCount.mockReturnValue(count);
 }
 
-export function mockStorageReadWithMap(worldStateDB: WorldStateDB, mockedStorage: Map<bigint, Fr>) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockImplementation((_address, slot) =>
+export function mockStorageReadWithMap(worldStateDB: PublicTreesDB, mockedStorage: Map<bigint, Fr>) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).storageRead.mockImplementation((_address, slot) =>
     Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),
   );
 }
 
-export function mockGetBytecodeCommitment(worldStateDB: WorldStateDB, commitment: Fr) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
-}
-
-export function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, value?: Fr) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getCommitmentValue.mockImplementation((index: bigint) => {
+export function mockNoteHashExists(worldStateDB: PublicTreesDB, _leafIndex: Fr, value?: Fr) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).getNoteHash.mockImplementation((index: bigint) => {
     if (index == _leafIndex.toBigInt()) {
       return Promise.resolve(value);
     } else {
@@ -51,17 +38,17 @@ export function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, v
   });
 }
 
-export function mockGetNullifierIndex(worldStateDB: WorldStateDB, leafIndex: Fr, _ignoredValue?: Fr) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+export function mockGetNullifierIndex(worldStateDB: PublicTreesDB, leafIndex: Fr, _ignoredValue?: Fr) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
 }
 
 export function mockL1ToL2MessageExists(
-  worldStateDB: WorldStateDB,
+  worldStateDB: PublicTreesDB,
   leafIndex: Fr,
   value: Fr,
   valueAtOtherIndices?: Fr,
 ) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
     if (index == leafIndex.toBigInt()) {
       return Promise.resolve(value);
     } else {
@@ -72,10 +59,14 @@ export function mockL1ToL2MessageExists(
   });
 }
 
-export function mockGetContractInstance(worldStateDB: WorldStateDB, contractInstance: ContractInstanceWithAddress) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getContractInstance.mockResolvedValue(contractInstance);
+export function mockGetContractInstance(contractsDB: PublicContractsDB, contractInstance: ContractInstanceWithAddress) {
+  (contractsDB as jest.Mocked<PublicContractsDB>).getContractInstance.mockResolvedValue(contractInstance);
+}
+
+export function mockGetContractClass(contractsDB: PublicContractsDB, contractClass: ContractClassPublic) {
+  (contractsDB as jest.Mocked<PublicContractsDB>).getContractClass.mockResolvedValue(contractClass);
 }
 
-export function mockGetContractClass(worldStateDB: WorldStateDB, contractClass: ContractClassPublic) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getContractClass.mockResolvedValue(contractClass);
+export function mockGetBytecodeCommitment(contractsDB: PublicContractsDB, commitment: Fr) {
+  (contractsDB as jest.Mocked<PublicContractsDB>).getBytecodeCommitment.mockResolvedValue(commitment);
 }

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -11,7 +11,7 @@ import { NativeWorldStateService } from '@aztec/world-state';
 import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
 import { getContractFunctionArtifact, getFunctionSelector } from '../avm/fixtures/index.js';
 import { SimpleContractDataSource } from '../avm/fixtures/simple_contract_data_source.js';
-import { WorldStateDB } from '../public_db_sources.js';
+import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import { type PublicTxResult, PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
 import { createTxForPublicCalls } from './index.js';
 
@@ -35,19 +35,14 @@ export type TestEnqueuedCall = {
 export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   private txCount = 0;
 
-  constructor(
-    private worldStateDB: WorldStateDB,
-    contractDataSource: SimpleContractDataSource,
-    merkleTrees: MerkleTreeWriteOperations,
-  ) {
-    super(contractDataSource, merkleTrees);
+  constructor(private merkleTree: MerkleTreeWriteOperations, contractDataSource: SimpleContractDataSource) {
+    super(contractDataSource, merkleTree);
   }
 
   public static async create(): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
-    const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-    return new PublicTxSimulationTester(worldStateDB, contractDataSource, merkleTrees);
+    const merkleTree = await (await NativeWorldStateService.tmp()).fork();
+    return new PublicTxSimulationTester(merkleTree, contractDataSource);
   }
 
   public async createTx(
@@ -137,7 +132,9 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     await this.setFeePayerBalance(feePayer);
 
-    const simulator = new PublicTxSimulator(this.merkleTrees, this.worldStateDB, globals, /*doMerkleOperations=*/ true);
+    const treesDB = new PublicTreesDB(this.merkleTree);
+    const contractsDB = new PublicContractsDB(this.contractDataSource);
+    const simulator = new PublicTxSimulator(treesDB, contractsDB, globals, /*doMerkleOperations=*/ true);
 
     const startTime = performance.now();
     const avmResult = await simulator.simulate(tx);
@@ -170,7 +167,7 @@ async function executionRequestForCall(
   return new PublicExecutionRequest(callContext, calldata);
 }
 
-function defaultGlobals() {
+export function defaultGlobals() {
   const globals = GlobalVariables.empty();
   globals.timestamp = TIMESTAMP;
   globals.gasFees = DEFAULT_GAS_FEES; // apply some nonzero default gas fees

package/src/public/hinting_db_sources.ts

@@ -0,0 +1,71 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import {
+  AvmBytecodeCommitmentHint,
+  AvmContractClassHint,
+  AvmContractInstanceHint,
+  type AvmExecutionHints,
+} from '@aztec/stdlib/avm';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import type { PublicContractsDBInterface } from '../server.js';
+
+/**
+ * A public contracts database that forwards requests and collects AVM hints.
+ */
+export class HintingPublicContractsDB implements PublicContractsDBInterface {
+  constructor(private readonly db: PublicContractsDBInterface, public readonly hints: AvmExecutionHints) {}
+
+  public async getContractInstance(
+    address: AztecAddress,
+    blockNumber: number,
+  ): Promise<ContractInstanceWithAddress | undefined> {
+    const instance = await this.db.getContractInstance(address, blockNumber);
+    if (instance) {
+      // We don't need to hint the block number because it doesn't change.
+      this.hints.contractInstances.push(
+        new AvmContractInstanceHint(
+          instance.address,
+          instance.salt,
+          instance.deployer,
+          instance.currentContractClassId,
+          instance.originalContractClassId,
+          instance.initializationHash,
+          instance.publicKeys,
+        ),
+      );
+    }
+    return instance;
+  }
+
+  public async getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined> {
+    const contractClass = await this.db.getContractClass(contractClassId);
+    if (contractClass) {
+      this.hints.contractClasses.push(
+        new AvmContractClassHint(
+          contractClass.id,
+          contractClass.artifactHash,
+          contractClass.privateFunctionsRoot,
+          contractClass.packedBytecode,
+        ),
+      );
+    }
+    return contractClass;
+  }
+
+  public async getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
+    const commitment = await this.db.getBytecodeCommitment(contractClassId);
+    if (commitment) {
+      this.hints.bytecodeCommitments.push(new AvmBytecodeCommitmentHint(contractClassId, commitment));
+    }
+    return commitment;
+  }
+
+  public async getDebugFunctionName(
+    contractAddress: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<string | undefined> {
+    return await this.db.getDebugFunctionName(contractAddress, selector);
+  }
+}

package/src/public/public_db_sources.ts

@@ -1,6 +1,7 @@
 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';
@@ -14,25 +15,29 @@ import {
 } from '@aztec/stdlib/contract';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import type {
-  MerkleTreeCheckpointOperations,
+  BatchInsertionResult,
+  IndexedTreeId,
+  MerkleTreeLeafType,
   MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
+  SequentialInsertionResult,
+  TreeInfo,
 } from '@aztec/stdlib/interfaces/server';
 import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
 import type { PublicDBAccessStats } from '@aztec/stdlib/stats';
 import { MerkleTreeId, type PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
-import type { Tx } from '@aztec/stdlib/tx';
+import type { BlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
 
-import type { PublicContractsDB, PublicStateDB } from '../common/db_interfaces.js';
+import type { PublicContractsDBInterface, PublicStateDBInterface } from '../common/db_interfaces.js';
 import { TxContractCache } from './tx_contract_cache.js';
 
 /**
- * Implements the PublicContractsDB using a ContractDataSource.
+ * Implements the PublicContractsDBInterface using a ContractDataSource.
  * Progressively records contracts in transaction as they are processed in a block.
  * Separates block-level contract information (from processed/included txs) from the
  * current tx's contract information (which may be cleared on tx revert/death).
  */
-export class ContractsDataSourcePublicDB implements PublicContractsDB {
+export class PublicContractsDB implements PublicContractsDBInterface {
   // Two caching layers for contract classes and instances.
   // Tx-level cache:
   //   - The current tx's new contract information is cached
@@ -210,13 +215,23 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     this.currentTxRevertibleCache.clear();
   }
 
-  public async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+  // TODO(fcarreiro/alvaro): This method currently needs a blockNumber. Since this class
+  // is only ever used for a given block, it should be possible to construct it with the
+  // block number and then forget about it. However, since this class (and interface) is
+  // currently more externally exposed than we'd want to, Facundo preferred to not add it
+  // to the constructor right now. If we can make this class more private, we should
+  // reconsider this. A litmus test is in how many places we need to initialize with a
+  // dummy block number (tests or not) and pass block numbers to `super`.
+  public async getContractInstance(
+    address: AztecAddress,
+    blockNumber: number,
+  ): Promise<ContractInstanceWithAddress | undefined> {
     // Check caches in order: tx revertible -> tx non-revertible -> block -> data source
     return (
       this.currentTxRevertibleCache.getInstance(address) ??
       this.currentTxNonRevertibleCache.getInstance(address) ??
       this.blockCache.getInstance(address) ??
-      (await this.dataSource.getContract(address))
+      (await this.dataSource.getContract(address, blockNumber))
     );
   }
 
@@ -261,38 +276,125 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
 }
 
 /**
- * A public state DB that reads and writes to the world state.
+ * Proxy class that forwards all merkle tree operations to the underlying object.
+ *
+ * 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).
  */
-export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicStateDB, MerkleTreeCheckpointOperations {
-  private logger = createLogger('simulator:world-state-db');
+class ForwardMerkleTree implements MerkleTreeWriteOperations {
+  constructor(private readonly operations: MerkleTreeWriteOperations) {}
 
-  constructor(public db: MerkleTreeWriteOperations, dataSource: ContractDataSource) {
-    super(dataSource);
+  getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {
+    return this.operations.getTreeInfo(treeId);
   }
 
-  /**
-   * Checkpoints the current fork state
-   */
-  public async createCheckpoint() {
-    await this.db.createCheckpoint();
+  getStateReference(): Promise<StateReference> {
+    return this.operations.getStateReference();
   }
 
-  /**
-   * Commits the current checkpoint
-   */
-  public async commitCheckpoint() {
-    await this.db.commitCheckpoint();
+  getInitialHeader(): BlockHeader {
+    return this.operations.getInitialHeader();
   }
 
-  /**
-   * Reverts the current checkpoint
-   */
-  public async revertCheckpoint() {
-    await this.db.revertCheckpoint();
+  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();
   }
 
-  public getMerkleInterface(): MerkleTreeWriteOperations {
-    return this.db;
+  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.
+ */
+export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInterface {
+  private logger = createLogger('simulator:public-trees-db');
+
+  constructor(public db: MerkleTreeWriteOperations) {
+    super(db);
   }
 
   /**
@@ -329,13 +431,13 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
     return leafValue;
   }
 
-  public async getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined> {
+  public async getNoteHash(leafIndex: bigint): Promise<Fr | undefined> {
     const timer = new Timer();
     const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
-    this.logger.debug(`[DB] Fetched commitment leaf value`, {
+    this.logger.debug(`[DB] Fetched note hash leaf value`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
-      operation: 'get-commitment-leaf-value',
+      operation: 'get-note-hash',
     } satisfies PublicDBAccessStats);
     return leafValue;
   }

package/src/public/public_processor/public_processor.ts

@@ -33,7 +33,7 @@ import {
 } from '@aztec/telemetry-client';
 import { ForkCheckpoint } from '@aztec/world-state/native';
 
-import { WorldStateDB } from '../public_db_sources.js';
+import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
 
@@ -59,10 +59,11 @@ export class PublicProcessorFactory {
     globalVariables: GlobalVariables,
     skipFeeEnforcement: boolean,
   ): PublicProcessor {
-    const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
+    const treesDB = new PublicTreesDB(merkleTree);
+    const contractsDB = new PublicContractsDB(this.contractDataSource);
     const publicTxSimulator = this.createPublicTxSimulator(
-      merkleTree,
-      worldStateDB,
+      treesDB,
+      contractsDB,
       globalVariables,
       /*doMerkleOperations=*/ true,
       skipFeeEnforcement,
@@ -70,9 +71,9 @@ export class PublicProcessorFactory {
     );
 
     return new PublicProcessor(
-      merkleTree,
       globalVariables,
-      worldStateDB,
+      treesDB,
+      contractsDB,
       publicTxSimulator,
       this.dateProvider,
       this.telemetryClient,
@@ -80,16 +81,16 @@ export class PublicProcessorFactory {
   }
 
   protected createPublicTxSimulator(
-    db: MerkleTreeWriteOperations,
-    worldStateDB: WorldStateDB,
+    treesDB: PublicTreesDB,
+    contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
     skipFeeEnforcement: boolean,
     telemetryClient: TelemetryClient,
   ) {
     return new PublicTxSimulator(
-      db,
-      worldStateDB,
+      treesDB,
+      contractsDB,
       globalVariables,
       doMerkleOperations,
       skipFeeEnforcement,
@@ -112,9 +113,9 @@ class PublicProcessorTimeoutError extends Error {
 export class PublicProcessor implements Traceable {
   private metrics: PublicProcessorMetrics;
   constructor(
-    protected db: MerkleTreeWriteOperations,
     protected globalVariables: GlobalVariables,
-    protected worldStateDB: WorldStateDB,
+    protected treesDB: PublicTreesDB,
+    protected contractsDB: PublicContractsDB,
     protected publicTxSimulator: PublicTxSimulator,
     private dateProvider: DateProvider,
     telemetryClient: TelemetryClient = getTelemetryClient(),
@@ -222,7 +223,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.worldStateDB);
+      const checkpoint = await ForkCheckpoint.new(this.treesDB);
 
       try {
         const [processedTx, returnValues] = await this.processTx(tx, deadline);
@@ -267,8 +268,8 @@ export class PublicProcessor implements Traceable {
           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();
+          await this.contractsDB.addNewContracts(tx);
+          this.contractsDB.commitContractsForTx();
         }
 
         nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map(n => n.toBuffer()));
@@ -294,7 +295,7 @@ export class PublicProcessor implements Traceable {
         // Base case is we always commit the checkpoint. Using the ForkCheckpoint means this has no effect if the tx was reverted
         await checkpoint.commit();
         // The tx-level contracts cache should not live on to the next tx
-        this.worldStateDB.clearContractsForTx();
+        this.contractsDB.clearContractsForTx();
       }
     }
 
@@ -353,12 +354,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.db.appendLeaves(
+    await this.treesDB.appendLeaves(
       MerkleTreeId.NOTE_HASH_TREE,
       padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
     );
     try {
-      await this.db.batchInsert(
+      await this.treesDB.batchInsert(
         MerkleTreeId.NULLIFIER_TREE,
         padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()),
         NULLIFIER_SUBTREE_HEIGHT,
@@ -374,7 +375,7 @@ export class PublicProcessor implements Traceable {
     }
 
     // The only public data write should be for fee payment
-    await this.db.sequentialInsert(
+    await this.treesDB.sequentialInsert(
       MerkleTreeId.PUBLIC_DATA_TREE,
       processedTx.txEffect.publicDataWrites.map(x => x.toBuffer()),
     );
@@ -426,7 +427,7 @@ export class PublicProcessor implements Traceable {
 
     this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${feePayer}`);
 
-    const balance = await this.worldStateDB.storageRead(feeJuiceAddress, balanceSlot);
+    const balance = await this.treesDB.storageRead(feeJuiceAddress, balanceSlot);
 
     if (balance.lt(txFee)) {
       throw new Error(
@@ -435,7 +436,7 @@ export class PublicProcessor implements Traceable {
     }
 
     const updatedBalance = balance.sub(txFee);
-    await this.worldStateDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
+    await this.treesDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
 
     return new PublicDataWrite(leafSlot, updatedBalance);
   }