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

package/src/public/public_tx_simulator/{dumping_cpp_public_tx_simulator.ts → 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 { CppPublicTxSimulator } from './cpp_public_tx_simulator.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 DumpingCppPublicTxSimulator extends CppPublicTxSimulator {
+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 DumpingCppPublicTxSimulator extends CppPublicTxSimulator {
 
   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 { TelemetryCppPublicTxSimulator } from './cpp_public_tx_simulator.js';
-import { DumpingCppPublicTxSimulator } from './dumping_cpp_public_tx_simulator.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 DumpingCppPublicTxSimulator if DUMP_AVM_INPUTS_TO_DIR env var is set (for CI/testing avm circuit),
- * otherwise uses TelemetryCppPublicTxSimulator (for production).
+ * 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 DumpingCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, dumpingConfig, dumpDir, bindings);
+    return new DumpingPublicTxSimulator(
+      avmSimulator,
+      globalVariables,
+      contractsDB,
+      forkId,
+      dumpingConfig,
+      dumpDir,
+      bindings,
+    );
   }
-  return new TelemetryCppPublicTxSimulator(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,7 +1,8 @@
-export * from './public_tx_simulator.js';
-export { CppPublicTxSimulator, TelemetryCppPublicTxSimulator } from './cpp_public_tx_simulator.js';
-export { DumpingCppPublicTxSimulator } from './dumping_cpp_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 { TelemetryPublicTxSimulator } from './telemetry_public_tx_simulator.js';
+export type {
+  PublicTxSimulatorInterface,
+  MeasuredPublicTxSimulatorInterface,
+} from './public_tx_simulator_interface.js';
 export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';