@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/src/public/public_processor/public_processor_metrics.ts

@@ -1,6 +1,6 @@
-import type { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import type { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
 import type { Gas } from '@aztec/stdlib/gas';
-import type { TxExecutionPhase } from '@aztec/stdlib/tx';
+import { TxExecutionPhase } from '@aztec/stdlib/tx';
 import {
   Attributes,
   type Gauge,
@@ -9,7 +9,7 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
 export class PublicProcessorMetrics {
@@ -34,60 +34,32 @@ export class PublicProcessorMetrics {
     this.tracer = client.getTracer(name);
     const meter = client.getMeter(name);
 
-    this.txDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_DURATION, {
-      description: 'How long it takes to process a transaction',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.txDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_DURATION);
 
-    this.txCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_COUNT, {
-      description: 'Number of transactions processed',
+    this.txCount = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_PROCESSOR_TX_COUNT, {
+      [Attributes.OK]: [true, false],
     });
 
-    this.txPhaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_PHASE_COUNT, {
-      description: 'Number of phases processed',
-    });
+    this.txPhaseCount = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_PROCESSOR_TX_PHASE_COUNT);
 
-    this.phaseDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_PHASE_DURATION, {
-      description: 'How long it takes to process a phase',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.phaseDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_PHASE_DURATION);
 
-    this.phaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_PHASE_COUNT, {
-      description: 'Number of failed phases',
+    this.phaseCount = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_PROCESSOR_PHASE_COUNT, {
+      [Attributes.TX_PHASE_NAME]: [TxExecutionPhase.SETUP, TxExecutionPhase.APP_LOGIC, TxExecutionPhase.TEARDOWN],
+      [Attributes.OK]: [true, false],
     });
 
-    this.bytecodeDeployed = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_DEPLOY_BYTECODE_SIZE, {
-      description: 'Size of deployed bytecode',
-      unit: 'By',
-    });
+    this.bytecodeDeployed = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_DEPLOY_BYTECODE_SIZE);
 
-    this.totalGas = meter.createGauge(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS, {
-      description: 'Total gas used in block',
-      unit: 'gas',
-    });
+    this.totalGas = meter.createGauge(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS);
 
-    this.totalGasHistogram = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS_HISTOGRAM, {
-      description: 'Total gas used in block as histogram',
-      unit: 'gas/block',
-    });
+    this.totalGasHistogram = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS_HISTOGRAM);
 
-    this.txGas = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_GAS, {
-      description: 'Gas used in transaction',
-      unit: 'gas/tx',
-    });
+    this.txGas = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_GAS);
 
-    this.gasRate = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_GAS_RATE, {
-      description: 'L2 gas per second for complete block',
-      unit: 'gas/s',
-    });
+    this.gasRate = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_GAS_RATE);
 
