@aztec-labs/bb-prover 6.0.0-rc.1 → 6.0.0-rc.3

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

@@ -1 +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"}
+{"version":3,"file":"bb_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/bb_verifier.ts"],"names":[],"mappings":"AACA,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;AAGlE,OAAO,EAAgB,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG7C,0GAA0G;AAC1G,qBAAa,6BAA8B,SAAQ,KAAK;IACtD,YAAY,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,EAGlD;CACF;AAED,qBAAa,iBAAkB,YAAW,6BAA6B;IAOnE,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IAPhB,sHAAsH;IACtH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAK;IAEtD,OAAO,CAAC,WAAW,CAAc;IAEjC,SAAS,aACC,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,WAAW,EAgB1B;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;;;OAGG;IACU,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAsCpE;YASa,8BAA8B;CAsC7C"}

package/dest/verifier/bb_verifier.js

@@ -63,6 +63,7 @@ function _ts_dispose_resources(env) {
         return next();
     })(env);
 }
+import { isRetryableError } from '@aztec-labs/foundation/error';
 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';
@@ -70,17 +71,29 @@ import { mapProtocolArtifactNameToCircuitName } from '@aztec-labs/noir-protocol-
 import { promises as fs } from 'fs';
 import { BBJsFactory } from '../bb/bb_js_backend.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
