@aztec/simulator 0.0.1-commit.993d52e → 0.0.1-commit.9a89641

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -1,9 +1,4 @@
-import {
-  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
-  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
-  PUBLIC_TX_L2_GAS_OVERHEAD,
-  TX_DA_GAS_OVERHEAD,
-} from '@aztec/constants';
+import { PUBLIC_TX_L2_GAS_OVERHEAD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
 import { asyncMap } from '@aztec/foundation/async-map';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -16,22 +11,24 @@ import { PublicCallRequest } from '@aztec/stdlib/kernel';
 import { GlobalVariables, PublicCallRequestWithCalldata, type Tx } from '@aztec/stdlib/tx';
 import { NativeWorldStateService } from '@aztec/world-state';
 
-import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { BaseAvmSimulationTester } from '../avm/testing/base_avm_simulation_tester.js';
 import {
   DEFAULT_BLOCK_NUMBER,
   DEFAULT_TIMESTAMP,
   getContractFunctionAbi,
   getFunctionSelector,
-} from '../avm/fixtures/utils.js';
+} from '../avm/testing/utils.js';
+import { AvmSimulatorPool } from '../avm_simulator_pool.js';
 import { PublicContractsDB } from '../public_db_sources.js';
-import { MeasuredCppPublicTxSimulator } from '../public_tx_simulator/cpp_public_tx_simulator.js';
-import { MeasuredCppVsTsPublicTxSimulator } from '../public_tx_simulator/cpp_vs_ts_public_tx_simulator.js';
+import { MeasuredPublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
 import type { MeasuredPublicTxSimulatorInterface } from '../public_tx_simulator/public_tx_simulator_interface.js';
 import { TestExecutorMetrics } from '../test_executor_metrics.js';
 import { SimpleContractDataSource } from './simple_contract_data_source.js';
 import { type TestPrivateInsertions, createTxForPublicCalls } from './utils.js';
 
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
+const TEARDOWN_DA_GAS_LIMIT = 98_304;
+const TEARDOWN_L2_GAS_LIMIT = 817_500;
 
 export type TestEnqueuedCall = {
   sender?: AztecAddress;
@@ -69,8 +66,9 @@ export type MeasuredSimulatorFactory = (
  */
 export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   protected txCount: number = 0;
-  private simulator: MeasuredPublicTxSimulatorInterface;
+  private simulator: MeasuredPublicTxSimulatorInterface | undefined;
   private metricsPrefix?: string;
+  protected avmSimulator?: AvmSimulatorPool;
 
   constructor(
     merkleTree: MerkleTreeWriteOperations,
@@ -86,7 +84,9 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     if (simulatorFactory) {
       this.simulator = simulatorFactory(merkleTree, contractsDB, globals, this.metrics, config);
     } else {
-      this.simulator = new MeasuredCppPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config);
+      // No simulator — this tester can only be used for setup (setFeePayerBalance, createTx, etc.)
+      // To simulate, use PublicTxSimulationTester.create() or pass a simulatorFactory.
+      this.simulator = undefined;
     }
   }
 
@@ -94,15 +94,25 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     worldStateService: NativeWorldStateService, // make sure to close this later
     globals: GlobalVariables = defaultGlobals(),
     metrics: TestExecutorMetrics = new TestExecutorMetrics(),
-    useCppSimulator = false,
     config: PublicSimulatorConfig = defaultConfig,
   ): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTree = await worldStateService.fork();
-    const simulatorFactory: MeasuredSimulatorFactory = useCppSimulator
-      ? (mt, cdb, g, m, c) => new MeasuredCppPublicTxSimulator(mt, cdb, g, m, c)
-      : (mt, cdb, g, m, c) => new MeasuredCppVsTsPublicTxSimulator(mt, cdb, g, m, c);
-    return new PublicTxSimulationTester(merkleTree, contractDataSource, globals, metrics, simulatorFactory, config);
+
+    const avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldStateService.getIpcPath() });
+    const simulatorFactory: MeasuredSimulatorFactory = (mt, cdb, g, m, c) =>
+      new MeasuredPublicTxSimulator(avmSimulator, g, cdb, mt.getRevision().forkId, m, c, undefined);
+
+    const tester = new PublicTxSimulationTester(
+      merkleTree,
+      contractDataSource,
+      globals,
+      metrics,
+      simulatorFactory,
+      config,
+    );
+    tester.avmSimulator = avmSimulator;
+    return tester;
   }
 
   public setMetricsPrefix(prefix: string) {
@@ -117,6 +127,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     feePayer: AztecAddress = sender,
     /* need some unique first nullifier for note-nonce computations */
     privateInsertions: TestPrivateInsertions = { nonRevertible: { nullifiers: [new Fr(420000 + this.txCount)] } },
+    gasLimits?: Gas,
   ): Promise<Tx> {
     const setupCallRequests = await asyncMap(setupCalls, call =>
       this.#createPubicCallRequestForCall(call, call.sender ?? sender),
@@ -136,12 +147,10 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       teardownCallRequest,
       feePayer,
       /*gasUsedByPrivate*/ teardownCall
-        ? new Gas(
-            DEFAULT_TEARDOWN_DA_GAS_LIMIT + TX_DA_GAS_OVERHEAD,
-            DEFAULT_TEARDOWN_L2_GAS_LIMIT + PUBLIC_TX_L2_GAS_OVERHEAD,
-          )
+        ? new Gas(TEARDOWN_DA_GAS_LIMIT + TX_DA_GAS_OVERHEAD, TEARDOWN_L2_GAS_LIMIT + PUBLIC_TX_L2_GAS_OVERHEAD)
         : new Gas(TX_DA_GAS_OVERHEAD, PUBLIC_TX_L2_GAS_OVERHEAD),
       defaultGlobals(),
+      gasLimits,
     );
   }
 
