@aztec/bb-prover 0.47.0 → 0.48.0

package/src/bb/execute.ts

@@ -621,6 +621,46 @@ export async function verifyAvmProof(
   return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', log);
 }
 
+/**
+ * Verifies a ClientIvcProof
+ * TODO(#7370) The verification keys should be supplied separately
+ * @param pathToBB - The full path to the bb binary
+ * @param targetPath - The path to the folder with the proof, accumulator, and verification keys
+ * @param log - A logging function
+ * @returns An object containing a result indication and duration taken
+ */
+export async function verifyClientIvcProof(
+  pathToBB: string,
+  targetPath: string,
+  log: LogFn,
+): Promise<BBFailure | BBSuccess> {
+  const binaryPresent = await fs
+    .access(pathToBB, fs.constants.R_OK)
+    .then(_ => true)
+    .catch(_ => false);
+  if (!binaryPresent) {
+    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
+  }
+
+  try {
+    const args = ['-o', targetPath];
+    const timer = new Timer();
+    const command = 'verify_client_ivc';
+    const result = await executeBB(pathToBB, command, args, log);
+    const duration = timer.ms();
+    if (result.status == BB_RESULT.SUCCESS) {
+      return { status: BB_RESULT.SUCCESS, durationMs: duration };
+    }
+    // Not a great error message here but it is difficult to decipher what comes from bb
+    return {
+      status: BB_RESULT.FAILURE,
+      reason: `Failed to verify proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+    };
+  } catch (error) {
+    return { status: BB_RESULT.FAILURE, reason: `${error}` };
+  }
+}
+
 /**
  * Used for verifying proofs with BB
  * @param pathToBB - The full path to the bb binary

package/src/instrumentation.ts

@@ -8,6 +8,7 @@ import {
   type TelemetryClient,
   type Tracer,
   ValueType,
+  millisecondBuckets,
 } from '@aztec/telemetry-client';
 
 /**
@@ -15,8 +16,8 @@ import {
  */
 export class ProverInstrumentation {
   private simulationDuration: Histogram;
-  private witGenDuration: Gauge;
-  private provingDuration: Gauge;
+  private witGenDuration: Histogram;
+  private provingDuration: Histogram;
 
   private witGenInputSize: Gauge;
   private witGenOutputSize: Gauge;
@@ -33,25 +34,29 @@ export class ProverInstrumentation {
 
     this.simulationDuration = meter.createHistogram(Metrics.CIRCUIT_SIMULATION_DURATION, {
       description: 'Records how long it takes to simulate a circuit',
-      unit: 's',
-      valueType: ValueType.DOUBLE,
+      unit: 'ms',
+      valueType: ValueType.INT,
       advice: {
-        explicitBucketBoundaries: [0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60],
+        explicitBucketBoundaries: millisecondBuckets(1), // 10ms -> ~327s
       },
     });
 
-    this.witGenDuration = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_DURATION, {
+    this.witGenDuration = meter.createHistogram(Metrics.CIRCUIT_WITNESS_GEN_DURATION, {
       description: 'Records how long it takes to generate the partial witness for a circuit',
-      unit: 's',
-      valueType: ValueType.DOUBLE,
+      unit: 'ms',
+      valueType: ValueType.INT,
+      advice: {
+        explicitBucketBoundaries: millisecondBuckets(1),
+      },
     });
 
-    // ideally this would be a histogram, but proving takes a long time on the server
-    // and they don't happen that often so Prometheus & Grafana have a hard time handling it
-    this.provingDuration = meter.createGauge(Metrics.CIRCUIT_PROVING_DURATION, {
-      unit: 's',
+    this.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION, {
+      unit: 'ms',
       description: 'Records how long it takes to prove a circuit',
-      valueType: ValueType.DOUBLE,
+      valueType: ValueType.INT,
+      advice: {
+        explicitBucketBoundaries: millisecondBuckets(2), // 100ms -> 54 minutes
+      },
     });
 
     this.witGenInputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_INPUT_SIZE, {
@@ -87,15 +92,15 @@ export class ProverInstrumentation {
    * Records the duration of a circuit operation.
    * @param metric - The metric to record
    * @param circuitName - The name of the circuit
-   * @param timerOrS - The duration
+   * @param timerOrMS - The duration
    */
   recordDuration(
     metric: 'simulationDuration' | 'witGenDuration' | 'provingDuration',
-    circuitName: CircuitName,
-    timerOrS: Timer | number,
+    circuitName: CircuitName | 'tubeCircuit',
+    timerOrMS: Timer | number,
   ) {
-    const s = typeof timerOrS === 'number' ? timerOrS : timerOrS.s();
-    this[metric].record(s, {
+    const ms = typeof timerOrMS === 'number' ? timerOrMS : timerOrMS.ms();
+    this[metric].record(Math.ceil(ms), {
       [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
       [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
     });
@@ -105,11 +110,11 @@ export class ProverInstrumentation {
    * 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 timerOrS - The duration
+   * @param timerOrMS - The duration
    */
-  recordAvmDuration(metric: 'witGenDuration' | 'provingDuration', appCircuitName: string, timerOrS: Timer | number) {
-    const s = typeof timerOrS === 'number' ? timerOrS : timerOrS.s();
-    this[metric].record(s, {
+  recordAvmDuration(metric: 'witGenDuration' | 'provingDuration', appCircuitName: string, timerOrMS: Timer | number) {
+    const ms = typeof timerOrMS === 'number' ? timerOrMS : timerOrMS.s();
+    this[metric].record(Math.ceil(ms), {
       [Attributes.APP_CIRCUIT_NAME]: appCircuitName,
     });
   }
@@ -122,7 +127,7 @@ export class ProverInstrumentation {
    */
   recordSize(
     metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
-    circuitName: CircuitName,
+    circuitName: CircuitName | 'tubeCircuit',
     size: number,
   ) {
     this[metric].record(Math.ceil(size), {

package/src/prover/bb_private_kernel_prover.ts

@@ -5,6 +5,7 @@ import {
 } from '@aztec/circuit-types';
 import { type CircuitSimulationStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
+  AGGREGATION_OBJECT_LENGTH,
   ClientIvcProof,
   Fr,
   type PrivateCircuitPublicInputs,
@@ -350,10 +351,8 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     ]);
     const json = JSON.parse(proofString);
     const fields = json.map(Fr.fromString);
-    const numPublicInputs = vkData.numPublicInputs;
-    // const numPublicInputs =
-    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1044): Reinstate aggregation
-    //   circuitType === 'App' ? vkData.numPublicInputs : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+    const numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+
     const fieldsWithoutPublicInputs = fields.slice(numPublicInputs);
     this.log.info(
       `Circuit type: ${circuitType}, complete proof length: ${fields.length}, without public inputs: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`,

package/src/prover/bb_prover.ts

@@ -9,6 +9,7 @@ import {
 } from '@aztec/circuit-types';
 import { type CircuitProvingStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
+  AGGREGATION_OBJECT_LENGTH,
   type AvmCircuitInputs,
   type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
@@ -30,7 +31,7 @@ import {
   type RootRollupInputs,
   type RootRollupPublicInputs,
   TUBE_PROOF_LENGTH,
-  TubeInputs,
+  type TubeInputs,
   type VerificationKeyAsFields,
   type VerificationKeyData,
   makeRecursiveProofFromBinary,
@@ -225,16 +226,6 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       kernelRequest.inputs.previousKernel.vk,
     );
 
-    // PUBLIC KERNEL: kernel request should be nonempty at start of public kernel proving but it is not
-    // TODO(#7369): We should properly enqueue the tube in the public kernel lifetime
-    if (!kernelRequest.inputs.previousKernel.clientIvcProof.isEmpty()) {
-      const { tubeVK, tubeProof } = await this.getTubeProof(
-        new TubeInputs(kernelRequest.inputs.previousKernel.clientIvcProof),
-      );
-      kernelRequest.inputs.previousKernel.vk = tubeVK;
-      kernelRequest.inputs.previousKernel.proof = tubeProof;
-    }
-
     await this.verifyWithKey(
       kernelRequest.inputs.previousKernel.vk,
       kernelRequest.inputs.previousKernel.proof.binaryProof,
@@ -288,9 +279,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     // We may need to convert the recursive proof into fields format
     logger.debug(`kernel Data proof: ${baseRollupInput.kernelData.proof}`);
-    logger.info(`in getBaseRollupProof`);
-    logger.info(`Number of public inputs in baseRollupInput: ${baseRollupInput.kernelData.vk.numPublicInputs}`);
-    logger.info(`Number of public inputs ${baseRollupInput.kernelData.publicInputs}`);
+    logger.debug(`Number of public inputs in baseRollupInput: ${baseRollupInput.kernelData.vk.numPublicInputs}`);
     baseRollupInput.kernelData.proof = await this.ensureValidProof(
       baseRollupInput.kernelData.proof,
       'BaseRollupArtifact',
@@ -476,7 +465,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     this.instrumentation.recordSize('witGenInputSize', circuitName, input.toBuffer().length);
     this.instrumentation.recordSize('witGenOutputSize', circuitName, output.toBuffer().length);
 
-    logger.debug(`Generated witness`, {
+    logger.info(`Generated witness`, {
       circuitName,
       duration: timer.ms(),
       inputSize: input.toBuffer().length,
@@ -530,7 +519,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       const proof = new Proof(rawProof, vkData.numPublicInputs);
       const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
 
-      this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs / 1000);
+      this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
       this.instrumentation.recordSize('proofSize', circuitName, proof.buffer.length);
       this.instrumentation.recordSize('circuitPublicInputCount', circuitName, vkData.numPublicInputs);
       this.instrumentation.recordSize('circuitSize', circuitName, vkData.circuitSize);
@@ -633,6 +622,12 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       // Read the proof as fields
       const tubeVK = await extractVkData(provingResult.vkPath!);
       const tubeProof = await this.readTubeProofAsFields(provingResult.proofPath!, tubeVK, TUBE_PROOF_LENGTH);
+
+      this.instrumentation.recordDuration('provingDuration', 'tubeCircuit', provingResult.durationMs);
+      this.instrumentation.recordSize('proofSize', 'tubeCircuit', tubeProof.binaryProof.buffer.length);
+      this.instrumentation.recordSize('circuitPublicInputCount', 'tubeCircuit', tubeVK.numPublicInputs);
+      this.instrumentation.recordSize('circuitSize', 'tubeCircuit', tubeVK.circuitSize);
+
       // Sanity check the tube proof (can be removed later)
       await this.verifyWithKey(tubeVK, tubeProof.binaryProof);
 
@@ -680,7 +675,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       const proof = await this.readProofAsFields(provingResult.proofPath!, circuitType, proofLength);
 
       const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
-      this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs / 1000);
+      this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
       this.instrumentation.recordSize('proofSize', circuitName, proof.binaryProof.buffer.length);
       this.instrumentation.recordSize('circuitPublicInputCount', circuitName, vkData.numPublicInputs);
       this.instrumentation.recordSize('circuitSize', circuitName, vkData.circuitSize);
@@ -787,8 +782,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     }
 
     const operation = async (bbWorkingDirectory: string) => {
-      // const numPublicInputs = vk.numPublicInputs;
-      const numPublicInputs = vk.numPublicInputs; // - AGGREGATION_OBJECT_LENGTH;
+      const numPublicInputs = vk.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
       const proofFullFilename = path.join(bbWorkingDirectory, PROOF_FILENAME);
       const vkFullFilename = path.join(bbWorkingDirectory, VK_FILENAME);
 
@@ -900,11 +894,8 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     if (!vkData) {
       throw new Error(`Invalid verification key for ${circuitType}`);
     }
-    const numPublicInputs = vkData.numPublicInputs;
-    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1044): Reinstate aggregation
-    // const numPublicInputs = CIRCUITS_WITHOUT_AGGREGATION.has(circuitType)
-    //   ? vkData.numPublicInputs
-    //   : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+    const numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+
     const fieldsWithoutPublicInputs = json
       .slice(0, 3)
       .map(Fr.fromString)
@@ -949,7 +940,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     const json = JSON.parse(proofString);
 
-    const numPublicInputs = vkData.numPublicInputs;
+    const numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
     if (numPublicInputs === 0) {
       throw new Error(`Tube proof should have public inputs (e.g. the number of public inputs from PrivateKernelTail)`);
     }

package/src/test/test_circuit_prover.ts

@@ -33,6 +33,7 @@ import {
   makeRecursiveProof,
 } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
 import {
   ProtocolCircuitVkIndexes,
@@ -70,11 +71,12 @@ import { mapPublicKernelToCircuitName } from '../stats.js';
 export class TestCircuitProver implements ServerCircuitProver {
   private wasmSimulator = new WASMSimulator();
   private instrumentation: ProverInstrumentation;
+  private logger = createDebugLogger('aztec:test-prover');
 
   constructor(
     telemetry: TelemetryClient,
     private simulationProvider?: SimulationProvider,
-    private logger = createDebugLogger('aztec:test-prover'),
+    private opts: { proverTestDelayMs: number } = { proverTestDelayMs: 0 },
   ) {
     this.instrumentation = new ProverInstrumentation(telemetry, 'TestCircuitProver');
   }
@@ -103,7 +105,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       SimulatedServerCircuitArtifacts.PrivateKernelEmptyArtifact,
     );
     const result = convertSimulatedPrivateKernelEmptyOutputsFromWitnessMap(witness);
-
+    await this.delay();
     return makePublicInputsAndRecursiveProof(
       result,
       makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
@@ -131,7 +133,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       SimulatedServerCircuitArtifacts.PrivateKernelEmptyArtifact,
     );
     const result = convertPrivateKernelEmptyOutputsFromWitnessMap(witness);
-
+    await this.delay();
     return makePublicInputsAndRecursiveProof(
       result,
       makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
@@ -172,7 +174,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
-
+    await this.delay();
     return Promise.resolve(rootParityInput);
   }
 
@@ -211,7 +213,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
-
+    await this.delay();
     return Promise.resolve(rootParityInput);
   }
 
@@ -243,6 +245,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
+    await this.delay();
     return makePublicInputsAndRecursiveProof(
       result,
       makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
@@ -250,13 +253,14 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
-  public getTubeProof(
+  public async getTubeProof(
     _tubeInput: TubeInputs,
   ): Promise<{ tubeVK: VerificationKeyData; tubeProof: RecursiveProof<typeof TUBE_PROOF_LENGTH> }> {
-    return Promise.resolve({
+    await this.delay();
+    return {
       tubeVK: VerificationKeyData.makeFake(),
       tubeProof: makeEmptyRecursiveProof(TUBE_PROOF_LENGTH),
-    });
+    };
   }
 
   /**
@@ -287,6 +291,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
+    await this.delay();
     return makePublicInputsAndRecursiveProof(
       result,
       makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
@@ -322,6 +327,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
+    await this.delay();
     return makePublicInputsAndRecursiveProof(
       result,
       makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
@@ -355,7 +361,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
-
+    await this.delay();
     return makePublicInputsAndRecursiveProof(
       result,
       makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
@@ -384,7 +390,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       result.toBuffer().length,
       this.logger,
     );
-
+    await this.delay();
     return makePublicInputsAndRecursiveProof(
       result,
       makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
@@ -392,11 +398,18 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
-  getAvmProof(_inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
+  public async getAvmProof(_inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
     // We can't simulate the AVM because we don't have enough context to do so (e.g., DBs).
     // We just return an empty proof and VK data.
     this.logger.debug('Skipping AVM simulation in TestCircuitProver.');
-    return Promise.resolve({ proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() });
+    await this.delay();
+    return { proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() };
+  }
+
+  private async delay(): Promise<void> {
+    if (this.opts.proverTestDelayMs > 0) {
+      await sleep(this.opts.proverTestDelayMs);
+    }
   }
 
   // Not implemented for test circuits

package/src/verifier/bb_verifier.ts

@@ -1,4 +1,5 @@
 import { type ClientProtocolCircuitVerifier, Tx } from '@aztec/circuit-types';
+import { type CircuitVerificationStats } from '@aztec/circuit-types/stats';
 import { type Proof, type VerificationKeyData } from '@aztec/circuits.js';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { type DebugLogger, type LogFn, createDebugLogger } from '@aztec/foundation/log';
@@ -17,9 +18,11 @@ import {
   VK_FILENAME,
   generateContractForCircuit,
   generateKeyForNoirCircuit,
+  verifyClientIvcProof,
   verifyProof,
 } from '../bb/execute.js';
 import { type BBConfig } from '../config.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
 
 export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
@@ -106,7 +109,12 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
         throw new Error(errorMessage);
       }
 
-      this.logger.debug(`${circuit} verification successful`);
+      this.logger.debug(`${circuit} verification successful`, {
+        circuitName: mapProtocolArtifactNameToCircuitName(circuit),
+        duration: result.durationMs,
+        eventName: 'circuit-verification',
+        proofType: 'ultra-honk',
+      } satisfies CircuitVerificationStats);
     };
     await runInDirectory(this.config.bbWorkingDirectory, operation);
   }
@@ -128,19 +136,43 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
     return fs.readFile(result.contractPath!, 'utf-8');
   }
 
-  verifyProof(tx: Tx): Promise<boolean> {
-    const expectedCircuit: ClientProtocolArtifact = tx.data.forPublic
-      ? 'PrivateKernelTailToPublicArtifact'
-      : 'PrivateKernelTailArtifact';
-
+  public async verifyProof(tx: Tx): Promise<boolean> {
     try {
-      // TODO(https://github.com/AztecProtocol/barretenberg/issues/1050) we need a proper verify flow for clientIvcProof
-      // For now we handle only the trivial blank data case
-      // await this.verifyProofForCircuit(expectedCircuit, proof);
-      return Promise.resolve(!tx.clientIvcProof.isEmpty());
+      // TODO(#7370) The verification keys should be supplied separately and based on the expectedCircuit
+      // rather than read from the tx object itself. We also need the vks for the translator and ecc, which
+      // are not being saved along the other vks yet. Reuse the 'verifyProofForCircuit' method above once
+      // we have all the verification keys available.
+      const expectedCircuit: ClientProtocolArtifact = tx.data.forPublic
+        ? 'PrivateKernelTailToPublicArtifact'
+        : 'PrivateKernelTailArtifact';
+      const circuit = 'ClientIVC';
+
+      // Block below is almost copy-pasted from verifyProofForCircuit
+      const operation = async (bbWorkingDirectory: string) => {
+        const logFunction = (message: string) => {
+          this.logger.debug(`${circuit} BB out - ${message}`);
+        };
+
+        await tx.clientIvcProof.writeToOutputDirectory(bbWorkingDirectory);
+        const result = await verifyClientIvcProof(this.config.bbBinaryPath, bbWorkingDirectory, logFunction);
+
+        if (result.status === BB_RESULT.FAILURE) {
+          const errorMessage = `Failed to verify ${circuit} proof!`;
+          throw new Error(errorMessage);
+        }
+
+        this.logger.debug(`${circuit} verification successful`, {
+          circuitName: mapProtocolArtifactNameToCircuitName(expectedCircuit),
+          duration: result.durationMs,
+          eventName: 'circuit-verification',
+          proofType: 'client-ivc',
+        } satisfies CircuitVerificationStats);
+      };
+      await runInDirectory(this.config.bbWorkingDirectory, operation);
+      return true;
     } catch (err) {
-      this.logger.warn(`Failed to verify ${expectedCircuit} proof for tx ${Tx.getHash(tx)}: ${String(err)}`);
-      return Promise.resolve(false);
+      this.logger.warn(`Failed to verify ClientIVC proof for tx ${Tx.getHash(tx)}: ${String(err)}`);
+      return false;
     }
   }
 }