@aztec/simulator 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/public/public_processor/public_processor_metrics.ts

@@ -1,6 +1,6 @@
 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 {
@@ -30,64 +30,43 @@ export class PublicProcessorMetrics {
 
   private treeInsertionDuration: Histogram;
 
+  private silentlySkippedCount: UpDownCounter;
+  private silentlySkippedDuration: Histogram;
+
   constructor(client: TelemetryClient, name = 'PublicProcessor') {
     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);
+
+    this.silentlySkippedCount = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_PROCESSOR_SILENTLY_SKIPPED_COUNT);
+
+    this.silentlySkippedDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_SILENTLY_SKIPPED_DURATION);
   }
 
   recordPhaseDuration(phaseName: TxExecutionPhase, durationMs: number) {
@@ -151,4 +130,9 @@ export class PublicProcessorMetrics {
   recordTreeInsertions(durationUs: number) {
     this.treeInsertionDuration.record(Math.ceil(durationUs));
   }
+
+  recordSilentlySkipped(durationMs: number) {
+    this.silentlySkippedCount.add(1);
+    this.silentlySkippedDuration.record(Math.ceil(durationMs));
+  }
 }

package/src/public/public_tx_simulator/dumping_public_tx_simulator.ts

@@ -0,0 +1,67 @@
+import type { LoggerBindings } from '@aztec/foundation/log';
+import {
+  AvmCircuitInputs,
+  AvmCircuitPublicInputs,
+  AvmExecutionHints,
+  type PublicSimulatorConfig,
+  type PublicTxResult,
+  serializeWithMessagePack,
+} from '@aztec/stdlib/avm';
+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 {@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(
+    avmSimulator: AvmSimulator,
+    globalVariables: GlobalVariables,
+    contractsDB: PublicContractsDB,
+    forkId: number,
+    config: Partial<PublicSimulatorConfig>,
+    outputDir: string,
+    bindings?: LoggerBindings,
+  ) {
+    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;
+  }
+
+  public override async simulate(tx: Tx): Promise<PublicTxResult> {
+    const result = await super.simulate(tx);
+    this.dumpAvmCircuitInputs(result, tx.getTxHash().toString());
+    return result;
+  }
+
+  private dumpAvmCircuitInputs(result: PublicTxResult, txHash: string): void {
+    try {
+      mkdirSync(this.outputDir, { recursive: true });
+
+      const filename = `avm-circuit-inputs-tx-${txHash}.bin`;
+      const filepath = join(this.outputDir, filename);
+
+      const hints = result.hints ?? AvmExecutionHints.empty();
+      const publicInputs = result.publicInputs ?? AvmCircuitPublicInputs.empty();
+      const avmCircuitInputs = new AvmCircuitInputs(hints, publicInputs);
+
+      const serialized = serializeWithMessagePack(avmCircuitInputs);
+      writeFileSync(filepath, serialized);
+
+      this.log.debug(`Dumped AVM circuit inputs to ${filepath}`);
+    } catch (error) {
+      this.log.warn(`Failed to dump AVM circuit inputs for tx ${txHash}: ${error}`);
+    }
+  }
+}

package/src/public/public_tx_simulator/factories.ts

@@ -0,0 +1,61 @@
+import type { LoggerBindings } from '@aztec/foundation/log';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+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 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(
+  avmSimulator: AvmSimulator,
+  globalVariables: GlobalVariables,
+  contractsDB: PublicContractsDB,
+  forkId: number,
+  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 DumpingPublicTxSimulator(
+      avmSimulator,
+      globalVariables,
+      contractsDB,
+      forkId,
+      dumpingConfig,
+      dumpDir,
+      bindings,
+    );
+  }
+  return new TelemetryPublicTxSimulator(
+    avmSimulator,
+    globalVariables,
+    contractsDB,
+    forkId,
+    telemetryClient,
+    config,
+    bindings,
+  );
+}

package/src/public/public_tx_simulator/index.ts

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