@@ -154,8 +163,9 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     /* need some unique first nullifier for note-nonce computations */
     privateInsertions?: TestPrivateInsertions,
     txLabel: string = 'unlabeledTx',
+    gasLimits?: Gas,
   ): Promise<PublicTxResult> {
-    const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions);
+    const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions, gasLimits);
 
     await this.setFeePayerBalance(feePayer);
 
@@ -233,22 +243,31 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     this.metrics.prettyPrint();
   }
 
+  /** Clean up IPC resources (AVM simulator pool and merkle tree fork) created by create(). */
+  public async close(): Promise<void> {
+    await this.avmSimulator?.[Symbol.asyncDispose]();
+    // Close the merkle tree fork to release IPC resources before the wsdb process is killed.
+    if (this.merkleTrees?.close) {
+      await this.merkleTrees.close().catch(() => {});
+    }
+  }
+
   /**
    * Cancel the current simulation if one is in progress.
-   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * This signals the underlying simulator to stop at the next safe point.
    * Safe to call even if no simulation is in progress.
    *
    * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
    */
   public async cancel(waitTimeoutMs?: number): Promise<void> {
-    await this.simulator.cancel?.(waitTimeoutMs);
+    await this.simulator?.cancel?.(waitTimeoutMs);
   }
 
   /**
    * Get the underlying simulator for advanced test scenarios.
    * Use this when you need direct control over simulation (e.g., for testing cancellation).
    */
