@aztec/bb-prover 0.0.1-commit.03f7ef2 → 0.0.1-commit.04d373f

package/src/verifier/batch_chonk_verifier.ts

@@ -0,0 +1,276 @@
+import { BackendType, Barretenberg } from '@aztec/bb.js';
+import { FifoFrameReader } from '@aztec/foundation/fifo';
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import { Timer } from '@aztec/foundation/timer';
+import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
+import type { Tx } from '@aztec/stdlib/tx';
+
+import { Unpackr } from 'msgpackr';
+import { execFile } from 'node:child_process';
+import { unlinkSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { promisify } from 'node:util';
+
+import type { BBConfig } from '../config.js';
+
+const execFileAsync = promisify(execFile);
+
+/** Result from the FIFO, matching the C++ VerifyResult struct. */
+interface FifoVerifyResult {
+  request_id: number;
+  status: number;
+  error_message: string;
+  time_in_verify_ms: number;
+}
+
+/** Maps client protocol artifacts used for chonk verification to VK indices. */
+const CHONK_VK_ARTIFACTS = ['HidingKernelToRollup', 'HidingKernelToPublic'] as const;
+
+interface PendingRequest {
+  resolve: (result: IVCProofVerificationResult) => void;
+  reject: (error: Error) => void;
+  totalTimer: Timer;
+}
+
+/**
+ * Batch verifier for Chonk IVC proofs. Uses the bb batch verifier service
+ * which batches IPA verification into a single SRS MSM for better throughput.
+ *
+ * Architecture:
+ * - Spawns a persistent `bb msgpack run` process via Barretenberg (native backend)
+ * - Sends proofs via the msgpack RPC protocol (ChonkBatchVerifierQueue)
+ * - Receives results via a named FIFO pipe (async, out-of-order)
+ * - Bisects batch failures to isolate individual bad proofs
+ */
+export class BatchChonkVerifier implements ClientProtocolCircuitVerifier {
+  private bb!: Barretenberg;
+  private fifoPath: string;
+  private nextRequestId = 0;
+  private pendingRequests = new Map<number, PendingRequest>();
+  private sendQueue: SerialQueue;
+  private fifoReader: FifoFrameReader;
+  private logger = createLogger('bb-prover:batch_chonk_verifier');
+  /** Maps artifact name to VK index in the batch verifier. */
+  private vkIndexMap = new Map<string, number>();
+  /** Bound cleanup handler for process exit signals. */
+  private exitCleanup: (() => void) | null = null;
+
+  private constructor(
+    private config: Pick<BBConfig, 'bbChonkVerifyConcurrency'> & Partial<Pick<BBConfig, 'bbBinaryPath'>>,
+    private vkBuffers: Uint8Array[],
+    private batchSize: number,
+    private label: string,
+  ) {
+    this.fifoPath = path.join(os.tmpdir(), `bb-batch-${label}-${process.pid}-${Date.now()}.fifo`);
+    this.fifoReader = new FifoFrameReader();
+    this.sendQueue = new SerialQueue();
+    this.sendQueue.start(1);
+  }
+
+  /** Create and start a BatchChonkVerifier using the protocol circuit VKs. */
+  static async new(config: BBConfig, batchSize: number, label: string): Promise<BatchChonkVerifier> {
+    const vkBuffers: Uint8Array[] = [];
+    const vkIndexMap = new Map<string, number>();
+    for (const artifact of CHONK_VK_ARTIFACTS) {
+      const vk = ProtocolCircuitVks[artifact];
+      if (!vk) {
+        throw new Error(`Missing VK for ${artifact}`);
+      }
+      vkIndexMap.set(artifact, vkBuffers.length);
+      vkBuffers.push(vk.keyAsBytes);
+    }
+    const verifier = new BatchChonkVerifier(config, vkBuffers, batchSize, label);
+    verifier.vkIndexMap = vkIndexMap;
+    await verifier.start();
+    return verifier;
+  }
+
+  /** Create and start a BatchChonkVerifier with custom VKs (for testing). */
+  static async newForTesting(
+    config: Pick<BBConfig, 'bbChonkVerifyConcurrency'> & Partial<Pick<BBConfig, 'bbBinaryPath'>>,
+    vks: Uint8Array[],
+    batchSize: number,
+  ): Promise<BatchChonkVerifier> {
+    const verifier = new BatchChonkVerifier(config, vks, batchSize, 'test');
+    for (let i = 0; i < vks.length; i++) {
+      verifier.vkIndexMap.set(String(i), i);
+    }
+    await verifier.start();
+    return verifier;
+  }
+
+  private async start(): Promise<void> {
+    this.logger.info('Starting BatchChonkVerifier');
+
+    this.bb = await Barretenberg.new({
+      bbPath: this.config.bbBinaryPath,
+      backend: BackendType.NativeUnixSocket,
+    });
+    await this.bb.initSRSChonk();
+
+    await execFileAsync('mkfifo', [this.fifoPath]);
+    this.registerExitCleanup();
+
+    await this.bb.chonkBatchVerifierStart({
+      vks: this.vkBuffers,
+      numCores: this.config.bbChonkVerifyConcurrency || 0,
+      batchSize: this.batchSize,
+      fifoPath: this.fifoPath,
+    });
+
+    this.startFifoReader();
+    this.logger.info('BatchChonkVerifier started', { fifoPath: this.fifoPath });
+  }
+
+  public verifyProof(tx: Tx): Promise<IVCProofVerificationResult> {
+    const circuit = tx.data.forPublic ? 'HidingKernelToPublic' : 'HidingKernelToRollup';
+    const vkIndex = this.vkIndexMap.get(circuit);
+    if (vkIndex === undefined) {
+      throw new Error(`No VK index for circuit ${circuit}`);
+    }
+    const proofWithPubInputs = tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields());
+    const proofFields = proofWithPubInputs.fieldsWithPublicInputs.map(f => f.toBuffer());
+    return this.enqueueProof(vkIndex, proofFields);
+  }
+
+  /** Enqueue raw proof fields for verification. Used directly by tests with custom VKs. */
+  public enqueueProof(vkIndex: number, proofFields: Uint8Array[]): Promise<IVCProofVerificationResult> {
+    const totalTimer = new Timer();
+    const requestId = this.nextRequestId++;
+
+    const resultPromise = new Promise<IVCProofVerificationResult>((resolve, reject) => {
+      this.pendingRequests.set(requestId, { resolve, reject, totalTimer });
+    });
+
+    void this.sendQueue
+      .put(async () => {
+        await this.bb.chonkBatchVerifierQueue({
+          requestId,
+          vkIndex,
+          proofFields,
+        });
+      })
+      .catch(err => {
+        const pending = this.pendingRequests.get(requestId);
+        if (pending) {
+          this.pendingRequests.delete(requestId);
+          pending.reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      });
+
+    return resultPromise;
+  }
+
+  public async stop(): Promise<void> {
+    this.logger.info('Stopping BatchChonkVerifier');
+
+    // Stop accepting new proofs
+    await this.sendQueue.end();
+
+    // Stop the bb service (flushes remaining proofs)
+    try {
+      await this.bb.chonkBatchVerifierStop({});
+    } catch (err) {
+      this.logger.warn(`Error stopping batch verifier service: ${err}`);
+    }
+
+    // Stop FIFO reader
+    this.fifoReader.stop();
+
+    // Clean up FIFO file and deregister exit handler
+    await unlink(this.fifoPath).catch(() => {});
+    this.deregisterExitCleanup();
+
+    // Reject any remaining pending requests
+    for (const [id, pending] of this.pendingRequests) {
+      pending.reject(new Error('BatchChonkVerifier stopped'));
+      this.pendingRequests.delete(id);
+    }
+
+    // Destroy bb process
+    await this.bb.destroy();
+
+    this.logger.info('BatchChonkVerifier stopped');
+  }
+
+  private startFifoReader(): void {
+    const unpackr = new Unpackr({ useRecords: false });
+
+    this.fifoReader.on('frame', (payload: Buffer) => {
+      try {
+        const result = unpackr.unpack(payload) as FifoVerifyResult;
+        this.handleResult(result);
+      } catch (err) {
+        this.logger.error(`FIFO: failed to decode msgpack result: ${err}`);
+      }
+    });
+
+    this.fifoReader.on('error', (err: Error) => {
+      this.logger.error(`FIFO reader error: ${err}`);
+    });
+
+    this.fifoReader.on('end', () => {
+      this.logger.debug('FIFO reader: stream ended');
+      for (const [id, pending] of this.pendingRequests) {
+        pending.reject(new Error('FIFO stream ended unexpectedly'));
+        this.pendingRequests.delete(id);
+      }
+    });
+
+    this.fifoReader.start(this.fifoPath);
+  }
+
+  private handleResult(result: FifoVerifyResult): void {
+    const pending = this.pendingRequests.get(result.request_id);
+    if (!pending) {
+      this.logger.warn(`Received result for unknown request_id=${result.request_id}`);
+      return;
+    }
+    this.pendingRequests.delete(result.request_id);
+
+    const valid = result.status === 0; // VerifyStatus::OK
+    const durationMs = result.time_in_verify_ms;
+    const totalDurationMs = pending.totalTimer.ms();
+
+    const ivcResult: IVCProofVerificationResult = { valid, durationMs, totalDurationMs };
+
+    if (!valid) {
+      this.logger.warn(`Proof verification failed for request_id=${result.request_id}: ${result.error_message}`);
+    } else {
+      this.logger.debug(`Proof verified`, {
+        requestId: result.request_id,
+        durationMs: Math.ceil(durationMs),
+        totalDurationMs: Math.ceil(totalDurationMs),
+      });
+    }
+
+    pending.resolve(ivcResult);
+  }
+
+  private registerExitCleanup(): void {
+    // Signal handlers must be synchronous — unlinkSync is intentional here
+    this.exitCleanup = () => {
+      try {
+        unlinkSync(this.fifoPath);
+      } catch {
+        /* ignore */
+      }
+    };
+    process.on('exit', this.exitCleanup);
+    process.on('SIGINT', this.exitCleanup);
+    process.on('SIGTERM', this.exitCleanup);
+  }
+
+  private deregisterExitCleanup(): void {
+    if (this.exitCleanup) {
+      process.removeListener('exit', this.exitCleanup);
+      process.removeListener('SIGINT', this.exitCleanup);
+      process.removeListener('SIGTERM', this.exitCleanup);
+      this.exitCleanup = null;
+    }
+  }
+}

package/src/verifier/bb_verifier.ts

@@ -1,4 +1,3 @@
-import { runInDirectory } from '@aztec/foundation/fs';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
@@ -15,28 +14,29 @@ import { Tx } from '@aztec/stdlib/tx';
 import type { VerificationKeyData } from '@aztec/stdlib/vks';
 
 import { promises as fs } from 'fs';
-import * as path from 'path';
 
-import {
-  BB_RESULT,
-  PROOF_FILENAME,
-  PUBLIC_INPUTS_FILENAME,
-  VK_FILENAME,
-  verifyChonkProof,
-  verifyProof,
-} from '../bb/execute.js';
+import { BBJsFactory } from '../bb/bb_js_backend.js';
 import type { BBConfig } from '../config.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
-import { writeChonkProofToPath } from '../prover/proof_utils.js';
 
 export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
+  private bbJsFactory: BBJsFactory;
+
   private constructor(
     private config: BBConfig,
     private logger: Logger,
-  ) {}
+  ) {
+    // BB_NUM_IVC_VERIFIERS bounds the number of long-lived bb processes the pool keeps alive.
+    // If 0, fall back to spawning a fresh bb per verification.
+    this.bbJsFactory = new BBJsFactory(config.bbBinaryPath, {
+      poolSize: config.numConcurrentIVCVerifiers > 0 ? config.numConcurrentIVCVerifiers : undefined,
+      logger,
+      debugDir: config.bbDebugOutputDir,
+    });
+  }
 
   public stop(): Promise<void> {
-    return Promise.resolve();
+    return this.bbJsFactory.destroy();
   }
 
   public static async new(config: BBConfig, logger = createLogger('bb-prover:verifier')) {
@@ -55,91 +55,77 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
     return vk;
   }
 
