@aztec-labs/bb-prover 6.0.0-nightly.20260829

package/src/bb/file_names.ts

@@ -0,0 +1,6 @@
+// File-naming conventions used by `bb` CLI output directories. Retained for consumers that still
+// read/write proofs to disk alongside bb-prover's in-memory bb.js flows.
+
+export const VK_FILENAME = 'vk';
+export const PROOF_FILENAME = 'proof';
+export const PUBLIC_INPUTS_FILENAME = 'public_inputs';

package/src/bb/index.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env -S node --no-warnings
+import { createConsoleLogger } from '@aztec-labs/foundation/log';
+import 'source-map-support/register.js';
+
+import { getProgram } from './cli.js';
+
+const log = createConsoleLogger();
+
+/** CLI main entrypoint */
+async function main() {
+  process.once('SIGINT', () => process.exit(0));
+  process.once('SIGTERM', () => process.exit(0));
+
+  const program = getProgram(log);
+  await program.parseAsync(process.argv);
+}
+
+main().catch(err => {
+  log(`Error in command execution`);
+  log(err);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,31 @@
+export interface BBConfig {
+  bbBinaryPath: string;
+  bbWorkingDirectory: string;
+  /** Whether to skip tmp dir cleanup for debugging purposes */
+  bbSkipCleanup: boolean;
+  /**
+   * Number of long-lived bb processes pooled by the RPC verifier (BBCircuitVerifier).
+   * Also caps concurrent verifications via the wrapping QueuedIVCVerifier.
+   */
+  numConcurrentIVCVerifiers: number;
+  /** Thread count for the RPC IVC verifier. */
+  bbIVCConcurrency: number;
+  /**
+   * Upper bound on proofs per batch for the peer chonk batch verifier.
+   * Proofs are verified immediately as they arrive — this only caps how many
+   * can accumulate while a batch is already being processed.
+   * Default 16: at 4 cores, a full batch of 16 verifies in ~245ms wall time.
+   */
+  bbChonkVerifyMaxBatch: number;
+  /** Thread count for the peer batch verifier parallel reduce. Default 6 to leave cores for the rest of the node. */
+  bbChonkVerifyConcurrency: number;
+  /** When set, bb.js operations write input/output files and log equivalent CLI commands to this directory. */
+  bbDebugOutputDir?: string;
+}
+
+export interface ACVMConfig {
+  /** The path to the ACVM binary */
+  acvmBinaryPath: string;
+  /** The working directory to use for simulation/proving */
+  acvmWorkingDirectory: string;
+}

package/src/honk.ts

@@ -0,0 +1,35 @@
+import type { ServerProtocolArtifact } from '@aztec-labs/noir-protocol-circuits-types/server';
+
+export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_starknet_honk' | 'ultra_rollup_honk';
+
+const UltraKeccakHonkCircuits = ['RootRollupArtifact'] as const satisfies ServerProtocolArtifact[];
+const UltraHonkCircuits = [
+  'InboxParity64Artifact',
+  'InboxParity256Artifact',
+  'InboxParity1024Artifact',
+] as const satisfies ServerProtocolArtifact[];
+
+export type UltraKeccakHonkServerProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number];
+export type UltraHonkServerProtocolArtifact = (typeof UltraHonkCircuits)[number];
+export type UltraRollupHonkServerProtocolArtifact = Exclude<
+  Exclude<ServerProtocolArtifact, UltraKeccakHonkServerProtocolArtifact>,
+  UltraHonkServerProtocolArtifact
+>;
+
+export function getUltraHonkFlavorForCircuit(artifact: UltraKeccakHonkServerProtocolArtifact): 'ultra_keccak_honk';
+export function getUltraHonkFlavorForCircuit(artifact: UltraHonkServerProtocolArtifact): 'ultra_honk';
+export function getUltraHonkFlavorForCircuit(artifact: UltraRollupHonkServerProtocolArtifact): 'ultra_rollup_honk';
+export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor;
+export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor {
+  // STARKNET: how to allow for the distinction between keccak/starknet? ultra_keccak_honk is returned in both cases
+  if (isUltraKeccakHonkCircuit(artifact)) {
+    return 'ultra_keccak_honk';
+  } else if (UltraHonkCircuits.includes(artifact as UltraHonkServerProtocolArtifact)) {
+    return 'ultra_honk';
+  }
+  return 'ultra_rollup_honk';
+}
+
+function isUltraKeccakHonkCircuit(artifact: ServerProtocolArtifact): artifact is UltraKeccakHonkServerProtocolArtifact {
+  return UltraKeccakHonkCircuits.includes(artifact as UltraKeccakHonkServerProtocolArtifact);
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './prover/index.js';
+export * from './test/index.js';
+export * from './verifier/index.js';
+export * from './config.js';
+export * from './bb/file_names.js';
+export * from './bb/bb_js_backend.js';
+export * from './honk.js';
+export * from './verification_key/verification_key_data.js';
+
+export { type ClientProtocolCircuitVerifier } from '@aztec-labs/stdlib/interfaces/server';

package/src/instrumentation.ts

@@ -0,0 +1,119 @@
+import type { Timer } from '@aztec-labs/foundation/timer';
+import type { CircuitName } from '@aztec-labs/stdlib/stats';
+import {
+  Attributes,
+  type Gauge,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type Tracer,
+} from '@aztec-labs/telemetry-client';
+
+/**
+ * Instrumentation class for Prover implementations.
+ */
+export class ProverInstrumentation {
+  private simulationDuration: Histogram;
+  private witGenDuration: Histogram;
+  private provingDuration: Histogram;
+
+  private witGenInputSize: Gauge;
+  private witGenOutputSize: Gauge;
+
+  private proofSize: Gauge;
+  private circuitSize: Gauge;
+  private circuitPublicInputCount: Gauge;
+
+  public readonly tracer: Tracer;
+
+  constructor(telemetry: TelemetryClient, name: string) {
+    this.tracer = telemetry.getTracer(name);
+    const meter = telemetry.getMeter(name);
+
+    this.simulationDuration = meter.createHistogram(Metrics.CIRCUIT_SIMULATION_DURATION);
+
+    this.witGenDuration = meter.createHistogram(Metrics.CIRCUIT_WITNESS_GEN_DURATION);
+
+    this.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION);
+
+    this.witGenInputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_INPUT_SIZE);
+
+    this.witGenOutputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_OUTPUT_SIZE);
+
+    this.proofSize = meter.createGauge(Metrics.CIRCUIT_PROVING_PROOF_SIZE);
+
+    this.circuitPublicInputCount = meter.createGauge(Metrics.CIRCUIT_PUBLIC_INPUTS_COUNT);
+
+    this.circuitSize = meter.createGauge(Metrics.CIRCUIT_SIZE);
+  }
+
+  /**
+   * Records the duration of a circuit operation.
+   * @param metric - The metric to record
+   * @param circuitName - The name of the circuit
+   * @param timerOrMS - The duration
+   */
+  recordDuration(
+    metric: 'simulationDuration' | 'witGenDuration' | 'provingDuration',
+    circuitName: CircuitName,
+    timerOrMS: Timer | number,
+  ) {
+    // Simulation duration is stored in ms, while the others are stored in seconds
+    if (metric === 'simulationDuration') {
+      const ms = typeof timerOrMS === 'number' ? timerOrMS : timerOrMS.ms();
+      this[metric].record(Math.trunc(ms), {
+        [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+      });
+    } else {
+      const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+      this[metric].record(s, {
+        [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+      });
+    }
+  }
+
+  /**
+   * Records the duration of an AVM circuit operation.
+   * @param metric - The metric to record
+   * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+   * @param timerOrMS - The duration
+   */
+  recordAvmDuration(metric: 'witGenDuration' | 'provingDuration', appCircuitName: string, timerOrMS: Timer | number) {
+    const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+    this[metric].record(s, {
+      [Attributes.APP_CIRCUIT_NAME]: appCircuitName,
+    });
+  }
+
+  /**
+   * Records the size of a circuit operation.
+   * @param metric - Records the size of a circuit operation.
+   * @param circuitName - The name of the circuit
+   * @param size - The size
+   */
+  recordSize(
+    metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
+    circuitName: CircuitName,
+    size: number,
+  ) {
+    this[metric].record(Math.ceil(size), {
+      [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+    });
+  }
+
+  /**
+   * Records the size of an AVM circuit operation.
+   * @param metric - The metric to record
+   * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+   * @param size - The size
+   */
+  recordAvmSize(
+    metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
+    appCircuitName: string,
+    size: number,
+  ) {
+    this[metric].record(Math.ceil(size), {
+      [Attributes.APP_CIRCUIT_NAME]: appCircuitName,
+    });
+  }
+}