-  public getSimulator(): MeasuredPublicTxSimulatorInterface {
+  public getSimulator(): MeasuredPublicTxSimulatorInterface | undefined {
     return this.simulator;
   }
 

package/src/public/fixtures/simple_contract_data_source.ts

@@ -5,7 +5,7 @@ import type { ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
-import { getFunctionSelector } from '../avm/fixtures/utils.js';
+import { getFunctionSelector } from '../avm/testing/utils.js';
 
 /**
  * This class is used during public/avm testing to function as a database of

package/src/public/fixtures/token_test.ts

@@ -21,9 +21,9 @@ export async function tokenTest(
 ) {
   const timer = new Timer();
 
-  const admin = AztecAddress.fromNumber(42);
-  const sender = AztecAddress.fromNumber(111);
-  const receiver = AztecAddress.fromNumber(222);
+  const admin = AztecAddress.fromNumberUnsafe(42);
+  const sender = AztecAddress.fromNumberUnsafe(111);
+  const receiver = AztecAddress.fromNumberUnsafe(222);
 
   const token = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue);
 

package/src/public/fixtures/utils.ts

@@ -2,10 +2,8 @@ import {
   CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE,
   CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
   CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-  DEFAULT_DA_GAS_LIMIT,
-  DEFAULT_L2_GAS_LIMIT,
-  DEFAULT_TEARDOWN_DA_GAS_LIMIT,
-  DEFAULT_TEARDOWN_L2_GAS_LIMIT,
+  MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT,
+  MAX_PROCESSABLE_L2_GAS,
   PRIVATE_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -38,6 +36,9 @@ import {
 
 import { strict as assert } from 'assert';
 
+const TEARDOWN_DA_GAS_LIMIT = 98_304;
+const TEARDOWN_L2_GAS_LIMIT = 817_500;
+
 export type TestPrivateInsertions = {
   revertible?: {
     nullifiers?: Fr[];
@@ -62,13 +63,14 @@ export async function createTxForPublicCalls(
   feePayer = AztecAddress.zero(),
   gasUsedByPrivate: Gas = Gas.empty(),
   globals: GlobalVariables = GlobalVariables.empty(),
+  gasLimits?: Gas,
 ): Promise<Tx> {
   assert(
     setupCallRequests.length > 0 || appCallRequests.length > 0 || teardownCallRequest !== undefined,
     "Can't create public tx with no enqueued calls",
   );
   // use max limits
-  const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
+  gasLimits = gasLimits ?? new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
 
   const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
 
@@ -127,9 +129,7 @@ export async function createTxForPublicCalls(
   }
 
   const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
-  const teardownGasLimits = teardownCallRequest
-    ? new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT)
-    : Gas.empty();
+  const teardownGasLimits = teardownCallRequest ? new Gas(TEARDOWN_DA_GAS_LIMIT, TEARDOWN_L2_GAS_LIMIT) : Gas.empty();
   const gasSettings = new GasSettings(gasLimits, teardownGasLimits, maxFeesPerGas, GasFees.empty());
   const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
   const header = BlockHeader.empty({ globalVariables: globals });
@@ -163,7 +163,7 @@ export async function createTxForPrivateOnly(
   gasUsedByPrivate: Gas = new Gas(10, 10),
 ): Promise<Tx> {
   // use max limits
-  const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
+  const gasLimits = new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
 
   const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
 
@@ -228,17 +228,15 @@ export async function addNewContractInstanceToTx(
   contractInstance: ContractInstanceWithAddress,
   skipNullifierInsertion = false,
 ) {
-  // can't use publicKeys.toFields() because it includes isInfinite which
-  // is not broadcast in such private logs
+  // Only ivpk_m is broadcast as a point (x, y); the other five keys are hashes.
   const publicKeysAsFields = [
-    contractInstance.publicKeys.masterNullifierPublicKey.x,
-    contractInstance.publicKeys.masterNullifierPublicKey.y,
-    contractInstance.publicKeys.masterIncomingViewingPublicKey.x,
-    contractInstance.publicKeys.masterIncomingViewingPublicKey.y,
-    contractInstance.publicKeys.masterOutgoingViewingPublicKey.x,
-    contractInstance.publicKeys.masterOutgoingViewingPublicKey.y,
-    contractInstance.publicKeys.masterTaggingPublicKey.x,
-    contractInstance.publicKeys.masterTaggingPublicKey.y,
+    contractInstance.publicKeys.npkMHash,
+    contractInstance.publicKeys.ivpkM.x,
+    contractInstance.publicKeys.ivpkM.y,
+    contractInstance.publicKeys.ovpkMHash,
+    contractInstance.publicKeys.tpkMHash,
+    contractInstance.publicKeys.mspkMHash,
+    contractInstance.publicKeys.fbpkMHash,
   ];
   const logFields = [
     CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG,
@@ -247,6 +245,7 @@ export async function addNewContractInstanceToTx(
     new Fr(contractInstance.salt),
     contractInstance.currentContractClassId,
     contractInstance.initializationHash,
+    contractInstance.immutablesHash,
     ...publicKeysAsFields,
     contractInstance.deployer.toField(),
   ];
@@ -256,7 +255,7 @@ export async function addNewContractInstanceToTx(
   );
 
   const contractAddressNullifier = await siloNullifier(
-    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+    AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
     contractInstance.address.toField(),
   );
 

package/src/public/fuzzing/avm_fuzzer_simulator.ts

@@ -33,7 +33,8 @@ import {
 } from '@aztec/stdlib/tx';
 import type { NativeWorldStateService } from '@aztec/world-state';
 
-import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { BaseAvmSimulationTester } from '../avm/testing/base_avm_simulation_tester.js';
+import { AvmSimulatorPool } from '../avm_simulator_pool.js';
 import { SimpleContractDataSource } from '../fixtures/simple_contract_data_source.js';
 import { PublicContractsDB } from '../public_db_sources.js';
 import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
@@ -75,7 +76,7 @@ export class FuzzerSimulationRequest {
 
 /**
  * Creates a TypeScript Tx object from a deserialized C++ Tx (AvmTxHint-like structure).
- * This allows using PublicTxSimulator.simulate() with fuzzer-generated transactions.
+ * This allows simulating fuzzer-generated transactions with the C++ public tx simulator.
  */
 async function createTxFromHint(cppTx: AvmTxHint): Promise<Tx> {
   // Create TxHash from the C++ tx hash string
@@ -189,6 +190,8 @@ async function createTxFromHint(cppTx: AvmTxHint): Promise<Tx> {
 /**
  * A simulator class for the AVM fuzzer that extends BaseAvmSimulationTester.
  * It provides methods for registering contracts from C++ msgpack data and simulating transactions.
+ * The simulation itself runs on the production C++ AVM simulator, so the fuzzer compares brillig
+ * execution against the real AVM rather than a TS reference.
  */
 export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
   private simulator: PublicTxSimulator;
@@ -197,22 +200,27 @@ export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
     merkleTrees: MerkleTreeWriteOperations,
     contractDataSource: SimpleContractDataSource,
     globals: GlobalVariables,
-    protocolContracts: ProtocolContracts,
+    private avmSimulator: AvmSimulatorPool,
+    contractsDB: PublicContractsDB,
+    forkId: number,
   ) {
     super(contractDataSource, merkleTrees);
-    const contractsDb = new PublicContractsDB(contractDataSource);
+    // collectPublicInputs and collectCallMetadata are required so the C++ result carries the end
+    // tree snapshots and app-logic return values that the fuzzer bin reports back to the harness.
     this.simulator = new PublicTxSimulator(
-      merkleTrees,
-      contractsDb,
+      avmSimulator,
       globals,
+      contractsDB,
+      forkId,
       {
         skipFeeEnforcement: false,
         collectDebugLogs: false,
         collectHints: false,
+        collectPublicInputs: true,
         collectStatistics: false,
-        collectCallMetadata: false,
+        collectCallMetadata: true,
       },
-      protocolContracts,
+      undefined,
     );
   }
 
@@ -222,11 +230,18 @@ export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
   public static async create(
     worldStateService: NativeWorldStateService,
     globals: GlobalVariables,
-    protocolContracts: ProtocolContracts,
   ): Promise<AvmFuzzerSimulator> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTrees = await worldStateService.fork();
-    return new AvmFuzzerSimulator(merkleTrees, contractDataSource, globals, protocolContracts);
+    const forkId = merkleTrees.getRevision().forkId;
+    const avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldStateService.getIpcPath() });
+    const contractsDB = new PublicContractsDB(contractDataSource);
+    return new AvmFuzzerSimulator(merkleTrees, contractDataSource, globals, avmSimulator, contractsDB, forkId);
+  }
+
+  /** Tear down the AVM simulator pool (AVM processes and CDB server). */
+  public async close(): Promise<void> {
+    await this.avmSimulator[Symbol.asyncDispose]();
   }
 
   /**

package/src/public/fuzzing/avm_simulator_bin.ts

@@ -7,7 +7,7 @@ import {
   deserializeFromMessagePack,
   serializeWithMessagePack,
 } from '@aztec/stdlib/avm';
-import { GlobalVariables, ProtocolContracts, TreeSnapshots } from '@aztec/stdlib/tx';
+import { GlobalVariables, TreeSnapshots } from '@aztec/stdlib/tx';
 import { NativeWorldStateService } from '@aztec/world-state';
 
 import { createInterface } from 'readline';
@@ -58,7 +58,6 @@ async function simulateWithFuzzer(
   rawContractInstances: [any, any][], // Replace these when we are moving contract instances to TS
   rawPublicDataWrites: any[], // Public data tree writes to apply before simulation
   rawNoteHashes: any[], // Note hashes to apply before simulation
-  protocolContracts: ProtocolContracts, // Protocol contracts mapping from C++
 ): Promise<{
   reverted: boolean;
   output: Fr[];
@@ -68,7 +67,7 @@ async function simulateWithFuzzer(
 }> {
   const worldStateService = await openExistingWorldState(dataDir, mapSizeKb);
 
-  const simulator = await AvmFuzzerSimulator.create(worldStateService, globals, protocolContracts);
+  const simulator = await AvmFuzzerSimulator.create(worldStateService, globals);
 
   await simulator.applyNoteHashes(rawNoteHashes);
 
@@ -108,7 +107,7 @@ async function execute(base64Line: string): Promise<void> {
     const rawRequest = deserializeFromMessagePack(buffer);
     const request = FuzzerSimulationRequest.fromPlainObject(rawRequest);
 
-    // Run the TS simulation
+    // Run the simulation on the C++ AVM simulator
     const result = await simulateWithFuzzer(
       request.wsDataDir,
       request.wsMapSizeKb,
@@ -118,7 +117,6 @@ async function execute(base64Line: string): Promise<void> {
       request.contractInstances,
       request.publicDataWrites,
       request.noteHashes,
-      request.protocolContracts,
     );
 
     // Serialize the result to msgpack and encode it in base64 for output

package/src/public/index.ts

@@ -1,12 +1,16 @@
+export { AvmSimulatorPool, type AvmSimulatorPoolOptions } from './avm_simulator_pool.js';
+export type { PublicContractsDBInterface } from './db_interfaces.js';
 export { PublicContractsDB } from './public_db_sources.js';
 export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_tree.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
+export type { AvmContractsDBContext, AvmSimulator } from './avm_simulator.js';
 export {
-  CppPublicTxSimulator,
+  PublicTxSimulator,
+  MeasuredPublicTxSimulator,
   createPublicTxSimulatorForBlockBuilding,
-  DumpingCppPublicTxSimulator,
+  DumpingPublicTxSimulator,
   type PublicTxSimulatorInterface,
-  TelemetryCppPublicTxSimulator,
+  TelemetryPublicTxSimulator,
 } from './public_tx_simulator/index.js';
 export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';
 export { getCallRequestsWithCalldataByPhase } from './utils.js';

package/src/public/public_db_sources.ts

@@ -55,10 +55,11 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     this.log = createLogger('simulator:contracts-data-source', bindings);
   }
 
-  public async addContracts(contractDeploymentData: ContractDeploymentData): Promise<void> {
+  /** Parses raw contract deployment data and inserts the resulting contracts into the current checkpoint. */
+  public addContractsFromLogs(contractDeploymentData: ContractDeploymentData): void {
     const currentState = this.getCurrentState();
 
-    await this.addContractClassesFromEvents(
+    this.addContractClassesFromEvents(
       ContractClassPublishedEvent.extractContractClassEvents(contractDeploymentData.getContractClassLogs()),
       currentState,
     );
@@ -69,10 +70,18 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     );
   }
 