+  /** Verify an UltraHonk proof via bb.js API (no temp files). */
   public async verifyProofForCircuit(circuit: ServerProtocolArtifact, proof: Proof) {
-    const operation = async (bbWorkingDirectory: string) => {
-      const publicInputsFileName = path.join(bbWorkingDirectory, PUBLIC_INPUTS_FILENAME);
-      const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
-      const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
-      const verificationKey = this.getVerificationKeyData(circuit);
+    const verificationKey = this.getVerificationKeyData(circuit);
+    const flavor = getUltraHonkFlavorForCircuit(circuit);
 
-      this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
+    this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
 
-      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13189): Put this proof parsing logic in the proof class.
-      await fs.writeFile(publicInputsFileName, proof.buffer.slice(0, proof.numPublicInputs * 32));
-      await fs.writeFile(proofFileName, proof.buffer.slice(proof.numPublicInputs * 32));
-      await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+    // Split proof buffer into public input fields and proof fields (32-byte each)
+    const publicInputFields = splitBufferToFieldArrays(proof.buffer.subarray(0, proof.numPublicInputs * 32));
+    const proofFields = splitBufferToFieldArrays(proof.buffer.subarray(proof.numPublicInputs * 32));
 
-      const result = await verifyProof(
-        this.config.bbBinaryPath,
-        proofFileName,
-        verificationKeyPath!,
-        getUltraHonkFlavorForCircuit(circuit),
-        this.logger,
-      );
+    await using instance = await this.bbJsFactory.getInstance();
+    const { verified, durationMs } = await instance.verifyProof(
+      proofFields,
+      verificationKey.keyAsBytes,
+      publicInputFields,
+      flavor,
+    );
 
-      if (result.status === BB_RESULT.FAILURE) {
-        const errorMessage = `Failed to verify ${circuit} proof!`;
-        throw new Error(errorMessage);
-      }
+    if (!verified) {
+      throw new Error(`Failed to verify ${circuit} proof!`);
+    }
 
-      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, this.config.bbSkipCleanup, this.logger);
+    this.logger.debug(`${circuit} verification successful`, {
+      circuitName: mapProtocolArtifactNameToCircuitName(circuit),
+      duration: durationMs,
+      eventName: 'circuit-verification',
+      proofType: 'ultra-honk',
+    } satisfies CircuitVerificationStats);
   }
 