-    this.treeInsertionDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TREE_INSERTION, {
-      description: 'How long it takes for tree insertion',
-      unit: 'us',
-      valueType: ValueType.INT,
-    });
+    this.treeInsertionDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TREE_INSERTION);
   }
 
   recordPhaseDuration(phaseName: TxExecutionPhase, durationMs: number) {
@@ -137,7 +109,7 @@ export class PublicProcessorMetrics {
     this.phaseCount.add(1, { [Attributes.TX_PHASE_NAME]: phaseName, [Attributes.OK]: false });
   }
 
-  recordClassRegistration(...events: ContractClassRegisteredEvent[]) {
+  recordClassPublication(...events: ContractClassPublishedEvent[]) {
     let totalBytecode = 0;
     for (const event of events) {
       totalBytecode += event.packedPublicBytecode.length;

package/src/public/public_tx_simulator/contract_provider_for_cpp.ts

@@ -0,0 +1,124 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import type { ContractProvider } from '@aztec/native';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { deserializeFromMessagePack, serializeWithMessagePack } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ContractDeploymentData } from '@aztec/stdlib/contract';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
+
+import type { PublicContractsDB } from '../public_db_sources.js';
+
+export class ContractProviderForCpp implements ContractProvider {
+  private log: Logger;
+
+  constructor(
+    private contractsDB: PublicContractsDB,
+    private globalVariables: GlobalVariables,
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('simulator:contract_provider_for_cpp', bindings);
+  }
+
+  public getContractInstance = async (address: string): Promise<Buffer | undefined> => {
+    this.log.trace(`Contract provider callback: getContractInstance(${address})`);
+
+    const aztecAddr = AztecAddress.fromString(address);
+
+    const instance = await this.contractsDB.getContractInstance(aztecAddr, this.globalVariables.timestamp);
+
+    if (!instance) {
+      this.log.debug(`Contract instance not found: ${address}`);
+      return undefined;
+    }
+
+    return serializeWithMessagePack(instance);
+  };
+
+  public getContractClass = async (classId: string): Promise<Buffer | undefined> => {
+    this.log.trace(`Contract provider callback: getContractClass(${classId})`);
+
+    // Parse classId string to Fr
+    const classIdFr = Fr.fromString(classId);
+
+    // Fetch contract class from the contracts DB
+    const contractClass = await this.contractsDB.getContractClass(classIdFr);
+
+    if (!contractClass) {
+      this.log.debug(`Contract class not found: ${classId}`);
+      return undefined;
+    }
+
+    return serializeWithMessagePack(contractClass);
+  };
+
+  public addContracts = async (contractDeploymentDataBuffer: Buffer): Promise<void> => {
+    this.log.trace(`Contract provider callback: addContracts`);
+
+    const rawData: any = deserializeFromMessagePack(contractDeploymentDataBuffer);
+
+    // Construct ContractDeploymentData from plain object.
+    const contractDeploymentData = ContractDeploymentData.fromPlainObject(rawData);
+
+    // Add contracts to the contracts DB
+    this.log.trace(`Calling contractsDB.addContracts`);
+    await this.contractsDB.addContracts(contractDeploymentData);
+  };
+
+  public getBytecodeCommitment = async (classId: string): Promise<Buffer | undefined> => {
+    this.log.trace(`Contract provider callback: getBytecodeCommitment(${classId})`);
+
+    // Parse classId string to Fr
+    const classIdFr = Fr.fromString(classId);
+
+    // Fetch bytecode commitment from the contracts DB
+    const commitment = await this.contractsDB.getBytecodeCommitment(classIdFr);
+
+    if (!commitment) {
+      this.log.debug(`Bytecode commitment not found: ${classId}`);
+      return undefined;
+    }
+
+    // Serialize the Fr to buffer
+    return serializeWithMessagePack(commitment);
+  };
+
+  public getDebugFunctionName = async (address: string, selector: string): Promise<string | undefined> => {
+    this.log.trace(`Contract provider callback: getDebugFunctionName(${address}, ${selector})`);
+
+    // Parse address and selector strings
+    const aztecAddr = AztecAddress.fromString(address);
+    const selectorFr = Fr.fromString(selector);
+    const functionSelector = FunctionSelector.fromFieldOrUndefined(selectorFr);
+
+    if (!functionSelector) {
+      this.log.trace(`calldata[0] is not a function selector: ${selector}`);
+      return undefined;
+    }
+
+    // Fetch debug function name from the contracts DB
+    const name = await this.contractsDB.getDebugFunctionName(aztecAddr, functionSelector);
+
+    if (!name) {
+      this.log.trace(`Debug function name not found for ${address}:${selector}`);
+      return undefined;
+    }
+
+    return name;
+  };
+
+  public createCheckpoint = (): Promise<void> => {
+    this.log.trace(`Contract provider callback: createCheckpoint`);
+    return Promise.resolve(this.contractsDB.createCheckpoint());
+  };
+
+  public commitCheckpoint = (): Promise<void> => {
+    this.log.trace(`Contract provider callback: commitCheckpoint`);
+    return Promise.resolve(this.contractsDB.commitCheckpoint());
+  };
+
+  public revertCheckpoint = (): Promise<void> => {
+    this.log.trace(`Contract provider callback: revertCheckpoint`);
+    return Promise.resolve(this.contractsDB.revertCheckpoint());
+  };
+}

package/src/public/public_tx_simulator/cpp_public_tx_simulator.ts

@@ -0,0 +1,211 @@
+import { type Logger, type LoggerBindings, createLogger, logLevel } 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,
+  type PublicSimulatorConfig,
+  PublicTxResult,
+  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 { WorldStateRevisionWithHandle } from '@aztec/stdlib/world-state';
+import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { strict as assert } from 'assert';
+
+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 { PublicTxSimulator } from './public_tx_simulator.js';
+import type {
+  MeasuredPublicTxSimulatorInterface,
+  PublicTxSimulatorInterface,
+} from './public_tx_simulator_interface.js';
+
+/**
+ * C++ implementation of PublicTxSimulator using the C++ 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.
+ */
+export class CppPublicTxSimulator extends PublicTxSimulator implements PublicTxSimulatorInterface {
+  protected override log: Logger;
+  /** Current cancellation token for in-flight simulation. */
+  private cancellationToken?: CancellationToken;
+  /** Current simulation promise, used to wait for completion after cancellation. */
+  private simulationPromise?: Promise<Buffer>;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    config?: Partial<PublicSimulatorConfig>,
+    bindings?: LoggerBindings,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config, undefined, bindings);
+    this.log = createLogger(`simulator:cpp_public_tx_simulator`, bindings);
+  }
+
+  /**
+   * Simulate a transaction's public portion using the C++ avvm simulator.
+   *
+   * @param tx - The transaction to simulate.
+   * @returns The result of the transaction's public execution.
+   */
+  public override 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,
+    });
+
+    // Using the "as WorldStateRevisionWithHandle" is a bit of a "trust me bro", hence the assert.
+    let wsRevision = this.merkleTree.getRevision();
+    assert(
+      wsRevision instanceof WorldStateRevisionWithHandle,
+      'CppPublicTxSimulator a real NativeWorldStateInstance with a handle to the C++ WorldState object',
+    );
+    const wsCppHandle = (wsRevision as WorldStateRevisionWithHandle).handle;
+    wsRevision = wsRevision.toWorldStateRevision(); // for msgpack serialization, we don't include the handle in the type
+
+    this.log.trace(`Running C++ simulation with world state revision ${JSON.stringify(wsRevision)}`);
+
+    // Create the fast simulation inputs
+    const txHint = AvmTxHint.fromTx(tx, this.globalVariables.gasFees);
+    const protocolContracts = ProtocolContractsList;
+    const fastSimInputs = new AvmFastSimulationInputs(
+      wsRevision,
+      this.config,
+      txHint,
+      this.globalVariables,
+      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,
+      wsCppHandle,
+      logLevel,
+      // TODO: re-enable logging
+      undefined,
+      this.cancellationToken,
+    );
+
+    let resultBuffer: Buffer;
+    try {
+      resultBuffer = await this.simulationPromise;
+    } catch (error: any) {
+      // Check if this was a cancellation
+      if (error.message?.includes('Simulation cancelled')) {
+        throw new SimulationError(`C++ simulation cancelled`, []);
+      }
+      throw new SimulationError(`C++ simulation failed: ${error.message}`, []);
+    } finally {
+      this.cancellationToken = undefined;
+      this.simulationPromise = undefined;
+    }
+
+    // If we've reached this point, C++ succeeded during simulation,
+
+    // 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}`, {
+      txHash,
+      reverted: !cppResult.revertCode.isOK(),
+      cppGasUsed: cppResult.gasUsed.totalGas.l2Gas,
+    });
+
+    return cppResult;
+  }
+
+  /**
+   * 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.
+   *
+   * @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.
+   *                        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);
+    }
+
+    // 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`);
+      await Promise.race([
+        this.simulationPromise.catch(() => {}), // Ignore rejection, just wait for completion
+        sleep(waitTimeoutMs),
+      ]);
+      this.log.debug('C++ simulation stopped or wait timed out');
+    }
+  }
+}
+
+export class MeasuredCppPublicTxSimulator extends CppPublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    protected readonly metrics: ExecutorMetricsInterface,
+    config?: Partial<PublicSimulatorConfig>,
+    bindings?: LoggerBindings,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config, bindings);
+  }
+
+  public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
+    this.metrics.startRecordingTxSimulation(txLabel);
+    let result: PublicTxResult | undefined;
+    try {
+      result = await super.simulate(tx);
+    } finally {
+      this.metrics.stopRecordingTxSimulation(txLabel, result?.gasUsed, result?.revertCode);
+    }
+    return result;
+  }
+}
+
+/**
+ * A C++ public tx simulator that tracks runtime/production metrics with telemetry.
+ */
+export class TelemetryCppPublicTxSimulator extends MeasuredCppPublicTxSimulator {
+  /* tracer needed by trackSpans */
+  public readonly tracer: Tracer;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
+    config?: Partial<PublicSimulatorConfig>,
+    bindings?: LoggerBindings,
+  ) {
+    const metrics = new ExecutorMetrics(telemetryClient, 'CppPublicTxSimulator');
+    super(merkleTree, contractsDB, globalVariables, metrics, config, bindings);
+    this.tracer = metrics.tracer;
+  }
+}

