@aztec/simulator 0.0.1-commit.24de95ac → 0.0.1-commit.27d773e65

package/src/public/public_tx_simulator/dumping_cpp_public_tx_simulator.ts

@@ -0,0 +1,83 @@
+import type { LoggerBindings } from '@aztec/foundation/log';
+import {
+  AvmCircuitInputs,
+  AvmCircuitPublicInputs,
+  AvmExecutionHints,
+  type PublicSimulatorConfig,
+  PublicTxResult,
+  serializeWithMessagePack,
+} from '@aztec/stdlib/avm';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import type { GlobalVariables, Tx, TxHash } from '@aztec/stdlib/tx';
+
+import { strict as assert } from 'assert';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+import type { PublicContractsDB } from '../public_db_sources.js';
+import { CppPublicTxSimulator } from './cpp_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.
+ */
+export class DumpingCppPublicTxSimulator extends CppPublicTxSimulator {
+  private readonly outputDir: string;
+
+  constructor(
+    merkleTree: MerkleTreeWriteOperations,
+    contractsDB: PublicContractsDB,
+    globalVariables: GlobalVariables,
+    config: Partial<PublicSimulatorConfig>,
+    outputDir: string,
+    bindings?: LoggerBindings,
+  ) {
+    super(merkleTree, contractsDB, globalVariables, 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;
+  }
+
+  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);
+
+    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 {
+    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 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}`);
+    }
+  }
+}

package/src/public/public_tx_simulator/factories.ts

@@ -0,0 +1,44 @@
+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 { PublicContractsDB } from '../public_db_sources.js';
+import { TelemetryCppPublicTxSimulator } from './cpp_public_tx_simulator.js';
+import { DumpingCppPublicTxSimulator } from './dumping_cpp_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).
+ */
+export function createPublicTxSimulatorForBlockBuilding(
+  merkleTree: MerkleTreeWriteOperations,
+  contractsDB: PublicContractsDB,
+  globalVariables: GlobalVariables,
+  telemetryClient: TelemetryClient,
+  bindings?: LoggerBindings,
+  collectDebugLogs = false,
+) {
+  const config = PublicSimulatorConfig.from({
+    skipFeeEnforcement: false,
+    collectDebugLogs,
+    collectHints: false,
+    collectPublicInputs: false,
+    collectStatistics: false,
+    collectCallMetadata: false,
+  });
+
+  const dumpDir = process.env.DUMP_AVM_INPUTS_TO_DIR;
+  if (dumpDir) {
+    // must collect hints and PIs for dumping
+    const dumpingConfig = {
+      ...config,
+      collectHints: true,
+      collectPublicInputs: true,
+    };
+    return new DumpingCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, dumpingConfig, dumpDir, bindings);
+  }
+  return new TelemetryCppPublicTxSimulator(merkleTree, contractsDB, globalVariables, telemetryClient, config, bindings);
+}

package/src/public/public_tx_simulator/index.ts

@@ -1,3 +1,7 @@
 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 { createPublicTxSimulatorForBlockBuilding } from './factories.js';
 export type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
 export { TelemetryPublicTxSimulator } from './telemetry_public_tx_simulator.js';
+export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';

package/src/public/public_tx_simulator/measured_public_tx_simulator.ts

@@ -1,5 +1,6 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { Timer } from '@aztec/foundation/timer';
+import type { PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
 import type { Gas } from '@aztec/stdlib/gas';
 import type { AvmSimulationStats } from '@aztec/stdlib/stats';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
@@ -10,12 +11,7 @@ import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js'
 import type { PublicContractsDB } from '../public_db_sources.js';
 import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { PublicTxContext } from './public_tx_context.js';
-import {
-  type ProcessedPhase,
-  type PublicTxResult,
-  PublicTxSimulator,
-  type PublicTxSimulatorConfig,
-} from './public_tx_simulator.js';
+import { PublicTxSimulator } from './public_tx_simulator.js';
 import type { MeasuredPublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
 
 /**
@@ -27,7 +23,7 @@ export class MeasuredPublicTxSimulator extends PublicTxSimulator implements Meas
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
     protected readonly metrics: ExecutorMetricsInterface,
-    config?: Partial<PublicTxSimulatorConfig>,
+    config?: Partial<PublicSimulatorConfig>,
   ) {
     super(merkleTree, contractsDB, globalVariables, config);
   }
@@ -38,24 +34,24 @@ export class MeasuredPublicTxSimulator extends PublicTxSimulator implements Meas
     try {
       avmResult = await super.simulate(tx);
     } finally {
-      this.metrics.stopRecordingTxSimulation(txLabel, avmResult?.revertCode);
+      this.metrics.stopRecordingTxSimulation(txLabel, avmResult?.gasUsed, avmResult?.revertCode);
     }
     return avmResult;
   }
 
-  protected override async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
+  protected override async insertNonRevertiblesFromPrivate(context: PublicTxContext) {
     const timer = new Timer();
-    await super.insertNonRevertiblesFromPrivate(context, tx);
+    await super.insertNonRevertiblesFromPrivate(context);
     this.metrics.recordPrivateEffectsInsertion(timer.us(), 'non-revertible');
   }
 
-  protected override async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
+  protected override async insertRevertiblesFromPrivate(context: PublicTxContext) {
     const timer = new Timer();
-    await super.insertRevertiblesFromPrivate(context, tx);
+    await super.insertRevertiblesFromPrivate(context);
     this.metrics.recordPrivateEffectsInsertion(timer.us(), 'revertible');
   }
 
-  protected override async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
+  protected override async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext) {
     const timer = new Timer();
     const result = await super.simulatePhase(phase, context);
     result.durationMs = timer.ms();

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -6,8 +6,8 @@ import {
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
   AvmAccumulatedData,
   AvmAccumulatedDataArrayLengths,
@@ -16,6 +16,7 @@ import {
   RevertCode,
 } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { AllContractDeploymentData, type ContractDeploymentData } from '@aztec/stdlib/contract';
 import type { SimulationError } from '@aztec/stdlib/errors';
 import { computeEffectiveGasFees, computeTransactionFee } from '@aztec/stdlib/fees';
 import { Gas, GasSettings } from '@aztec/stdlib/gas';
@@ -80,12 +81,15 @@ export class PublicTxContext {
     private readonly setupCallRequests: PublicCallRequestWithCalldata[],
     private readonly appLogicCallRequests: PublicCallRequestWithCalldata[],
     private readonly teardownCallRequests: PublicCallRequestWithCalldata[],
+    public readonly nonRevertibleContractDeploymentData: ContractDeploymentData,
+    public readonly revertibleContractDeploymentData: ContractDeploymentData,
     public readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly feePayer: AztecAddress,
     private readonly trace: SideEffectTrace,
+    bindings?: LoggerBindings,
   ) {
-    this.log = createLogger(`simulator:public_tx_context`);
+    this.log = createLogger(`simulator:public_tx_context`, bindings);
   }
 
   public static async create(
@@ -94,12 +98,15 @@ export class PublicTxContext {
     tx: Tx,
     globalVariables: GlobalVariables,
     protocolContracts: ProtocolContracts,
-    doMerkleOperations: boolean,
     proverId: Fr,
+    bindings?: LoggerBindings,
   ) {
+    const contractDeploymentData = AllContractDeploymentData.fromTx(tx);
+    const nonRevertibleContractDeploymentData = contractDeploymentData.getNonRevertibleContractDeploymentData();
+    const revertibleContractDeploymentData = contractDeploymentData.getRevertibleContractDeploymentData();
     const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic!.nonRevertibleAccumulatedData;
 
-    const trace = new SideEffectTrace();
+    const trace = new SideEffectTrace(0, bindings);
 
     const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
 
@@ -108,9 +115,9 @@ export class PublicTxContext {
       treesDB,
       contractsDB,
       trace,
-      doMerkleOperations,
       firstNullifier,
       globalVariables.timestamp,
+      bindings,
     );
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
@@ -120,7 +127,7 @@ export class PublicTxContext {
 
     return new PublicTxContext(
       tx.getTxHash(),
-      new PhaseStateManager(txStateManager),
+      new PhaseStateManager(txStateManager, bindings),
       await txStateManager.getTreeSnapshots(),
       globalVariables,
       protocolContracts,
@@ -132,10 +139,13 @@ export class PublicTxContext {
       getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP),
       getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.APP_LOGIC),
       getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.TEARDOWN),
+      nonRevertibleContractDeploymentData,
+      revertibleContractDeploymentData,
       tx.data.forPublic!.nonRevertibleAccumulatedData,
       tx.data.forPublic!.revertibleAccumulatedData,
       tx.data.feePayer,
       trace,
+      bindings,
     );
   }
 
@@ -435,8 +445,11 @@ class PhaseStateManager {
 
   private currentlyActiveStateManager: PublicPersistableStateManager | undefined;
 
-  constructor(private readonly txStateManager: PublicPersistableStateManager) {
-    this.log = createLogger(`simulator:public_phase_state_manager`);
+  constructor(
+    private readonly txStateManager: PublicPersistableStateManager,
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger(`simulator:public_phase_state_manager`, bindings);
   }
 
   async fork() {