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

package/dest/verifier/batch_chonk_verifier.d.ts

@@ -0,0 +1,57 @@
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec-labs/stdlib/interfaces/server';
+import type { Tx } from '@aztec-labs/stdlib/tx';
+import type { BBConfig } from '../config.js';
+/**
+ * Batch verifier for Chonk IVC proofs. Uses the bb batch verifier service
+ * which batches IPA verification into a constant number of SRS MSMs 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 declare class BatchChonkVerifier implements ClientProtocolCircuitVerifier {
+    private config;
+    private vkBuffers;
+    private batchSize;
+    private label;
+    private bb;
+    private fifoDir;
+    private fifoPath;
+    private nextRequestId;
+    private pendingRequests;
+    private sendQueue;
+    private fifoReader;
+    private logger;
+    private metrics;
+    /** Maps artifact name to VK index in the batch verifier. */
+    private vkIndexMap;
+    /** Bound cleanup handler for process exit signals. */
+    private exitCleanup;
+    private stopped;
+    private fatalError;
+    private pendingDrainedResolvers;
+    private constructor();
+    /** Create and start a BatchChonkVerifier using the protocol circuit VKs. */
+    static new(config: BBConfig, batchSize: number, label: string): Promise<BatchChonkVerifier>;
+    /** Create and start a BatchChonkVerifier with custom VKs (for testing). */
+    static newForTesting(config: Pick<BBConfig, 'bbChonkVerifyConcurrency'> & Partial<Pick<BBConfig, 'bbBinaryPath'>>, vks: Uint8Array[], batchSize: number): Promise<BatchChonkVerifier>;
+    private start;
+    verifyProof(tx: Tx): Promise<IVCProofVerificationResult>;
+    /** Enqueue raw proof fields for verification. Used directly by tests with custom VKs. */
+    enqueueProof(vkIndex: number, proofFields: Uint8Array[]): Promise<IVCProofVerificationResult>;
+    stop(): Promise<void>;
+    private withTimeout;
+    private startFifoReader;
+    private handleResult;
+    private registerExitCleanup;
+    private deregisterExitCleanup;
+    private rejectPendingRequests;
+    private failVerifier;
+    private waitForPendingRequestsToDrain;
+    private notifyPendingDrained;
+    private cleanupFifo;
+    private cleanupFifoSync;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/verifier/batch_chonk_verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch_chonk_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/batch_chonk_verifier.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AACtH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAUhD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAyB7C;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,YAAW,6BAA6B;IAmBpE,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,KAAK;IArBf,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,eAAe,CAAqC;IAC5D,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,MAAM,CAAkD;IAChE,OAAO,CAAC,OAAO,CAAqB;IACpC,4DAA4D;IAC5D,OAAO,CAAC,UAAU,CAA6B;IAC/C,sDAAsD;IACtD,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,uBAAuB,CAAyB;IAExD,OAAO,eAUN;IAED,4EAA4E;IAC5E,OAAa,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAehG;IAED,2EAA2E;IAC3E,OAAa,aAAa,CACxB,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,0BAA0B,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,EAC5F,GAAG,EAAE,UAAU,EAAE,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,kBAAkB,CAAC,CAO7B;YAEa,KAAK;IAiCZ,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAe9D;IAED,yFAAyF;IAClF,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAkDnG;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA+BjC;YAOa,WAAW;IAkBzB,OAAO,CAAC,eAAe;IA6BvB,OAAO,CAAC,YAAY;IA8BpB,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,6BAA6B;IA0BrC,OAAO,CAAC,oBAAoB;YASd,WAAW;IAUzB,OAAO,CAAC,eAAe;CAWxB"}

package/dest/verifier/batch_chonk_verifier.js