package/src/public/public_tx_simulator/cpp_public_tx_simulator_with_hinted_dbs.ts

@@ -0,0 +1,134 @@
+import { type Logger, type LoggerBindings, createLogger, logLevel } from '@aztec/foundation/log';
+import { avmSimulateWithHintedDbs } from '@aztec/native';
+import {
+  AvmCircuitInputs,
+  type PublicSimulatorConfig,
+  PublicTxResult,
+  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 { strict as assert } from 'assert';
+
+import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
+import type { PublicContractsDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from './public_tx_simulator.js';
+import type {
+  MeasuredPublicTxSimulatorInterface,
+  PublicTxSimulatorInterface,
+} from './public_tx_simulator_interface.js';
+
+/**
+ * C++ implementation of PublicTxSimulator using pre-collected hints.
+ * This implementation runs TS simulation first to collect all hints,
+ * then passes the complete AvmCircuitInputs (hints + public inputs)
+ * to C++ to run hinted simulation.
+ */
+export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements PublicTxSimulatorInterface {
+  protected override log: Logger;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    config?: Partial<PublicSimulatorConfig>,
+    bindings?: LoggerBindings,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config, undefined, bindings);
+    this.log = createLogger(`simulator:cpp_public_tx_simulator_hinted_dbs`, bindings);
+  }
+
+  /**
+   * Simulate a transaction's public portion using the C++ vm2 simulator with hinted DBs.
+   *
+   * This implementation:
+   * 1. Runs the full TypeScript simulation to generate AvmCircuitInputs (hints + public inputs)
+   * 2. Passes the complete AvmCircuitInputs to C++ to run hinted simulation
+   *
+   * @param tx - The transaction to simulate.
+   * @returns The result of the transaction's public execution.
+   */
+  public override async simulate(tx: Tx): Promise<PublicTxResult> {
+    const txHash = this.computeTxHash(tx);
+    this.log.debug(`C++ hinted DB simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
+      txHash,
+    });
+
+    // First, run TS simulation to generate hints and public inputs
+    this.log.debug(`Running TS simulation for tx ${txHash}`);
+
+    // Run the full TypeScript simulation using the parent class
+    // This will modify the merkle tree with the transaction's state changes
+    const tsResult = await super.simulate(tx);
+    this.log.debug(`TS simulation succeeded for tx ${txHash}`);
+
+    // Extract the full AvmCircuitInputs from the TS result
+    const avmCircuitInputs = new AvmCircuitInputs(tsResult.hints!, tsResult.publicInputs!);
+
+    // Second, run C++ simulation with hinted DBs
+    this.log.debug(`Running C++ simulation with hinted DBs for tx ${txHash}`);
+
+    // Serialize to msgpack and call the C++ simulator
+    const inputBuffer = avmCircuitInputs.serializeWithMessagePack();
+
+    let resultBuffer: Buffer;
+    try {
+      resultBuffer = await avmSimulateWithHintedDbs(inputBuffer, logLevel);
+    } catch (error: any) {
+      throw new SimulationError(`C++ hinted simulation failed: ${error.message}`, []);
+    }
+
+    // Deserialize the msgpack result
+    const cppResultJSON: object = deserializeFromMessagePack(resultBuffer);
+    const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
+
+    assert(cppResult.revertCode.equals(tsResult.revertCode));
+    assert(cppResult.gasUsed.totalGas.equals(tsResult.gasUsed.totalGas));
+
+    this.log.debug(`C++ hinted simulation completed for tx ${txHash}`, {
+      txHash,
+      reverted: !tsResult.revertCode.isOK(),
+      tsGasUsed: tsResult.gasUsed.totalGas.l2Gas,
+      cppGasUsed: tsResult.gasUsed.totalGas.l2Gas,
+    });
+
+    // TODO(fcarreiro): complete this.
+    return tsResult;
+  }
+}
+
+/**
+ * Class to record metrics for simulation.
+ *
+ * Note(dbanks12): We might not be able to collect all the same metrics in C++ as we do in TS!
+ * Unless we move some of the metrics collection to C++, we don't have inner functions exposed
+ * to TS for tracking.
+ */
+export class MeasuredCppPublicTxSimulatorHintedDbs
+  extends CppPublicTxSimulatorHintedDbs
+  implements MeasuredPublicTxSimulatorInterface
+{
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    protected readonly metrics: ExecutorMetricsInterface,
+    config?: Partial<PublicSimulatorConfig>,
+    bindings?: LoggerBindings,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, config, bindings);
+  }
+
+  public override async simulate(tx: Tx, txLabel: string = 'unlabeledTx'): Promise<PublicTxResult> {
+    this.metrics.startRecordingTxSimulation(txLabel);
+    let result: PublicTxResult | undefined;
+    try {
+      result = await super.simulate(tx);
+    } finally {
+      this.metrics.stopRecordingTxSimulation(txLabel, result?.gasUsed, result?.revertCode);
+    }
+    return result;
+  }
+}