+  /** Verify a Chonk (IVC) proof from a transaction via bb.js API. */
   public async verifyProof(tx: Tx): Promise<IVCProofVerificationResult> {
     const proofType = 'Chonk';
     try {
       const totalTimer = new Timer();
-      let verificationDuration = 0;
 
       const circuit: ClientProtocolArtifact = tx.data.forPublic ? 'HidingKernelToPublic' : 'HidingKernelToRollup';
+      const verificationKey = this.getVerificationKeyData(circuit);
+
+      // Reconstruct the full proof with public inputs prepended, then convert Fr[] to Uint8Array[]
+      const proofWithPubInputs = tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields());
+      const fieldsAsBuffers = proofWithPubInputs.fieldsWithPublicInputs.map(f => new Uint8Array(f.toBuffer()));
 
-      // Block below is almost copy-pasted from verifyProofForCircuit
-      const operation = async (bbWorkingDirectory: string) => {
-        const logFunction = (message: string) => {
-          this.logger.debug(`${proofType} BB out - ${message}`);
-        };
-
-        const proofPath = path.join(bbWorkingDirectory, PROOF_FILENAME);
-        await writeChonkProofToPath(tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields()), proofPath);
-
-        const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
-        const verificationKey = this.getVerificationKeyData(circuit);
-        await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
-
-        const timer = new Timer();
-        const result = await verifyChonkProof(
-          this.config.bbBinaryPath,
-          proofPath,
-          verificationKeyPath,
-          logFunction,
-          this.config.bbIVCConcurrency,
-        );
-        verificationDuration = timer.ms();
-
-        if (result.status === BB_RESULT.FAILURE) {
-          const errorMessage = `Failed to verify ${proofType} proof for ${circuit}!`;
-          throw new Error(errorMessage);
-        }
-
-        this.logger.debug(`${proofType} verification successful`, {
-          circuitName: mapProtocolArtifactNameToCircuitName(circuit),
-          duration: result.durationMs,
-          eventName: 'circuit-verification',
-          proofType: 'chonk',
-        } satisfies CircuitVerificationStats);
-      };
-      await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
-      return { valid: true, durationMs: verificationDuration, totalDurationMs: totalTimer.ms() };
+      await using instance = await this.bbJsFactory.getInstance();
+      const { verified, durationMs } = await instance.verifyChonkProof(fieldsAsBuffers, verificationKey.keyAsBytes);
+
+      if (!verified) {
+        throw new Error(`Failed to verify ${proofType} proof for ${circuit}!`);
+      }
+
+      this.logger.debug(`${proofType} verification successful`, {
+        circuitName: mapProtocolArtifactNameToCircuitName(circuit),
+        duration: durationMs,
+        eventName: 'circuit-verification',
+        proofType: 'chonk',
+      } satisfies CircuitVerificationStats);
+
+      return { valid: true, durationMs, totalDurationMs: totalTimer.ms() };
     } catch (err) {
       this.logger.warn(`Failed to verify ${proofType} proof for tx ${tx.getTxHash().toString()}: ${String(err)}`);
       return { valid: false, durationMs: 0, totalDurationMs: 0 };
     }
   }
 }