-  public async addNewContracts(tx: Tx): Promise<void> {
+  public addNewContracts(tx: Tx): void {
     const contractDeploymentData = AllContractDeploymentData.fromTx(tx);
-    await this.addContracts(contractDeploymentData.getNonRevertibleContractDeploymentData());
-    await this.addContracts(contractDeploymentData.getRevertibleContractDeploymentData());
+    this.addContractsFromLogs(contractDeploymentData.getNonRevertibleContractDeploymentData());
+    this.addContractsFromLogs(contractDeploymentData.getRevertibleContractDeploymentData());
+  }
+
+  /** Inserts typed contract instances directly into the current checkpoint. */
+  public addContracts(contractInstances?: ContractInstanceWithAddress[]): void {
+    const currentState = this.getCurrentState();
+    for (const instance of contractInstances ?? []) {
+      currentState.addInstance(instance.address, instance);
+    }
   }
 
   /**
@@ -81,7 +90,7 @@ export class PublicContractsDB implements PublicContractsDBInterface {
    */
   public createCheckpoint(): void {
     const currentState = this.getCurrentState();
-    const newState = currentState.deepCopy();
+    const newState = currentState.fork();
     this.contractStateStack.push(newState);
   }
 
@@ -174,17 +183,15 @@ export class PublicContractsDB implements PublicContractsDBInterface {
     return await this.dataSource.getDebugFunctionName(address, selector);
   }
 
-  private async addContractClassesFromEvents(
+  private addContractClassesFromEvents(
     contractClassEvents: ContractClassPublishedEvent[],
     state: ContractsDbCheckpoint,
   ) {
-    await Promise.all(
-      contractClassEvents.map(async (event: ContractClassPublishedEvent) => {
-        this.log.debug(`Adding class ${event.contractClassId.toString()} to contract state`);
-        const contractClass = await event.toContractClassPublic();
-        state.addClass(event.contractClassId, contractClass);
-      }),
-    );
+    for (const event of contractClassEvents) {
+      this.log.debug(`Adding class ${event.contractClassId.toString()} to contract state`);
+      const contractClass = event.toContractClassPublic();
+      state.addClass(event.contractClassId, contractClass);
+    }
   }
 
   private addContractInstancesFromEvents(

package/src/public/public_processor/guarded_merkle_tree.ts

@@ -12,7 +12,7 @@ import type {
   TreeInfo,
 } from '@aztec/stdlib/trees';
 import type { BlockHeader, StateReference } from '@aztec/stdlib/tx';
-import type { WorldStateRevision, WorldStateRevisionWithHandle } from '@aztec/stdlib/world-state';
+import type { WorldStateRevision } from '@aztec/stdlib/world-state';
 
 /**
  * Wraps an instance of `MerkleTreeWriteOperations` to allow the sequencer to gate access.
@@ -94,9 +94,12 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
   getInitialHeader(): BlockHeader {
     return this.target.getInitialHeader();
   }
-  public getRevision(): WorldStateRevision | WorldStateRevisionWithHandle {
+  public getRevision(): WorldStateRevision {
     return this.target.getRevision();
   }
+  public getIpcPath(): string {
+    return this.target.getIpcPath();
+  }
   getSiblingPath<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<SiblingPath<TreeHeights[ID]>> {
     return this.guardAndPush(() => this.target.getSiblingPath(treeId, index));
   }
@@ -134,7 +137,7 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
   ): Promise<(BlockNumber | undefined)[]> {
     return this.guardAndPush(() => this.target.getBlockNumbersForLeafIndices(treeId, leafIndices));
   }
-  createCheckpoint(): Promise<void> {
+  createCheckpoint(): Promise<number> {
     return this.guardAndPush(() => this.target.createCheckpoint());
   }
   commitCheckpoint(): Promise<void> {
@@ -143,11 +146,11 @@ export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
   revertCheckpoint(): Promise<void> {
     return this.guardAndPush(() => this.target.revertCheckpoint());
   }
-  commitAllCheckpoints(): Promise<void> {
-    return this.guardAndPush(() => this.target.commitAllCheckpoints());
+  commitAllCheckpointsTo(depth: number): Promise<void> {
+    return this.guardAndPush(() => this.target.commitAllCheckpointsTo(depth));
   }
-  revertAllCheckpoints(): Promise<void> {
-    return this.guardAndPush(() => this.target.revertAllCheckpoints());
+  revertAllCheckpointsTo(depth: number): Promise<void> {
+    return this.guardAndPush(() => this.target.revertAllCheckpointsTo(depth));
   }
   findSiblingPaths<ID extends MerkleTreeId>(
     treeId: ID,