@@ -0,0 +1,389 @@
+import { BackendType, Barretenberg } from '@aztec/bb.js';
+import { FifoFrameReader } from '@aztec-labs/foundation/fifo';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { ProtocolCircuitVks } from '@aztec-labs/noir-protocol-circuits-types/server/vks';
+import { getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { Unpackr } from 'msgpackr';
+import { execFile } from 'node:child_process';
+import { rmSync } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { promisify } from 'node:util';
+import { IVCVerifierMetrics } from './queued_chonk_verifier.js';
+const execFileAsync = promisify(execFile);
+const RESULT_TIMEOUT_MS = 5 * 60 * 1000;
+const STOP_DRAIN_TIMEOUT_MS = 5_000;
+/** Maps client protocol artifacts used for chonk verification to VK indices. */ const CHONK_VK_ARTIFACTS = [
+    'HidingKernelToRollup',
+    'HidingKernelToPublic'
+];
+/**
+ * Batch verifier for Chonk IVC proofs. Uses the bb batch verifier service
+ * which batches IPA verification into a constant number of SRS MSMs 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 {
+    config;
+    vkBuffers;
+    batchSize;
+    label;
+    bb;
+    fifoDir;
+    fifoPath;
+    nextRequestId;
+    pendingRequests;
+    sendQueue;
+    fifoReader;
+    logger;
+    metrics;
+    /** Maps artifact name to VK index in the batch verifier. */ vkIndexMap;
+    /** Bound cleanup handler for process exit signals. */ exitCleanup;
+    stopped;
+    fatalError;
+    pendingDrainedResolvers;
+    constructor(config, vkBuffers, batchSize, label){
+        this.config = config;
+        this.vkBuffers = vkBuffers;
+        this.batchSize = batchSize;
+        this.label = label;
+        this.fifoPath = '';
+        this.nextRequestId = 0;
+        this.pendingRequests = new Map();
+        this.logger = createLogger('bb-prover:batch_chonk_verifier');
+        this.vkIndexMap = new Map();
+        this.exitCleanup = null;
+        this.stopped = false;
+        this.pendingDrainedResolvers = new Set();
+        this.fifoReader = new FifoFrameReader();
+        this.sendQueue = new SerialQueue();
+        this.sendQueue.start(1);
+        this.metrics = new IVCVerifierMetrics(getTelemetryClient(), `BatchChonkVerifier-${label}`);
+    }
+    /** Create and start a BatchChonkVerifier using the protocol circuit VKs. */ static async new(config, batchSize, label) {
+        const vkBuffers = [];
+        const vkIndexMap = new Map();
+        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, vks, batchSize) {
+        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;
+    }
+    async start() {
+        this.logger.info('Starting BatchChonkVerifier');
+        try {
+            this.bb = await Barretenberg.new({
+                bbPath: this.config.bbBinaryPath,
+                backend: BackendType.NativeUnixSocket
+            });
+            await this.bb.initSRSChonk();
+            // Keep the FIFO in a private directory so cleanup has a single owner.
+            this.fifoDir = await mkdtemp(path.join(os.tmpdir(), `bb-batch-${this.label}-${process.pid}-`));
+            this.fifoPath = path.join(this.fifoDir, 'results.fifo');
+            await execFileAsync('mkfifo', [
+                this.fifoPath
+            ]);
+            this.registerExitCleanup();
+            this.startFifoReader();
+            await this.bb.chonkBatchVerifierStart({
+                vks: this.vkBuffers,
+                numCores: this.config.bbChonkVerifyConcurrency || 0,
+                batchSize: this.batchSize,
+                fifoPath: this.fifoPath
+            });
+        } catch (err) {
+            this.fifoReader.stop();
+            this.deregisterExitCleanup();
+            await this.cleanupFifo();
+            await this.bb?.destroy().catch(()=>{});
+            throw err;
+        }
+        this.logger.info('BatchChonkVerifier started', {
+            fifoPath: this.fifoPath
+        });
+    }
+    verifyProof(tx) {
+        const totalTimer = new Timer();
+        return (async ()=>{
+            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 await this.enqueueProof(vkIndex, proofFields);
+        })().catch((err)=>{
+            this.logger.warn(`Failed to verify Chonk proof for tx ${tx.getTxHash().toString()}: ${String(err)}`);
+            return {
+                valid: false,
+                durationMs: 0,
+                totalDurationMs: totalTimer.ms()
+            };
+        });
+    }
+    /** Enqueue raw proof fields for verification. Used directly by tests with custom VKs. */ enqueueProof(vkIndex, proofFields) {
+        if (this.stopped) {
+            return Promise.reject(new Error('BatchChonkVerifier stopped'));
+        }
+        if (this.fatalError) {
+            return Promise.reject(this.fatalError);
+        }
+        const totalTimer = new Timer();
+        const requestId = this.nextRequestId++;
+        const resultPromise = new Promise((resolve, reject)=>{
+            const timeout = setTimeout(()=>{
+                const pending = this.pendingRequests.get(requestId);
+                if (!pending) {
+                    return;
+                }
+                this.pendingRequests.delete(requestId);
+                pending.reject(new Error(`BatchChonkVerifier result timed out for request_id=${requestId}`));
+                this.notifyPendingDrained();
+            }, RESULT_TIMEOUT_MS);
+            // A pending result timer must never keep the host process alive on its own (e.g. an
+            // orphaned request at process exit); the FIFO reader keeps the loop alive while results
+            // are genuinely awaited.
+            timeout.unref();
+            this.pendingRequests.set(requestId, {
+                resolve,
+                reject,
+                totalTimer,
+                timeout
+            });
+        });
+        void this.sendQueue.put(async ()=>{
+            if (this.fatalError) {
+                throw this.fatalError;
+            }
+            await this.bb.chonkBatchVerifierQueue({
+                requestId,
+                vkIndex,
+                proofFields
+            });
+        }).catch((err)=>{
+            const pending = this.pendingRequests.get(requestId);
+            if (pending) {
+                this.pendingRequests.delete(requestId);
+                clearTimeout(pending.timeout);
+                pending.reject(err instanceof Error ? err : new Error(String(err)));
+                this.notifyPendingDrained();
+            }
+        });
+        return resultPromise;
+    }
+    async stop() {
+        this.logger.info('Stopping BatchChonkVerifier');
+        this.stopped = true;
+        try {
+            // Stop accepting new proofs and flush the send queue. Bound it so an unresponsive
+            // native process can't block teardown of our own event-loop handles indefinitely.
+            await this.withTimeout(this.sendQueue.end(), STOP_DRAIN_TIMEOUT_MS, 'send queue flush');
+            // Stop the bb service (flushes remaining proofs).
+            await this.withTimeout(this.bb.chonkBatchVerifierStop({}), STOP_DRAIN_TIMEOUT_MS, 'chonkBatchVerifierStop');
+            // Native stop flushes callbacks; keep the FIFO open until those frames are observed.
+            const drained = await this.waitForPendingRequestsToDrain(STOP_DRAIN_TIMEOUT_MS);
+            if (!drained) {
+                this.rejectPendingRequests(new Error('Timed out waiting for BatchChonkVerifier results during stop'));
+            }
+        } catch (err) {
+            this.logger.warn(`Error during BatchChonkVerifier graceful stop: ${err}`);
+            this.rejectPendingRequests(err instanceof Error ? err : new Error(String(err)));
+        } finally{
+            // Always release our own event-loop handles — the FIFO read stream (a blocking
+            // threadpool read that can't be unref'd), the unix socket, the native process, and the
+            // exit handler — so the host process exits cleanly even if the native backend is wedged.
+            this.fifoReader.stop();
+            this.deregisterExitCleanup();
+            await this.cleanupFifo();
+            await this.bb.destroy().catch((err)=>this.logger.warn(`Error destroying bb backend during stop: ${err}`));
+        }
+        this.logger.info('BatchChonkVerifier stopped');
+    }
+    /**
+   * Races a promise against a timeout so a wedged native backend can't block teardown. The
+   * timer is unref'd so it never keeps the process alive; the underlying promise stays handled
+   * by the race even if the timeout wins, so it cannot surface as an unhandled rejection.
+   */ async withTimeout(promise, timeoutMs, label) {
+        let timer;
+        const timeout = new Promise((_, reject)=>{
+            timer = setTimeout(()=>reject(new Error(`BatchChonkVerifier ${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+            timer.unref();
+        });
+        try {
+            return await Promise.race([
+                promise,
+                timeout
+            ]);
+        } finally{
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
+    startFifoReader() {
+        const unpackr = new Unpackr({
+            useRecords: false
+        });
+        this.fifoReader.on('frame', (payload)=>{
+            try {
+                const result = unpackr.unpack(payload);
+                this.handleResult(result);
+            } catch (err) {
+                this.logger.error(`FIFO: failed to decode msgpack result: ${err}`);
+                // A corrupt result stream cannot safely be matched to outstanding requests.
+                this.failVerifier(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+        this.fifoReader.on('error', (err)=>{
+            this.logger.error(`FIFO reader error: ${err}`);
+            this.failVerifier(err);
+        });
+        this.fifoReader.on('end', ()=>{
+            this.logger.debug('FIFO reader: stream ended');
+            if (!this.stopped) {
+                this.failVerifier(new Error('FIFO stream ended unexpectedly'));
+            }
+        });
+        this.fifoReader.start(this.fifoPath);
+    }
+    handleResult(result) {
+        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);
+        clearTimeout(pending.timeout);
+        const valid = result.status === 0; // VerifyStatus::OK
+        const durationMs = result.time_in_verify_ms;
+        const totalDurationMs = pending.totalTimer.ms();
+        const ivcResult = {
+            valid,
+            durationMs,
+            totalDurationMs
+        };
+        this.metrics.recordIVCVerification(ivcResult);
+        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);
+        this.notifyPendingDrained();
+    }
+    registerExitCleanup() {
+        this.exitCleanup = ()=>{
+            this.cleanupFifoSync();
+        };
+        process.on('exit', this.exitCleanup);
+    }
+    deregisterExitCleanup() {
+        if (this.exitCleanup) {
+            process.removeListener('exit', this.exitCleanup);
+            this.exitCleanup = null;
+        }
+    }
+    rejectPendingRequests(error) {
+        for (const [id, pending] of Array.from(this.pendingRequests)){
+            pending.reject(error);
+            clearTimeout(pending.timeout);
+            this.pendingRequests.delete(id);
+        }
+        this.notifyPendingDrained();
+    }
+    failVerifier(error) {
+        if (!this.fatalError) {
+            this.fatalError = error;
+        }
+        this.rejectPendingRequests(error);
+    }
+    waitForPendingRequestsToDrain(timeoutMs) {
+        if (this.pendingRequests.size === 0) {
+            return Promise.resolve(true);
+        }
+        let timeout;
+        let onDrain;
+        const drained = new Promise((resolve)=>{
+            onDrain = ()=>resolve(true);
+            this.pendingDrainedResolvers.add(onDrain);
+        });
+        const timedOut = new Promise((resolve)=>{
+            timeout = setTimeout(()=>resolve(false), timeoutMs);
+            timeout.unref();
+        });
+        return Promise.race([
+            drained,
+            timedOut
+        ]).finally(()=>{
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            if (onDrain) {
+                this.pendingDrainedResolvers.delete(onDrain);
+            }
+        });
+    }
+    notifyPendingDrained() {
+        if (this.pendingRequests.size > 0) {
+            return;
+        }
+        for (const resolve of Array.from(this.pendingDrainedResolvers)){
+            resolve();
+        }
+    }
+    async cleanupFifo() {
+        if (this.fifoDir) {
+            await rm(this.fifoDir, {
+                recursive: true,
+                force: true
+            }).catch(()=>{});
+        } else if (this.fifoPath) {
+            await rm(this.fifoPath, {
+                force: true
+            }).catch(()=>{});
+        }
+        this.fifoDir = undefined;
+        this.fifoPath = '';
+    }
+    cleanupFifoSync() {
+        try {
+            if (this.fifoDir) {
+                rmSync(this.fifoDir, {
+                    recursive: true,
+                    force: true
+                });
+            } else if (this.fifoPath) {
+                rmSync(this.fifoPath, {
+                    force: true
+                });
+            }
+        } catch  {
+        /* ignore */ }
+    }
+}

package/dest/verifier/bb_verifier.d.ts

@@ -0,0 +1,21 @@
+import { type Logger } from '@aztec-labs/foundation/log';
+import { type ProtocolArtifact, type ServerProtocolArtifact } from '@aztec-labs/noir-protocol-circuits-types/types';
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec-labs/stdlib/interfaces/server';
+import type { Proof } from '@aztec-labs/stdlib/proofs';
+import { Tx } from '@aztec-labs/stdlib/tx';
+import type { VerificationKeyData } from '@aztec-labs/stdlib/vks';
+import type { BBConfig } from '../config.js';
+export declare class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
+    private config;
+    private logger;
+    private bbJsFactory;
+    private constructor();
+    stop(): Promise<void>;
+    static new(config: BBConfig, logger?: Logger): Promise<BBCircuitVerifier>;
+    getVerificationKeyData(circuit: ProtocolArtifact): VerificationKeyData;
+    /** Verify an UltraHonk proof via bb.js API (no temp files). */
+    verifyProofForCircuit(circuit: ServerProtocolArtifact, proof: Proof): Promise<void>;
+    /** Verify a Chonk (IVC) proof from a transaction via bb.js API. */
+    verifyProof(tx: Tx): Promise<IVCProofVerificationResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmJfdmVyaWZpZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZmllci9iYl92ZXJpZmllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sNEJBQTRCLENBQUM7QUFHdkUsT0FBTyxFQUVMLEtBQUssZ0JBQWdCLEVBQ3JCLEtBQUssc0JBQXNCLEVBRTVCLE1BQU0sZ0RBQWdELENBQUM7QUFDeEQsT0FBTyxLQUFLLEVBQUUsNkJBQTZCLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUN0SCxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUV2RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDM0MsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUlsRSxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFHN0MscUJBQWEsaUJBQWtCLFlBQVcsNkJBQTZCO0lBSW5FLE9BQU8sQ0FBQyxNQUFNO0lBQ2QsT0FBTyxDQUFDLE1BQU07SUFKaEIsT0FBTyxDQUFDLFdBQVcsQ0FBYztJQUVqQyxPQUFPLGVBV047SUFFTSxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUUzQjtJQUVELE9BQW9CLEdBQUcsQ0FBQyxNQUFNLEVBQUUsUUFBUSxFQUFFLE1BQU0sU0FBcUMsOEJBTXBGO0lBRU0sc0JBQXNCLENBQUMsT0FBTyxFQUFFLGdCQUFnQixHQUFHLG1CQUFtQixDQU01RTtJQUVELCtEQUErRDtJQUNsRCxxQkFBcUIsQ0FBQyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsS0FBSyxFQUFFLEtBQUssaUJBNEIvRTtJQUVELG1FQUFtRTtJQUN0RCxXQUFXLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsMEJBQTBCLENBQUMsQ0ErQnBFO0NBQ0YifQ==

package/dest/verifier/bb_verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bb_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/bb_verifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AAGvE,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAE5B,MAAM,gDAAgD,CAAC;AACxD,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AACtH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAEvD,OAAO,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAC3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAIlE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG7C,qBAAa,iBAAkB,YAAW,6BAA6B;IAInE,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IAJhB,OAAO,CAAC,WAAW,CAAc;IAEjC,OAAO,eAWN;IAEM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAE3B;IAED,OAAoB,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAqC,8BAMpF;IAEM,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,mBAAmB,CAM5E;IAED,+DAA+D;IAClD,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK,iBA4B/E;IAED,mEAAmE;IACtD,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CA+BpE;CACF"}

package/dest/verifier/bb_verifier.js

@@ -0,0 +1,193 @@
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+import { createLogger } from '@aztec-labs/foundation/log';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { ProtocolCircuitVks } from '@aztec-labs/noir-protocol-circuits-types/server/vks';
+import { mapProtocolArtifactNameToCircuitName } from '@aztec-labs/noir-protocol-circuits-types/types';
+import { promises as fs } from 'fs';
+import { BBJsFactory } from '../bb/bb_js_backend.js';
+import { getUltraHonkFlavorForCircuit } from '../honk.js';
+export class BBCircuitVerifier {
+    config;
+    logger;
+    bbJsFactory;
+    constructor(config, logger){
+        this.config = config;
+        this.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
+        });
+    }
+    stop() {
+        return this.bbJsFactory.destroy();
+    }
+    static async new(config, logger = createLogger('bb-prover:verifier')) {
+        if (!config.bbWorkingDirectory) {
+            throw new Error(`Barretenberg working directory (BB_WORKING_DIRECTORY) is not set`);
+        }
+        await fs.mkdir(config.bbWorkingDirectory, {
+            recursive: true
+        });
+        return new BBCircuitVerifier(config, logger);
+    }
+    getVerificationKeyData(circuit) {
+        const vk = ProtocolCircuitVks[circuit];
+        if (vk === undefined) {
+            throw new Error(`Could not find VK for artifact ${circuit}`);
+        }
+        return vk;
+    }
+    /** Verify an UltraHonk proof via bb.js API (no temp files). */ async verifyProofForCircuit(circuit, proof) {
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
+        try {
+            const verificationKey = this.getVerificationKeyData(circuit);
+            const flavor = getUltraHonkFlavorForCircuit(circuit);
+            this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
+            // 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 instance = _ts_add_disposable_resource(env, await this.bbJsFactory.getInstance(), true);
+            const { verified, durationMs } = await instance.verifyProof(proofFields, verificationKey.keyAsBytes, publicInputFields, flavor);
+            if (!verified) {
+                throw new Error(`Failed to verify ${circuit} proof!`);
+            }
+            this.logger.debug(`${circuit} verification successful`, {
+                circuitName: mapProtocolArtifactNameToCircuitName(circuit),
+                duration: durationMs,
+                eventName: 'circuit-verification',
+                proofType: 'ultra-honk'
+            });
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
+        }
+    }
+    /** Verify a Chonk (IVC) proof from a transaction via bb.js API. */ async verifyProof(tx) {
+        const proofType = 'Chonk';
+        try {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                const totalTimer = new Timer();
+                const circuit = 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()));
+                const instance = _ts_add_disposable_resource(env, await this.bbJsFactory.getInstance(), true);
+                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'
+                });
+                return {
+                    valid: true,
+                    durationMs,
+                    totalDurationMs: totalTimer.ms()
+                };
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        } 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) {
+    const fields = [];
+    for(let i = 0; i < buffer.length; i += 32){
+        fields.push(new Uint8Array(buffer.subarray(i, i + 32)));
+    }
+    return fields;
+}

package/dest/verifier/index.d.ts

@@ -0,0 +1,4 @@
+export * from './batch_chonk_verifier.js';
+export * from './bb_verifier.js';
+export * from './queued_chonk_verifier.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZmllci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyw0QkFBNEIsQ0FBQyJ9