+
+/** Split a buffer into 32-byte Uint8Array field elements. */
+function splitBufferToFieldArrays(buffer: Buffer): Uint8Array[] {
+  const fields: Uint8Array[] = [];
+  for (let i = 0; i < buffer.length; i += 32) {
+    fields.push(new Uint8Array(buffer.subarray(i, i + 32)));
+  }
+  return fields;
+}

package/src/verifier/index.ts

@@ -1,2 +1,3 @@
+export * from './batch_chonk_verifier.js';
 export * from './bb_verifier.js';
 export * from './queued_chonk_verifier.js';

package/src/verifier/queued_chonk_verifier.ts

@@ -10,14 +10,12 @@ import {
   type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
 import { createHistogram } from 'node:perf_hooks';
 
-import type { BBConfig } from '../config.js';
-
 class IVCVerifierMetrics {
   private ivcVerificationHistogram: Histogram;
   private ivcTotalVerificationHistogram: Histogram;
@@ -36,49 +34,18 @@ class IVCVerifierMetrics {
   constructor(client: TelemetryClient, name = 'QueuedIVCVerifier') {
     const meter = client.getMeter(name);
 
-    this.ivcVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TIME, {
-      unit: 'ms',
-      description: 'Duration to verify chonk proofs',
-      valueType: ValueType.INT,
-    });
+    this.ivcVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TIME);
 
-    this.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME, {
-      unit: 'ms',
-      description: 'Total duration to verify chonk proofs, including serde',
-      valueType: ValueType.INT,
-    });
+    this.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME);
 