+/** Thrown when no live bb process could check a proof, so the proof was neither accepted nor rejected. */ export class ProofVerifierUnavailableError extends Error {
+    constructor(message, options){
+        super(message, options);
+        this.name = 'ProofVerifierUnavailableError';
+    }
+}
 export class BBCircuitVerifier {
     config;
     logger;
+    /** bb instances a Chonk verification tries, while each one's bb dies under it, before the verifier is unavailable. */ static MAX_CHONK_VERIFY_ATTEMPTS = 2;
     bbJsFactory;
-    constructor(config, logger){
+    constructor(config, logger, bbJsFactory){
         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,
+        const poolSize = config.numConcurrentIVCVerifiers > 0 ? config.numConcurrentIVCVerifiers : undefined;
+        this.bbJsFactory = bbJsFactory ?? new BBJsFactory(config.bbBinaryPath, {
+            poolSize,
+            // A pooled instance outlives the call that borrowed it, so it replaces a bb process that dies
+            // under it and the next borrower gets a working one. Each verification stands alone, so a
+            // replacement has nothing to carry over. A fresh-per-call instance has nothing to heal.
+            respawn: poolSize !== undefined,
             logger,
             debugDir: config.bbDebugOutputDir
         });
@@ -136,37 +149,100 @@ export class BBCircuitVerifier {
             if (result) await result;
         }
     }
-    /** Verify a Chonk (IVC) proof from a transaction via bb.js API. */ async verifyProof(tx) {
+    /**
+   * Verify a Chonk (IVC) proof from a transaction via bb.js API. Throws {@link ProofVerifierUnavailableError} when no
+   * live bb process could check the proof; any other failure returns `valid: false`.
+   */ async verifyProof(tx) {
         const proofType = 'Chonk';
+        const txHash = tx.getTxHash().toString();
         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 { verified, durationMs } = await this.verifyChonkProofOnLiveInstance(fieldsAsBuffers, verificationKey.keyAsBytes, txHash);
+            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 (err) {
+            if (err instanceof ProofVerifierUnavailableError) {
+                throw err;
+            }
+            this.logger.warn(`Failed to verify ${proofType} proof`, {
+                txHash,
+                err
+            });
+            return {
+                valid: false,
+                durationMs: 0,
+                totalDurationMs: 0
+            };
+        }
+    }
+    /**
+   * Runs a Chonk verification on a pooled bb instance. A call that failed for environmental reasons — its bb process
+   * died, or could not be started — is retried; any other failure is the verification's own verdict and is rethrown.
+   *
+   * The error says so itself, through the `retry` property bb.js sets. Asking the instance whether it is still alive
+   * would be a guess: the process can die between the answer and the next call.
+   */ async verifyChonkProofOnLiveInstance(fieldsWithPublicInputs, verificationKey, txHash) {
+        for(let attempt = 1;; attempt++){
             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}!`);
+                let borrowed;
+                try {
+                    borrowed = await this.bbJsFactory.getInstance();
+                } catch (err) {
+                    // A bb that could not be started is worth another go, within the same budget a death gets.
+                    // Anything else — the factory destroyed under us — will not improve by asking again. Either
+                    // way no proof was checked, so this is never the proof's fault.
+                    if (isRetryableError(err) && attempt < BBCircuitVerifier.MAX_CHONK_VERIFY_ATTEMPTS) {
+                        this.logger.warn('no bb instance available to verify a proof; retrying', {
+                            txHash,
+                            attempt
+                        });
+                        continue;
+                    }
+                    throw new ProofVerifierUnavailableError('No bb instance available to verify the proof', {
+                        cause: err
+                    });
+                }
+                const instance = _ts_add_disposable_resource(env, borrowed, true);
+                try {
+                    return await instance.verifyChonkProof(fieldsWithPublicInputs, verificationKey);
+                } catch (err) {
+                    // Only an environmental failure is worth retrying; anything else is the verification's own
+                    // verdict and belongs to the caller.
+                    if (!isRetryableError(err)) {
+                        throw err;
+                    }
+                    if (attempt >= BBCircuitVerifier.MAX_CHONK_VERIFY_ATTEMPTS) {
+                        throw new ProofVerifierUnavailableError(`bb died while verifying the proof, on ${attempt} attempts`, {
+                            cause: err
+                        });
+                    }
+                    this.logger.warn('bb died while verifying a proof; retrying', {
+                        txHash,
+                        attempt
+                    });
                 }
-                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;
@@ -174,13 +250,6 @@ export class BBCircuitVerifier {
                 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
-            };
         }
     }
 }

package/dest/verifier/queued_chonk_verifier.d.ts

@@ -23,4 +23,4 @@ export declare class QueuedIVCVerifier implements ClientProtocolCircuitVerifier
     verifyProof(tx: Tx): Promise<IVCProofVerificationResult>;
     stop(): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVldWVkX2Nob25rX3ZlcmlmaWVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmVyaWZpZXIvcXVldWVkX2Nob25rX3ZlcmlmaWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLDZCQUE2QixFQUFFLDBCQUEwQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDdEgsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDaEQsT0FBTyxFQU1MLEtBQUssZUFBZSxFQUlyQixNQUFNLDhCQUE4QixDQUFDO0FBR3RDLHlGQUF5RjtBQUN6RixxQkFBYSxrQkFBa0I7SUFDN0IsT0FBTyxDQUFDLHdCQUF3QixDQUFZO0lBQzVDLE9BQU8sQ0FBQyw2QkFBNkIsQ0FBWTtJQUNqRCxPQUFPLENBQUMsZUFBZSxDQUFnQjtJQUN2QyxPQUFPLENBQUMsZ0JBQWdCLENBR3JCO0lBQ0gsT0FBTyxDQUFDLG1CQUFtQixDQUd4QjtJQUVILE9BQU8sQ0FBQyxrQkFBa0IsQ0FBaUU7SUFFM0YsWUFBWSxNQUFNLEVBQUUsZUFBZSxFQUFFLElBQUksU0FBc0IsRUFrQjlEO0lBRUQscUJBQXFCLENBQUMsTUFBTSxFQUFFLDBCQUEwQixRQVN2RDtJQUVELE9BQU8sQ0FBQyxTQUFTLENBY2Y7Q0FDSDtBQUVELHFCQUFhLGlCQUFrQixZQUFXLDZCQUE2QjtJQUtuRSxPQUFPLENBQUMsUUFBUTtJQUVoQixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsTUFBTTtJQVBoQixPQUFPLENBQUMsS0FBSyxDQUFjO0lBQzNCLE9BQU8sQ0FBQyxPQUFPLENBQXFCO0lBRXBDLFlBQ1UsUUFBUSxFQUFFLDZCQUE2QixFQUMvQyxXQUFXLEVBQUUsTUFBTSxFQUNYLFNBQVMsR0FBRSxlQUFzQyxFQUNqRCxNQUFNLDhDQUFrRCxFQU1qRTtJQUVZLFdBQVcsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQywwQkFBMEIsQ0FBQyxDQUlwRTtJQUVLLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBRzFCO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVldWVkX2Nob25rX3ZlcmlmaWVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmVyaWZpZXIvcXVldWVkX2Nob25rX3ZlcmlmaWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLDZCQUE2QixFQUFFLDBCQUEwQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDdEgsT0FBTyxLQUFLLEVBQUUsRUFBRSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDaEQsT0FBTyxFQU1MLEtBQUssZUFBZSxFQUlyQixNQUFNLDhCQUE4QixDQUFDO0FBR3RDLHlGQUF5RjtBQUN6RixxQkFBYSxrQkFBa0I7SUFDN0IsT0FBTyxDQUFDLHdCQUF3QixDQUFZO0lBQzVDLE9BQU8sQ0FBQyw2QkFBNkIsQ0FBWTtJQUNqRCxPQUFPLENBQUMsZUFBZSxDQUFnQjtJQUN2QyxPQUFPLENBQUMsZ0JBQWdCLENBR3JCO0lBQ0gsT0FBTyxDQUFDLG1CQUFtQixDQUd4QjtJQUVILE9BQU8sQ0FBQyxrQkFBa0IsQ0FBaUU7SUFFM0YsWUFBWSxNQUFNLEVBQUUsZUFBZSxFQUFFLElBQUksU0FBc0IsRUFrQjlEO0lBRUQscUJBQXFCLENBQUMsTUFBTSxFQUFFLDBCQUEwQixRQVN2RDtJQUVELE9BQU8sQ0FBQyxTQUFTLENBY2Y7Q0FDSDtBQUVELHFCQUFhLGlCQUFrQixZQUFXLDZCQUE2QjtJQUtuRSxPQUFPLENBQUMsUUFBUTtJQUVoQixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsTUFBTTtJQVBoQixPQUFPLENBQUMsS0FBSyxDQUFjO0lBQzNCLE9BQU8sQ0FBQyxPQUFPLENBQXFCO0lBRXBDLFlBQ1UsUUFBUSxFQUFFLDZCQUE2QixFQUMvQyxXQUFXLEVBQUUsTUFBTSxFQUNYLFNBQVMsR0FBRSxlQUFzQyxFQUNqRCxNQUFNLDhDQUFrRCxFQU1qRTtJQUVZLFdBQVcsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQywwQkFBMEIsQ0FBQyxDQUlwRTtJQUVLLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBUTFCO0NBQ0YifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"queued_chonk_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/queued_chonk_verifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AACtH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAML,KAAK,eAAe,EAIrB,MAAM,8BAA8B,CAAC;AAGtC,yFAAyF;AACzF,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,wBAAwB,CAAY;IAC5C,OAAO,CAAC,6BAA6B,CAAY;IACjD,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAGrB;IACH,OAAO,CAAC,mBAAmB,CAGxB;IAEH,OAAO,CAAC,kBAAkB,CAAiE;IAE3F,YAAY,MAAM,EAAE,eAAe,EAAE,IAAI,SAAsB,EAkB9D;IAED,qBAAqB,CAAC,MAAM,EAAE,0BAA0B,QASvD;IAED,OAAO,CAAC,SAAS,CAcf;CACH;AAED,qBAAa,iBAAkB,YAAW,6BAA6B;IAKnE,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM;IAPhB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAqB;IAEpC,YACU,QAAQ,EAAE,6BAA6B,EAC/C,WAAW,EAAE,MAAM,EACX,SAAS,GAAE,eAAsC,EACjD,MAAM,8CAAkD,EAMjE;IAEY,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAIpE;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAG1B;CACF"}
+{"version":3,"file":"queued_chonk_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/queued_chonk_verifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AACtH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAML,KAAK,eAAe,EAIrB,MAAM,8BAA8B,CAAC;AAGtC,yFAAyF;AACzF,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,wBAAwB,CAAY;IAC5C,OAAO,CAAC,6BAA6B,CAAY;IACjD,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAGrB;IACH,OAAO,CAAC,mBAAmB,CAGxB;IAEH,OAAO,CAAC,kBAAkB,CAAiE;IAE3F,YAAY,MAAM,EAAE,eAAe,EAAE,IAAI,SAAsB,EAkB9D;IAED,qBAAqB,CAAC,MAAM,EAAE,0BAA0B,QASvD;IAED,OAAO,CAAC,SAAS,CAcf;CACH;AAED,qBAAa,iBAAkB,YAAW,6BAA6B;IAKnE,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM;IAPhB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAqB;IAEpC,YACU,QAAQ,EAAE,6BAA6B,EAC/C,WAAW,EAAE,MAAM,EACX,SAAS,GAAE,eAAsC,EACjD,MAAM,8CAAkD,EAMjE;IAEY,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAIpE;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAQ1B;CACF"}

package/dest/verifier/queued_chonk_verifier.js

@@ -96,7 +96,12 @@ export class QueuedIVCVerifier {
         return result;
     }
     async stop() {
-        await this.queue.end();
-        await this.verifier.stop();
+        // Stopped first so that verifications waiting for a bb instance fail rather than keep the queue from draining. Queued
+        // verifications that have not started yet fail too.
+        try {
+            await this.verifier.stop();
+        } finally{
+            await this.queue.end();
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec-labs/bb-prover",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0-rc.3",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -70,15 +70,15 @@
     ]
   },
   "dependencies": {
-    "@aztec-foundation/bb.js": "6.0.0-rc.1",
-    "@aztec-foundation/noir-noirc_abi": "6.0.0-rc.1",
-    "@aztec-foundation/noir-types": "6.0.0-rc.1",
-    "@aztec-labs/constants": "6.0.0-rc.1",
-    "@aztec-labs/foundation": "6.0.0-rc.1",
-    "@aztec-labs/noir-protocol-circuits-types": "6.0.0-rc.1",
-    "@aztec-labs/simulator": "6.0.0-rc.1",
-    "@aztec-labs/stdlib": "6.0.0-rc.1",
-    "@aztec-labs/telemetry-client": "6.0.0-rc.1",
+    "@aztec-foundation/bb.js": "6.0.0-rc.6",
+    "@aztec-foundation/noir-noirc_abi": "6.0.0-rc.6",
+    "@aztec-foundation/noir-types": "6.0.0-rc.6",
+    "@aztec-labs/constants": "6.0.0-rc.3",
+    "@aztec-labs/foundation": "6.0.0-rc.3",
+    "@aztec-labs/noir-protocol-circuits-types": "6.0.0-rc.3",
+    "@aztec-labs/simulator": "6.0.0-rc.3",
+    "@aztec-labs/stdlib": "6.0.0-rc.3",
+    "@aztec-labs/telemetry-client": "6.0.0-rc.3",
     "commander": "^12.1.0",
     "msgpackr": "^1.11.2",
     "pako": "^2.1.0",
@@ -86,10 +86,10 @@
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec-labs/noir-contracts.js": "6.0.0-rc.1",
-    "@aztec-labs/noir-test-contracts.js": "6.0.0-rc.1",
-    "@aztec-labs/protocol-contracts": "6.0.0-rc.1",
-    "@aztec-labs/world-state": "6.0.0-rc.1",
+    "@aztec-labs/noir-contracts.js": "6.0.0-rc.3",
+    "@aztec-labs/noir-test-contracts.js": "6.0.0-rc.3",
+    "@aztec-labs/protocol-contracts": "6.0.0-rc.3",
+    "@aztec-labs/world-state": "6.0.0-rc.3",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/bb/bb_js_backend.ts

@@ -76,12 +76,19 @@ export interface BBJsApi {
 export class BBJsInstance implements BBJsApi {
   private constructor(private api: Barretenberg) {}
 
-  /** Creates a new Barretenberg instance connected to a fresh bb process. */
-  static async create(bbPath: string, logger?: LogFn, threads?: number): Promise<BBJsInstance> {
+  /**
+   * Creates a new Barretenberg instance connected to a fresh bb process.
+   *
+   * `respawn` lets the instance replace its bb process when it dies, so a long-lived instance stays
+   * usable instead of failing every later call. Only safe where the instance holds no state between
+   * calls, since a replacement has no Chonk accumulation and no batch-verifier session.
+   */
+  static async create(bbPath: string, logger?: LogFn, threads?: number, respawn?: boolean): Promise<BBJsInstance> {
     const options: BackendOptions = {
       bbPath,
       backend: BackendType.NativeUnixSocket,
       logger,
+      respawn,
     };
     if (threads !== undefined) {
       options.threads = threads;
@@ -251,17 +258,31 @@ export interface BBJsFactoryOptions {
    * If omitted, every `getInstance()` call spawns a fresh bb that is destroyed on dispose.
    */
   poolSize?: number;
+  /**
+   * Let each instance replace its bb process when it dies. Only for callers whose calls stand alone:
+   * a replacement process remembers nothing, so state held across calls (a Chonk accumulation, a
+   * batch-verifier session) would be silently lost.
+   */
+  respawn?: boolean;
   logger?: Logger;
   threads?: number;
   debugDir?: string;
 }
 
+/** A place in a {@link BBJsFactory} pool: empty until a borrower first starts a bb in it. */
+type PoolSlot = { instance?: BBJsApi };
+
 /**
  * Manages bb.js instance lifecycle. By default every `getInstance()` call spawns a fresh
  * bb process that is destroyed when the borrow is disposed. Pass `poolSize` to keep a fixed
  * set of long-lived bb processes that are reused across calls — useful when the per-call
  * bb startup cost dominates the workload (e.g. high-rate IVC verification).
  *
+ * The pool is a queue of `poolSize` slots, each starting its bb on the first borrow that needs it.
+ * A borrower waits in exactly two places: for a slot, which destroy() releases by cancelling the
+ * queue, and for its slot's bb to start, which bb.js bounds with its own startup deadline. A bb that
+ * fails to start costs only that slot, which goes back empty for the next borrower to try again.
+ *
  * Idiomatic usage:
  * ```
  * await using inst = await factory.getInstance();
@@ -270,82 +291,86 @@ export interface BBJsFactoryOptions {
  * ```
  */
 export class BBJsFactory {
-  private readonly poolSize?: number;
   private readonly logger?: Logger;
   private readonly threads?: number;
   private readonly debugDir?: string;
+  private readonly respawn: boolean;
 
-  /** Available pooled instances when poolSize is set; otherwise undefined. */
-  private pool?: FifoMemoryQueue<BBJsApi>;
-  /** Lazily-resolved on first `getInstance()` call to prevent racing pool initialization. */
-  private initPromise?: Promise<void>;
+  /** Slots not currently borrowed, when poolSize is set; otherwise undefined. */
+  private readonly slots?: FifoMemoryQueue<PoolSlot>;
   private destroyed = false;
 
   constructor(
     private bbPath: string,
     options: BBJsFactoryOptions = {},
   ) {
-    this.poolSize = options.poolSize;
+    this.respawn = options.respawn ?? false;
     this.logger = options.logger;
     this.threads = options.threads;
     this.debugDir = options.debugDir;
-    if (this.poolSize !== undefined && this.poolSize < 1) {
-      throw new Error(`BBJsFactory poolSize must be >= 1, got ${this.poolSize}`);
+    if (options.poolSize !== undefined) {
+      if (options.poolSize < 1) {
+        throw new Error(`BBJsFactory poolSize must be >= 1, got ${options.poolSize}`);
+      }
+      this.slots = new FifoMemoryQueue<PoolSlot>();
+      for (let i = 0; i < options.poolSize; i++) {
+        this.slots.put({});
+      }
     }
   }
 
   /**
    * Acquire a bb instance. The returned object implements `BBJsApi` and `AsyncDisposable`.
-   * With no pool: spawns a fresh bb that is destroyed on dispose. With a pool: borrows from
-   * the pool and returns to it on dispose.
+   * With no pool: spawns a fresh bb that is destroyed on dispose. With a pool: borrows a slot,
+   * starting its bb if it has none, and returns the slot to the pool on dispose.
    */
   async getInstance(): Promise<BBJsApi & AsyncDisposable> {
     if (this.destroyed) {
       throw new Error('BBJsFactory has been destroyed');
     }
-    if (this.poolSize === undefined) {
+    if (!this.slots) {
       // No pool: fresh-per-call, dispose destroys.
       const instance = await this.createInstance();
       return this.makeOwned(instance);
     }
-    if (!this.initPromise) {
-      this.initPromise = this.initPool();
+    const slot = await this.slots.get();
+    if (!slot) {
+      throw new Error('BBJsFactory was destroyed while waiting for an instance');
     }
-    await this.initPromise;
-    const pool = this.pool;
-    if (!pool) {
-      throw new Error('BBJsFactory has been destroyed');
+    let instance: BBJsApi;
+    try {
+      instance = slot.instance ??= await this.createInstance();
+    } catch (err) {
+      await this.release(slot);
+      throw err;
     }
-    const instance = await pool.get();
-    if (!instance) {
-      throw new Error('BBJsFactory was destroyed while waiting for an instance');
+    if (this.destroyed) {
+      await this.release(slot);
+      throw new Error('BBJsFactory has been destroyed');
     }
-    return this.makeBorrowed(instance);
+    return this.makeDisposable(instance, () => this.release(slot));
   }
 
   /**
    * Tear down all pooled instances. Idempotent. No-op when no pool is configured (fresh-per-call
-   * instances are destroyed by their own dispose callbacks). Instances currently held by an
-   * in-flight pooled borrow are destroyed by their dispose callback when released.
+   * instances are destroyed by their own dispose callbacks). Instances in borrowed slots are
+   * destroyed when their borrow is released.
    */
   async destroy(): Promise<void> {
     if (this.destroyed) {
       return;
     }
     this.destroyed = true;
-    const pool = this.pool;
-    this.pool = undefined;
-    if (!pool) {
+    if (!this.slots) {
       return;
     }
     const idle: BBJsApi[] = [];
-    while (pool.length() > 0) {
-      const item = pool.getImmediate();
-      if (item) {
-        idle.push(item);
+    for (let slot = this.slots.getImmediate(); slot; slot = this.slots.getImmediate()) {
+      if (slot.instance) {
+        idle.push(slot.instance);
       }
     }
-    pool.cancel();
+    this.slots.cancel();
     // Aggregate teardown failures so a single bb child that fails to shut down doesn't mask others.
     const results = await Promise.allSettled(idle.map(item => item.destroy()));
     const errors = results.filter((r): r is PromiseRejectedResult => r.status === 'rejected').map(r => r.reason);
@@ -354,37 +379,18 @@ export class BBJsFactory {
     }
   }
 
-  private async initPool(): Promise<void> {
-    // Use allSettled so that if any createInstance() rejects we can destroy the rest instead of
-    // leaking bb child processes whose creation succeeded.
-    const results = await Promise.allSettled(Array.from({ length: this.poolSize! }, () => this.createInstance()));
-    const items: BBJsApi[] = [];
-    const errors: unknown[] = [];
-    for (const result of results) {
-      if (result.status === 'fulfilled') {
-        items.push(result.value);
-      } else {
-        errors.push(result.reason);
-      }
-    }
-    if (errors.length > 0 || this.destroyed) {
-      // Either creation failed or destroy() raced ahead — clean up everything we successfully spawned.
-      await Promise.all(items.map(item => item.destroy()));
-      if (errors.length > 0) {
-        throw errors[0];
-      }
-      return;
-    }
-    const pool = new FifoMemoryQueue<BBJsApi>();
-    for (const item of items) {
-      pool.put(item);
+  /** Return a borrowed slot to the pool, or destroy its bb if the factory was destroyed meanwhile. */
+  private async release(slot: PoolSlot): Promise<void> {
+    if (!this.destroyed) {
+      this.slots!.put(slot);
+    } else {
+      await slot.instance?.destroy();
     }
-    this.pool = pool;
   }
 
-  private async createInstance(): Promise<BBJsApi> {
+  protected async createInstance(): Promise<BBJsApi> {
     const logFn = this.logger ? (msg: string) => this.logger!.verbose(`bb.js - ${msg}`) : undefined;
-    const raw = await BBJsInstance.create(this.bbPath, logFn, this.threads);
+    const raw = await BBJsInstance.create(this.bbPath, logFn, this.threads, this.respawn);
     return this.maybeWrapDebug(raw);
   }
 
@@ -406,21 +412,6 @@ export class BBJsFactory {
     return this.makeDisposable(instance, () => instance.destroy());
   }
 
-  /**
-   * Wrap a pooled instance with an `AsyncDisposable` that returns it to the pool (or destroys it
-   * if the factory was destroyed in the meantime). Destroy errors are propagated.
-   */
-  private makeBorrowed(instance: BBJsApi): BBJsApi & AsyncDisposable {
-    return this.makeDisposable(instance, async () => {
-      const pool = this.pool;
-      if (pool && !this.destroyed) {
-        pool.put(instance);
-      } else {
-        await instance.destroy();
-      }
-    });
-  }
-
   private makeDisposable(instance: BBJsApi, onDispose: () => void | Promise<void>): BBJsApi & AsyncDisposable {
     let disposed = false;
     const dispose = async (): Promise<void> => {

package/src/prover/server/bb_prover.ts

@@ -9,6 +9,7 @@ import {
   ULTRA_KECCAK_PROOF_LENGTH,
 } from '@aztec-labs/constants';
 import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { isRetryableError } from '@aztec-labs/foundation/error';
 import { runInDirectory } from '@aztec-labs/foundation/fs';
 import { createLogger } from '@aztec-labs/foundation/log';
 import {
@@ -449,7 +450,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       );
     } catch (error) {
       // Preserve retryability of the underlying failure (e.g. a transient bb startup error).
-      const retry = error instanceof ProvingError && error.retry;
+      const retry = isRetryableError(error);
       throw new ProvingError(`Failed to generate proof for ${circuitType}: ${error}`, error, retry);
     }
 
@@ -590,7 +591,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       ));
     } catch (error) {
       // Preserve retryability of the underlying failure (e.g. a transient bb startup error).
-      const retry = error instanceof ProvingError && error.retry;
+      const retry = isRetryableError(error);
       throw new ProvingError(`Failed to verify proof for ${circuitType}: ${error}`, error, retry);
     }
 

package/src/test/fake_bb_js.ts

@@ -0,0 +1,125 @@
+import type { AvmStat } from '@aztec-foundation/bb.js';
+
+import { type BBJsApi, BBJsFactory, type BBJsProofResult } from '../bb/bb_js_backend.js';
+
+/** How a {@link FakeBBJsInstance} answers one `verifyChonkProof` call. */
+export type FakeChonkVerifyOutcome = 'valid' | 'invalid' | 'bb-error' | 'die';
+
+function notImplemented(): Promise<never> {
+  return Promise.reject(new Error('Not implemented by FakeBBJsInstance'));
+}
+
+/** An error shaped like the one bb.js raises when the bb process died: retrying may help. */
+function retryable(message: string): Error {
+  return Object.assign(new Error(message), { retry: true });
+}
+
+/**
+ * A {@link BBJsApi} double whose bb process can die.
+ *
+ * A pooled instance is created with respawn, so a death fails only the call that was in flight and
+ * the next call is served by a replacement process. The double behaves the same way: `die` rejects
+ * once, retryably, and leaves the instance usable. Only `verifyChonkProof` is implemented.
+ */
+export class FakeBBJsInstance implements BBJsApi {
+  public destroyCount = 0;
+  public chonkVerifyCalls = 0;
+  private destroyed = false;
+
+  /** @param outcomes - Answers to successive `verifyChonkProof` calls; `valid` once they run out. */
+  constructor(private readonly outcomes: FakeChonkVerifyOutcome[] = []) {}
+
+  public verifyChonkProof(): Promise<{ verified: boolean; durationMs: number }> {
+    this.chonkVerifyCalls++;
+    if (this.destroyed) {
+      return Promise.reject(new Error('Backend connection closed'));
+    }
+    switch (this.outcomes.shift() ?? 'valid') {
+      case 'valid':
+        return Promise.resolve({ verified: true, durationMs: 1 });
+      case 'invalid':
+        return Promise.resolve({ verified: false, durationMs: 1 });
+      case 'bb-error':
+        return Promise.reject(new Error('bb rejected the proof input'));
+      case 'die':
+        return Promise.reject(retryable('Socket connection ended unexpectedly'));
+    }
+  }
+
+  public destroy(): Promise<void> {
+    this.destroyed = true;
+    this.destroyCount++;
+    return Promise.resolve();
+  }
+
+  public generateProof(): Promise<BBJsProofResult> {
+    return notImplemented();
+  }
+
+  public verifyProof(): Promise<{ verified: boolean; durationMs: number }> {
+    return notImplemented();
+  }
+
+  public computeGateCount(): Promise<{ circuitSize: number; durationMs: number }> {
+    return notImplemented();
+  }
+
+  public generateContract(): Promise<{ solidityCode: string; durationMs: number }> {
+    return notImplemented();
+  }
+
+  public generateAvmProof(): Promise<{ proof: Uint8Array[]; stats: AvmStat[]; durationMs: number }> {
+    return notImplemented();
+  }
+
+  public verifyAvmProof(): Promise<{ verified: boolean; durationMs: number }> {
+    return notImplemented();
+  }
+
+  public checkAvmCircuit(): Promise<{ passed: boolean; stats: AvmStat[]; durationMs: number }> {
+    return notImplemented();
+  }
+}
+
+/** A scripted {@link FakeBBJsFactory} spawn. */
+type PlannedSpawn = {
+  /** An error fails the spawn; outcomes script the created instance's verifications. */
+  next: FakeChonkVerifyOutcome[] | Error;
+  /** When set, the spawn completes only once it resolves. */
+  spawned?: Promise<void>;
+};
+
+/** A {@link BBJsFactory} that creates {@link FakeBBJsInstance}s instead of spawning bb. */
+export class FakeBBJsFactory extends BBJsFactory {
+  /** Every instance created, in creation order. */
+  public readonly created: FakeBBJsInstance[] = [];
+  private readonly plan: PlannedSpawn[] = [];
+
+  /** @param poolSize - Pooled instances to keep; when omitted, every borrow creates a fresh instance. */
+  constructor(poolSize?: number) {
+    super('/unused/bb', { poolSize });
+  }
+
+  /**
+   * Scripts the next creation: an error makes that spawn fail, outcomes script the created instance's verifications.
+   * With `spawned`, the spawn completes only once it resolves.
+   */
+  public planNextInstance(next: FakeChonkVerifyOutcome[] | Error, spawned?: Promise<void>): void {
+    this.plan.push({ next, spawned });
+  }
+
+  protected override async createInstance(): Promise<BBJsApi> {
+    const { next, spawned }: PlannedSpawn = this.plan.shift() ?? { next: [] };
+    if (spawned) {
+      await spawned;
+    }
+    if (next instanceof Error) {
+      // BBJsInstance.create wraps a failed spawn as retryable; the double must too, or a test
+      // sees a permanent failure where production sees a transient one.
+      throw Object.assign(next, { retry: true });
+    }
+    const instance = new FakeBBJsInstance(next);
+    this.created.push(instance);
+    return instance;
+  }
+}