@aztec/simulator 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

package/src/public/public_processor/public_processor.ts

@@ -50,6 +50,7 @@ import { ForkCheckpoint } from '@aztec/world-state/native';
 
 import { AssertionError } from 'assert';
 
+import type { AvmSimulator } from '../avm_simulator.js';
 import { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import {
   type PublicTxSimulatorConfig,
@@ -66,6 +67,7 @@ export class PublicProcessorFactory {
   private log: Logger;
   constructor(
     private contractDataSource: ContractDataSource,
+    private avmSimulator: AvmSimulator,
     private dateProvider: DateProvider = new DateProvider(),
     protected telemetryClient: TelemetryClient = getTelemetryClient(),
     bindings?: LoggerBindings,
@@ -74,7 +76,9 @@ export class PublicProcessorFactory {
   }
 
   /**
-   * Creates a new instance of a PublicProcessor.
+   * Creates a new instance of a PublicProcessor. The simulator it drives reads contract data from the fork's
+   * contracts DB, scoped by the fork id so AVM requests route to the right state.
+   *
    * @param globalVariables - The global variables for the block being processed.
    * @param contractsDB - Optional pre-populated contracts DB; a fresh one is constructed if omitted.
    * @returns A new instance of a PublicProcessor.
@@ -85,8 +89,10 @@ export class PublicProcessorFactory {
     config: PublicSimulatorConfig,
     contractsDB: PublicContractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings()),
   ): PublicProcessor {
+    const forkId = merkleTree.getRevision().forkId;
+
     const guardedFork = new GuardedMerkleTreeOperations(merkleTree);
-    const publicTxSimulator = this.createPublicTxSimulator(guardedFork, contractsDB, globalVariables, config);
+    const publicTxSimulator = this.createPublicTxSimulator(forkId, globalVariables, contractsDB, config);
 
     return new PublicProcessor(
       globalVariables,
@@ -100,15 +106,16 @@ export class PublicProcessorFactory {
   }
 
   protected createPublicTxSimulator(
-    merkleTree: MerkleTreeWriteOperations,
-    contractsDB: PublicContractsDB,
+    forkId: number,
     globalVariables: GlobalVariables,
+    contractsDB: PublicContractsDB,
     config?: Partial<PublicTxSimulatorConfig>,
   ): PublicTxSimulatorInterface {
     return new TelemetryPublicTxSimulator(
-      merkleTree,
-      contractsDB,
+      this.avmSimulator,
       globalVariables,
+      contractsDB,
+      forkId,
       this.telemetryClient,
       config,
       this.log.getBindings(),
@@ -130,10 +137,6 @@ class PublicProcessorAbortError extends Error {
   }
 }
 
-function isPublicProcessorInterruptError(err: any) {
-  return err?.name === 'PublicProcessorTimeoutError' || err?.name === 'PublicProcessorAbortError';
-}
-
 /**
  * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
  * any public function calls in them. Txs with private calls only are unaffected.
@@ -326,11 +329,15 @@ export class PublicProcessor implements Traceable {
         // Commit the tx-level contracts checkpoint on success
         this.contractsDB.commitCheckpoint();
       } catch (err: any) {
-        if (isPublicProcessorInterruptError(err)) {
-          const interruptReason = err.name === 'PublicProcessorTimeoutError' ? 'timeout' : 'abort signal';
-          this.log.warn(`Stopping tx processing due to ${interruptReason}.`);
-          // The tx may still be executing on a worker thread (C++ via NAPI).
-          // Signal cancellation AND WAIT for the simulation to actually stop before touching fork checkpoints.
+        if (err?.name === 'PublicProcessorTimeoutError' || err?.name === 'PublicProcessorAbortError') {
+          this.log.warn(
+            `Stopping tx processing due to ${err.name === 'PublicProcessorTimeoutError' ? 'timeout' : 'abort'}.`,
+          );
+          // We hit the transaction execution deadline or an external abort signal.
+          // There may still be a simulation in progress.
+          // Signal cancellation AND WAIT for the simulation to actually stop. Cancellation is
+          // cooperative: the simulator may be mid slow-operation and won't observe the flag until it
+          // completes, and without waiting we'd revert checkpoints while it's still writing to state.
           await this.publicTxSimulator.cancel?.();
 
           // Now stop the guarded fork to prevent any further TS-side access to the world state.

package/src/public/public_tx_simulator/dumping_public_tx_simulator.ts

@@ -4,35 +4,36 @@ import {
   AvmCircuitPublicInputs,
   AvmExecutionHints,
   type PublicSimulatorConfig,
-  PublicTxResult,
+  type PublicTxResult,
   serializeWithMessagePack,
 } from '@aztec/stdlib/avm';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
-import type { GlobalVariables, Tx, TxHash } from '@aztec/stdlib/tx';
+import type { GlobalVariables, Tx } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 
+import type { AvmSimulator } from '../avm_simulator.js';
 import type { PublicContractsDB } from '../public_db_sources.js';
 import { PublicTxSimulator } from './public_tx_simulator.js';
 
 /**
- * A C++ public tx simulator that dumps AVM circuit inputs to disk after simulation.
- * Used during nightly CI runs to collect circuit inputs for benchmarking.
+ * A {@link PublicTxSimulator} that dumps AVM circuit inputs to disk after simulation.
+ * Used during nightly CI runs to collect circuit inputs for AVM proving benchmarks.
  */
 export class DumpingPublicTxSimulator extends PublicTxSimulator {
   private readonly outputDir: string;
 
   constructor(
-    merkleTree: MerkleTreeWriteOperations,
-    contractsDB: PublicContractsDB,
+    avmSimulator: AvmSimulator,
     globalVariables: GlobalVariables,
+    contractsDB: PublicContractsDB,
+    forkId: number,
     config: Partial<PublicSimulatorConfig>,
     outputDir: string,
     bindings?: LoggerBindings,
   ) {
-    super(merkleTree, contractsDB, globalVariables, config, bindings);
+    super(avmSimulator, globalVariables, contractsDB, forkId, config, bindings);
     assert(config.collectHints === true, 'collectHints must be enabled to dump AVM circuit inputs');
     assert(config.collectPublicInputs === true, 'collectPublicInputs must be enabled to dump AVM circuit inputs');
     this.outputDir = outputDir;
@@ -40,44 +41,27 @@ export class DumpingPublicTxSimulator extends PublicTxSimulator {
 
   public override async simulate(tx: Tx): Promise<PublicTxResult> {
     const result = await super.simulate(tx);
-
-    // Dump the circuit inputs after successful simulation
-    const txHash = this.computeTxHash(tx);
-    this.dumpAvmCircuitInputs(result, txHash);
-
+    this.dumpAvmCircuitInputs(result, tx.getTxHash().toString());
     return result;
   }
 
-  /**
-   * Dumps AVM circuit inputs to disk.
-   *
-   * @param result - The simulation result containing hints and public inputs
-   * @param txHash - The transaction hash to use in the filename
-   */
-  private dumpAvmCircuitInputs(result: PublicTxResult, txHash: TxHash): void {
+  private dumpAvmCircuitInputs(result: PublicTxResult, txHash: string): void {
     try {
-      // Ensure the output directory exists
       mkdirSync(this.outputDir, { recursive: true });
 
-      // Generate filename using transaction hash
-      const filename = `avm-circuit-inputs-tx-${txHash.toString()}.bin`;
+      const filename = `avm-circuit-inputs-tx-${txHash}.bin`;
       const filepath = join(this.outputDir, filename);
 
-      // Create circuit inputs from the result
       const hints = result.hints ?? AvmExecutionHints.empty();
       const publicInputs = result.publicInputs ?? AvmCircuitPublicInputs.empty();
       const avmCircuitInputs = new AvmCircuitInputs(hints, publicInputs);
 
-      // Serialize the circuit inputs using MessagePack
       const serialized = serializeWithMessagePack(avmCircuitInputs);
-
-      // Write to disk
       writeFileSync(filepath, serialized);
 
       this.log.debug(`Dumped AVM circuit inputs to ${filepath}`);
     } catch (error) {
-      // Non-blocking error handling - log but don't interrupt processing
-      this.log.warn(`Failed to dump AVM circuit inputs for tx ${txHash.toString()}: ${error}`);
+      this.log.warn(`Failed to dump AVM circuit inputs for tx ${txHash}: ${error}`);
     }
   }
 }

package/src/public/public_tx_simulator/factories.ts

@@ -1,22 +1,23 @@
 import type { LoggerBindings } from '@aztec/foundation/log';
 import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import type { GlobalVariables } from '@aztec/stdlib/tx';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
+import type { AvmSimulator } from '../avm_simulator.js';
 import type { PublicContractsDB } from '../public_db_sources.js';
 import { DumpingPublicTxSimulator } from './dumping_public_tx_simulator.js';
 import { TelemetryPublicTxSimulator } from './public_tx_simulator.js';
 
 /**
- * Creates a public tx simulator for block building.
- * Uses DumpingPublicTxSimulator if DUMP_AVM_INPUTS_TO_DIR env var is set (for CI/testing avm circuit),
+ * Creates an IPC-based public tx simulator for block building.
+ * Uses DumpingPublicTxSimulator if DUMP_AVM_INPUTS_TO_DIR env var is set (for CI/testing the AVM circuit),
  * otherwise uses TelemetryPublicTxSimulator (for production).
  */
 export function createPublicTxSimulatorForBlockBuilding(
-  merkleTree: MerkleTreeWriteOperations,
-  contractsDB: PublicContractsDB,
+  avmSimulator: AvmSimulator,
   globalVariables: GlobalVariables,
+  contractsDB: PublicContractsDB,
+  forkId: number,
   telemetryClient: TelemetryClient,
   bindings?: LoggerBindings,
   collectDebugLogs = false,
@@ -38,7 +39,23 @@ export function createPublicTxSimulatorForBlockBuilding(
       collectHints: true,
       collectPublicInputs: true,
     };
-    return new DumpingPublicTxSimulator(merkleTree, contractsDB, globalVariables, dumpingConfig, dumpDir, bindings);
+    return new DumpingPublicTxSimulator(
+      avmSimulator,
+      globalVariables,
+      contractsDB,
+      forkId,
+      dumpingConfig,
+      dumpDir,
+      bindings,
+    );
   }
-  return new TelemetryPublicTxSimulator(merkleTree, contractsDB, globalVariables, telemetryClient, config, bindings);
+  return new TelemetryPublicTxSimulator(
+    avmSimulator,
+    globalVariables,
+    contractsDB,
+    forkId,
+    telemetryClient,
+    config,
+    bindings,
+  );
 }

package/src/public/public_tx_simulator/index.ts

@@ -1,5 +1,8 @@
-export { PublicTxSimulator, TelemetryPublicTxSimulator } from './public_tx_simulator.js';
+export { PublicTxSimulator, MeasuredPublicTxSimulator, TelemetryPublicTxSimulator } from './public_tx_simulator.js';
 export { DumpingPublicTxSimulator } from './dumping_public_tx_simulator.js';
 export { createPublicTxSimulatorForBlockBuilding } from './factories.js';
-export type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
+export type {
+  PublicTxSimulatorInterface,
+  MeasuredPublicTxSimulatorInterface,
+} from './public_tx_simulator_interface.js';
 export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -1,7 +1,5 @@
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
-import { type CancellationToken, avmSimulate, cancelSimulation, createCancellationToken } from '@aztec/native';
-import { ProtocolContractsList } from '@aztec/protocol-contracts';
 import {
   AvmFastSimulationInputs,
   AvmTxHint,
@@ -10,14 +8,14 @@ import {
   deserializeFromMessagePack,
 } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import type { GlobalVariables, Tx } from '@aztec/stdlib/tx';
+import { WorldStateRevision } from '@aztec/stdlib/world-state';
 import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
 
+import type { AvmContractsDBContext, AvmSimulator } from '../avm_simulator.js';
 import { ExecutorMetrics } from '../executor_metrics.js';
 import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
 import type { PublicContractsDB } from '../public_db_sources.js';
-import { ContractProviderForCpp } from './contract_provider_for_cpp.js';
 import { PublicTxSimulatorBase } from './public_tx_simulator_base.js';
 import type {
   MeasuredPublicTxSimulatorInterface,
@@ -25,146 +23,136 @@ import type {
 } from './public_tx_simulator_interface.js';
 
 /**
- * Simulates a transaction's public portion using the C++ AVM simulator.
- * The C++ simulator accesses the world state directly/natively within C++.
- * For contract DB accesses, it makes callbacks through NAPI back to the TS PublicContractsDB cache.
+ * Simulates a transaction's public portion by running its public calls through an {@link AvmSimulator}.
+ * `forkId` selects the fork whose contract data the simulation reads.
  */
 export class PublicTxSimulator extends PublicTxSimulatorBase implements PublicTxSimulatorInterface {
   protected override log: Logger;
-  /** Current cancellation token for in-flight simulation. */
-  private cancellationToken?: CancellationToken;
+  /** Aborts the in-flight simulation. */
+  private abortController?: AbortController;
   /** Current simulation promise, used to wait for completion after cancellation. */
-  private simulationPromise?: Promise<Buffer>;
+  private simulationPromise?: Promise<PublicTxResult>;
 
   constructor(
-    merkleTree: MerkleTreeWriteOperations,
-    contractsDB: PublicContractsDB,
+    avmSimulator: AvmSimulator,
     globalVariables: GlobalVariables,
+    contractsDB: PublicContractsDB,
+    forkId: number,
     config?: Partial<PublicSimulatorConfig>,
     bindings?: LoggerBindings,
   ) {
-    super(merkleTree, contractsDB, globalVariables, config, undefined, bindings);
+    super(avmSimulator, globalVariables, contractsDB, forkId, config, undefined, bindings);
     this.log = createLogger(`simulator:public_tx_simulator`, bindings);
   }
 
   /**
-   * Simulate a transaction's public portion using the C++ avvm simulator.
+   * Simulate a transaction's public portion.
    *
    * @param tx - The transaction to simulate.
    * @returns The result of the transaction's public execution.
    */
   public async simulate(tx: Tx): Promise<PublicTxResult> {
-    const txHash = this.computeTxHash(tx);
-    this.log.debug(`C++ simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
-      txHash,
-    });
-
-    const wsRevision = this.merkleTree.getRevision();
-    const wsdbIpcPath = this.merkleTree.getIpcPath();
+    this.abortController = new AbortController();
+    this.simulationPromise = this.doSimulate(tx, this.abortController.signal);
+    try {
+      return await this.simulationPromise;
+    } finally {
+      this.abortController = undefined;
+      this.simulationPromise = undefined;
+    }
+  }
 
-    this.log.trace(`Running C++ simulation with world state revision ${JSON.stringify(wsRevision)}`);
+  protected async doSimulate(tx: Tx, signal: AbortSignal): Promise<PublicTxResult> {
+    const txHash = this.computeTxHash(tx);
+    this.log.debug(
+      `Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}, forkId=${this.forkId}`,
+      { txHash },
+    );
 
-    // Create the fast simulation inputs
+    // Create the fast simulation inputs.
     const txHint = AvmTxHint.fromTx(tx, this.globalVariables.gasFees);
-    const protocolContracts = ProtocolContractsList;
     const fastSimInputs = new AvmFastSimulationInputs(
-      wsRevision,
+      // blockNumber: WorldStateRevision.LATEST sentinel so the WSDB walks the fork's current
+      // uncommitted state. Using 0 here makes WSDB treat this as a historical query against
+      // the empty genesis tree and miss any in-fork uncommitted leaves (deployed contracts,
+      // etc.) from earlier txs in the same block.
+      { forkId: this.forkId, blockNumber: WorldStateRevision.LATEST, includeUncommitted: true },
       this.config,
       txHint,
       this.globalVariables,
-      protocolContracts,
+      this.protocolContracts,
     );
 
-    // Create contract provider for callbacks to TypeScript PublicContractsDB from C++
-    const contractProvider = new ContractProviderForCpp(this.contractsDB, this.globalVariables, this.bindings);
-
-    // Serialize to msgpack and call the C++ simulator
     this.log.trace(`Serializing fast simulation inputs to msgpack...`);
     const inputBuffer = fastSimInputs.serializeWithMessagePack();
 
-    // Create cancellation token for this simulation
-    this.cancellationToken = createCancellationToken();
-
-    // Store the promise so cancel() can wait for it
-    this.log.debug(`Calling C++ simulator for tx ${txHash}`);
-    this.simulationPromise = avmSimulate(
-      inputBuffer,
-      contractProvider,
-      wsdbIpcPath,
-      this.log.level,
-      undefined,
-      this.cancellationToken,
-    );
-
-    let resultBuffer: Buffer;
+    this.log.debug(`Running AVM simulation for tx ${txHash}`);
+    const context: AvmContractsDBContext = {
+      contractsDB: this.contractsDB,
+      forkId: this.forkId,
+      timestamp: this.globalVariables.timestamp,
+    };
+    let resultBuffer: Uint8Array;
     try {
-      resultBuffer = await this.simulationPromise;
+      resultBuffer = await this.avmSimulator.simulate(inputBuffer, context, signal);
     } catch (error: any) {
-      // Check if this was a cancellation
-      if (error.message?.includes('Simulation cancelled')) {
-        throw new SimulationError(`C++ simulation cancelled`, []);
+      if (error.message?.includes('cancelled')) {
+        throw new SimulationError(`AVM simulation cancelled`, []);
       }
-      throw new SimulationError(`C++ simulation failed: ${error.message}`, []);
-    } finally {
-      this.cancellationToken = undefined;
-      this.simulationPromise = undefined;
+      throw new SimulationError(`AVM simulation failed: ${error.message}`, []);
     }
 
-    // If we've reached this point, C++ succeeded during simulation,
+    this.log.trace(`Deserializing simulation result from buffer (size: ${resultBuffer.length})...`);
+    const resultJSON: object = deserializeFromMessagePack(Buffer.from(resultBuffer));
+    const result = PublicTxResult.fromPlainObject(resultJSON);
 
-    // Deserialize the msgpack result
-    this.log.trace(`Deserializing C++ from buffer (size: ${resultBuffer.length})...`);
-    const cppResultJSON: object = deserializeFromMessagePack(resultBuffer);
-    this.log.trace(`Deserializing C++ result to PublicTxResult...`);
-    const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
-
-    this.log.trace(`C++ simulation completed for tx ${txHash}`, {
+    this.log.trace(`AVM simulation completed for tx ${txHash}`, {
       txHash,
-      reverted: !cppResult.revertCode.isOK(),
-      cppGasUsed: cppResult.gasUsed.totalGas.l2Gas,
+      reverted: !result.revertCode.isOK(),
+      l2GasUsed: result.gasUsed.totalGas.l2Gas,
     });
 
-    return cppResult;
+    return result;
   }
 
   /**
    * Cancel the current simulation if one is in progress.
-   * This signals the C++ simulator to stop at the next opcode or before the next WorldState write.
-   * Safe to call even if no simulation is in progress.
+   * This signals the underlying simulator to stop at the next safe point (between opcodes, before a
+   * world-state write). 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.
-   *                        This is important because C++ might be in the middle of a slow operation
-   *                        (e.g., pad_trees) and won't check the cancellation flag until it completes.
+   *                        Cancellation is cooperative: the simulator may be mid slow-operation and
+   *                        won't observe the cancellation until it completes.
    *                        Default timeout of 100ms after cancellation.
    */
   public async cancel(waitTimeoutMs: number = 100): Promise<void> {
-    if (this.cancellationToken) {
-      this.log.debug('Cancelling C++ simulation');
-      cancelSimulation(this.cancellationToken);
+    if (this.abortController) {
+      this.log.debug('Cancelling AVM simulation');
+      this.abortController.abort();
     }
 
-    // Wait for the simulation to actually complete if not already done
     if (this.simulationPromise) {
-      this.log.debug(`Waiting up to ${waitTimeoutMs}ms for C++ simulation to stop`);
+      this.log.debug(`Waiting up to ${waitTimeoutMs}ms for AVM simulation to stop`);
       await Promise.race([
         this.simulationPromise.catch(() => {}), // Ignore rejection, just wait for completion
         sleep(waitTimeoutMs),
       ]);
-      this.log.debug('C++ simulation stopped or wait timed out');
+      this.log.debug('AVM simulation stopped or wait timed out');
     }
   }
 }
 
 export class MeasuredPublicTxSimulator extends PublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
   constructor(
-    merkleTree: MerkleTreeWriteOperations,
-    contractsDB: PublicContractsDB,
+    avmSimulator: AvmSimulator,
     globalVariables: GlobalVariables,
+    contractsDB: PublicContractsDB,
+    forkId: number,
     protected readonly metrics: ExecutorMetricsInterface,
     config?: Partial<PublicSimulatorConfig>,
     bindings?: LoggerBindings,
   ) {
-    super(merkleTree, contractsDB, globalVariables, config, bindings);
+    super(avmSimulator, globalVariables, contractsDB, forkId, config, bindings);
   }
 
   public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
@@ -180,22 +168,23 @@ export class MeasuredPublicTxSimulator extends PublicTxSimulator implements Meas
 }
 
 /**
- * A C++ public tx simulator that tracks runtime/production metrics with telemetry.
+ * A public tx simulator that tracks runtime/production metrics with telemetry.
  */
 export class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
   /* tracer needed by trackSpans */
   public readonly tracer: Tracer;
 
   constructor(
-    merkleTree: MerkleTreeWriteOperations,
-    contractsDB: PublicContractsDB,
+    avmSimulator: AvmSimulator,
     globalVariables: GlobalVariables,
+    contractsDB: PublicContractsDB,
+    forkId: number,
     telemetryClient: TelemetryClient = getTelemetryClient(),
     config?: Partial<PublicSimulatorConfig>,
     bindings?: LoggerBindings,
   ) {
     const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
-    super(merkleTree, contractsDB, globalVariables, metrics, config, bindings);
+    super(avmSimulator, globalVariables, contractsDB, forkId, metrics, config, bindings);
     this.tracer = metrics.tracer;
   }
 }

package/src/public/public_tx_simulator/public_tx_simulator_base.ts

@@ -1,15 +1,16 @@
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractsList } from '@aztec/protocol-contracts';
 import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import type { GlobalVariables, ProtocolContracts, Tx } from '@aztec/stdlib/tx';
 
+import type { AvmSimulator } from '../avm_simulator.js';
 import type { PublicContractsDB } from '../public_db_sources.js';
 
 /**
- * Shared base for public tx simulators. Holds the common configuration, world-state and contract DB
- * handles, logger, and the tx-hash helper. Concrete simulators (e.g. the C++ simulator) extend this
- * and implement `simulate`.
+ * Shared base for public tx simulators: holds the common configuration, the {@link AvmSimulator} used
+ * to run the transaction's public calls, the contracts DB and fork id that scope the simulation's
+ * contract-data lookups, the logger, and the tx-hash helper. Concrete simulators extend this and
+ * implement `simulate`.
  */
 export abstract class PublicTxSimulatorBase {
   protected log: Logger;
@@ -17,9 +18,10 @@ export abstract class PublicTxSimulatorBase {
   protected readonly bindings?: LoggerBindings;
 
   constructor(
-    protected merkleTree: MerkleTreeWriteOperations,
-    protected contractsDB: PublicContractsDB,
+    protected avmSimulator: AvmSimulator,
     protected globalVariables: GlobalVariables,
+    protected contractsDB: PublicContractsDB,
+    protected forkId: number,
     config?: Partial<PublicSimulatorConfig>,
     protected protocolContracts: ProtocolContracts = ProtocolContractsList,
     bindings?: LoggerBindings,

package/src/public/public_tx_simulator/public_tx_simulator_interface.ts

@@ -5,14 +5,14 @@ export interface PublicTxSimulatorInterface {
   simulate(tx: Tx): Promise<PublicTxResult>;
   /**
    * 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.
    * Optional - not all implementations support cancellation.
    *
    * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
-   *                        This is important because signaling cancellation doesn't immediately stop C++ -
-   *                        it only sets a flag that C++ checks at certain points. If C++ is in the middle
-   *                        of a slow operation (e.g., pad_trees), it won't stop until that completes.
+   *                        Cancellation is cooperative: signaling it only sets a flag the simulator
+   *                        checks at certain points, so if it's mid slow-operation it won't stop until
+   *                        that completes.
    * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
    */
   cancel?(waitTimeoutMs?: number): Promise<void>;
@@ -22,7 +22,7 @@ export interface MeasuredPublicTxSimulatorInterface {
   simulate(tx: Tx, txLabel: string): Promise<PublicTxResult>;
   /**
    * 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.
    * Optional - not all implementations support cancellation.
    *

package/dest/public/public_tx_simulator/contract_provider_for_cpp.d.ts

@@ -1,19 +0,0 @@
-import { type LoggerBindings } from '@aztec/foundation/log';
-import type { ContractProvider } from '@aztec/native';
-import type { GlobalVariables } from '@aztec/stdlib/tx';
-import type { PublicContractsDB } from '../public_db_sources.js';
-export declare class ContractProviderForCpp implements ContractProvider {
-    private contractsDB;
-    private globalVariables;
-    private log;
-    constructor(contractsDB: PublicContractsDB, globalVariables: GlobalVariables, bindings?: LoggerBindings);
-    getContractInstance: (address: string) => Promise<Buffer<ArrayBufferLike> | undefined>;
-    getContractClass: (classId: string) => Promise<Buffer<ArrayBufferLike> | undefined>;
-    addContracts: (contractDeploymentDataBuffer: Buffer<ArrayBufferLike>) => Promise<void>;
-    getBytecodeCommitment: (classId: string) => Promise<Buffer<ArrayBufferLike> | undefined>;
-    getDebugFunctionName: (address: string, selector: string) => Promise<string | undefined>;
-    createCheckpoint: () => Promise<void>;
-    commitCheckpoint: () => Promise<void>;
-    revertCheckpoint: () => Promise<void>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfcHJvdmlkZXJfZm9yX2NwcC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9wdWJsaWNfdHhfc2ltdWxhdG9yL2NvbnRyYWN0X3Byb3ZpZGVyX2Zvcl9jcHAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFlLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBQ3ZGLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBS3RELE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXhELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFakUscUJBQWEsc0JBQXVCLFlBQVcsZ0JBQWdCO0lBSTNELE9BQU8sQ0FBQyxXQUFXO0lBQ25CLE9BQU8sQ0FBQyxlQUFlO0lBSnpCLE9BQU8sQ0FBQyxHQUFHLENBQVM7SUFFcEIsWUFDVSxXQUFXLEVBQUUsaUJBQWlCLEVBQzlCLGVBQWUsRUFBRSxlQUFlLEVBQ3hDLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFTSxtQkFBbUIsb0VBYXhCO0lBRUssZ0JBQWdCLG9FQWVyQjtJQUdLLFlBQVksMkVBV2pCO0lBRUsscUJBQXFCLG9FQWdCMUI7SUFFSyxvQkFBb0IscUVBc0J6QjtJQUVLLGdCQUFnQixzQkFHckI7SUFFSyxnQkFBZ0Isc0JBR3JCO0lBRUssZ0JBQWdCLHNCQUdyQjtDQUNIIn0=

package/dest/public/public_tx_simulator/contract_provider_for_cpp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract_provider_for_cpp.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/contract_provider_for_cpp.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAKtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,qBAAa,sBAAuB,YAAW,gBAAgB;IAI3D,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,eAAe;IAJzB,OAAO,CAAC,GAAG,CAAS;IAEpB,YACU,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACxC,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAEM,mBAAmB,oEAaxB;IAEK,gBAAgB,oEAerB;IAGK,YAAY,2EAWjB;IAEK,qBAAqB,oEAgB1B;IAEK,oBAAoB,qEAsBzB;IAEK,gBAAgB,sBAGrB;IAEK,gBAAgB,sBAGrB;IAEK,gBAAgB,sBAGrB;CACH"}