-    this.ivcFailureCount = meter.createUpDownCounter(Metrics.IVC_VERIFIER_FAILURE_COUNT, {
-      description: 'Count of failed IVC proof verifications',
-      valueType: ValueType.INT,
-    });
+    this.ivcFailureCount = createUpDownCounterWithDefault(meter, Metrics.IVC_VERIFIER_FAILURE_COUNT);
 
     this.aggDurationMetrics = {
-      avg: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_AVG, {
-        valueType: ValueType.DOUBLE,
-        description: 'AVG ivc verification',
-        unit: 'ms',
-      }),
-      max: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MAX, {
-        valueType: ValueType.DOUBLE,
-        description: 'MAX ivc verification',
-        unit: 'ms',
-      }),
-      min: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MIN, {
-        valueType: ValueType.DOUBLE,
-        description: 'MIN ivc verification',
-        unit: 'ms',
-      }),
-      p50: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P50, {
-        valueType: ValueType.DOUBLE,
-        description: 'P50 ivc verification',
-        unit: 'ms',
-      }),
-      p90: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P90, {
-        valueType: ValueType.DOUBLE,
-        description: 'P90 ivc verification',
-        unit: 'ms',
-      }),
+      avg: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_AVG),
+      max: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MAX),
+      min: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MIN),
+      p50: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P50),
+      p90: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P90),
     };
 
     meter.addBatchObservableCallback(this.aggregate, Object.values(this.aggDurationMetrics));
@@ -117,15 +84,15 @@ export class QueuedIVCVerifier implements ClientProtocolCircuitVerifier {
   private metrics: IVCVerifierMetrics;
 
   public constructor(
-    config: BBConfig,
     private verifier: ClientProtocolCircuitVerifier,
+    concurrency: number,
     private telemetry: TelemetryClient = getTelemetryClient(),
     private logger = createLogger('bb-prover:queued_chonk_verifier'),
   ) {
     this.metrics = new IVCVerifierMetrics(this.telemetry, 'QueuedIVCVerifier');
     this.queue = new SerialQueue();
-    this.logger.info(`Starting QueuedIVCVerifier with ${config.numConcurrentIVCVerifiers} concurrent verifiers`);
-    this.queue.start(config.numConcurrentIVCVerifiers);
+    this.logger.info(`Starting QueuedIVCVerifier with ${concurrency} concurrent verifiers`);
+    this.queue.start(concurrency);
   }
 
   public async verifyProof(tx: Tx): Promise<IVCProofVerificationResult> {
@@ -134,7 +101,8 @@ export class QueuedIVCVerifier implements ClientProtocolCircuitVerifier {
     return result;
   }
 
-  stop(): Promise<void> {
-    return this.queue.end();
+  async stop(): Promise<void> {
+    await this.queue.end();
+    await this.verifier.stop();
   }
 }