@aztec/bb-prover 0.0.1-commit.e558bd1c → 0.0.1-commit.e57c76e

package/dest/prover/server/bb_prover.js

@@ -1,3 +1,68 @@
+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);
+}
 function applyDecs2203RFactory() {
     function createAddInitializerMethod(initializers, decoratorFinishedRef) {
         return function addInitializer(initializer) {
@@ -375,7 +440,6 @@ import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NE
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
-import { BufferReader } from '@aztec/foundation/serialize';
 import { convertBlockMergeRollupOutputsFromWitnessMap, convertBlockMergeRollupPrivateInputsToWitnessMap, convertBlockRootEmptyTxFirstRollupOutputsFromWitnessMap, convertBlockRootEmptyTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootFirstRollupOutputsFromWitnessMap, convertBlockRootFirstRollupPrivateInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap, convertBlockRootRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxFirstRollupOutputsFromWitnessMap, convertBlockRootSingleTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxRollupOutputsFromWitnessMap, convertBlockRootSingleTxRollupPrivateInputsToWitnessMap, convertCheckpointMergeRollupOutputsFromWitnessMap, convertCheckpointMergeRollupPrivateInputsToWitnessMap, convertCheckpointPaddingRollupOutputsFromWitnessMap, convertCheckpointPaddingRollupPrivateInputsToWitnessMap, convertCheckpointRootRollupOutputsFromWitnessMap, convertCheckpointRootRollupPrivateInputsToWitnessMap, convertCheckpointRootSingleBlockRollupOutputsFromWitnessMap, convertCheckpointRootSingleBlockRollupPrivateInputsToWitnessMap, convertParityBaseOutputsFromWitnessMap, convertParityBasePrivateInputsToWitnessMap, convertParityRootOutputsFromWitnessMap, convertParityRootPrivateInputsToWitnessMap, convertPrivateTxBaseRollupOutputsFromWitnessMap, convertPrivateTxBaseRollupPrivateInputsToWitnessMap, convertPublicChonkVerifierOutputsFromWitnessMap, convertPublicChonkVerifierPrivateInputsToWitnessMap, convertPublicTxBaseRollupOutputsFromWitnessMap, convertPublicTxBaseRollupPrivateInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertRootRollupPrivateInputsToWitnessMap, convertTxMergeRollupOutputsFromWitnessMap, convertTxMergeRollupPrivateInputsToWitnessMap, getServerCircuitArtifact } from '@aztec/noir-protocol-circuits-types/server';
 import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
 import { mapProtocolArtifactNameToCircuitName } from '@aztec/noir-protocol-circuits-types/types';
@@ -385,11 +449,12 @@ import { makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/serv
 import { Proof, RecursiveProof, makeRecursiveProofFromBinary } from '@aztec/stdlib/proofs';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { promises as fs } from 'fs';
+import { ungzip } from 'pako';
 import * as path from 'path';
-import { BB_RESULT, PROOF_FILENAME, PUBLIC_INPUTS_FILENAME, VK_FILENAME, generateAvmProof, generateProof, verifyAvmProof, verifyProof } from '../../bb/execute.js';
+import { BBJsFactory } from '../../bb/bb_js_backend.js';
 import { getUltraHonkFlavorForCircuit } from '../../honk.js';
 import { ProverInstrumentation } from '../../instrumentation.js';
-import { readProofsFromOutputDirectory } from '../proof_utils.js';
+import { constructRecursiveProofFromBuffers } from '../proof_utils.js';
 const logger = createLogger('bb-prover');
 _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
     [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-base'
@@ -422,10 +487,15 @@ _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
         ], []));
     }
     instrumentation;
+    bbJsFactory;
     constructor(config, telemetry){
         this.config = config;
         _initProto(this);
         this.instrumentation = new ProverInstrumentation(telemetry, 'BBNativeRollupProver');
+        this.bbJsFactory = new BBJsFactory(config.bbBinaryPath, {
+            logger,
+            debugDir: config.bbDebugOutputDir
+        });
     }
     get tracer() {
         return this.instrumentation.tracer;
@@ -439,7 +509,7 @@ _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
         await fs.mkdir(config.bbWorkingDirectory, {
             recursive: true
         });
-        logger.info(`Using native BB at ${config.bbBinaryPath} and working directory ${config.bbWorkingDirectory}`);
+        logger.info(`Using bb.js API with binary at ${config.bbBinaryPath}`);
         logger.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
         return new BBNativeRollupProver(config, telemetry);
     }
@@ -545,15 +615,14 @@ _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
         return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
     }
     async generateProofWithBB(input, circuitType, convertInput, convertOutput, workingDirectory) {
-        // Have the ACVM write the partial witness here
+        // Have the ACVM write the partial witness here (still needs a temp directory)
         const outputWitnessFile = path.join(workingDirectory, 'partial-witness.gz');
         // Generate the partial witness using the ACVM
-        // A further temp directory will be created beneath ours and then cleaned up after the partial witness has been copied to our specified location
         const simulator = new NativeACVMSimulator(this.config.acvmWorkingDirectory, this.config.acvmBinaryPath, outputWitnessFile, logger);
         const artifact = getServerCircuitArtifact(circuitType);
         logger.debug(`Generating witness data for ${circuitType}`);
         const inputWitness = convertInput(input);
-        const foreignCallHandler = undefined; // We don't handle foreign calls in the native ACVM simulator
+        const foreignCallHandler = undefined;
         const witnessResult = await simulator.executeProtocolCircuit(inputWitness, artifact, foreignCallHandler);
         const output = convertOutput(witnessResult.witness);
         const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
@@ -567,49 +636,82 @@ _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
             outputSize: output.toBuffer().length,
             eventName: 'circuit-witness-generation'
         });
-        // Now prove the circuit from the generated witness
-        logger.debug(`Proving ${circuitType}...`);
-        const provingResult = await generateProof(this.config.bbBinaryPath, workingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), this.getVerificationKeyDataForCircuit(circuitType).keyAsBytes, outputWitnessFile, getUltraHonkFlavorForCircuit(circuitType), logger);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
-            throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
+        // Read and decompress the witness for bb.js
+        const witnessGz = await fs.readFile(outputWitnessFile);
+        const witness = ungzip(witnessGz);
+        // Decompress bytecode for bb.js
+        const bytecode = ungzip(Buffer.from(artifact.bytecode, 'base64'));
+        // Prove the circuit via bb.js API
+        logger.debug(`Proving ${circuitType} via bb.js...`);
+        let proofResult;
+        try {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                const instance = _ts_add_disposable_resource(env, await this.bbJsFactory.getInstance(), true);
+                proofResult = await instance.generateProof(circuitType, bytecode, this.getVerificationKeyDataForCircuit(circuitType).keyAsBytes, witness, getUltraHonkFlavorForCircuit(circuitType));
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
+            }
+        } catch (error) {
+            throw new ProvingError(`Failed to generate proof for ${circuitType}: ${error}`);
         }
         return {
             circuitOutput: output,
-            provingResult
+            proofResult
         };
     }
-    async generateAvmProofWithBB(input, workingDirectory) {
-        logger.info(`Proving avm-circuit for TX ${input.hints.tx.hash}...`);
-        const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate AVM proof for TX ${input.hints.tx.hash}: ${provingResult.reason}`);
-            throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
-        }
-        return provingResult;
-    }
     async createAvmProof(input) {
-        const operation = async (bbWorkingDirectory)=>{
-            const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
-            const avmProof = await this.readAvmProofAsFields(provingResult.proofPath);
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
+        try {
+            logger.info(`Proving avm-circuit for TX ${input.hints.tx.hash}...`);
+            const inputsBuffer = input.serializeWithMessagePack();
+            const instance = _ts_add_disposable_resource(env, await this.bbJsFactory.getInstance(), true);
+            const { proof: proofFieldArrays, durationMs } = await instance.generateAvmProof(inputsBuffer);
+            // Convert Uint8Array[] (32-byte field elements) to Fr[]
+            const proofFields = proofFieldArrays.map((f)=>Fr.fromBuffer(Buffer.from(f)));
+            // Pad to fixed size (during development the proof length may vary)
+            if (proofFields.length > AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED) {
+                throw new Error(`Proof has ${proofFields.length} fields, expected no more than ${AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED}.`);
+            }
+            const proofFieldsPadded = proofFields.concat(Array(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED - proofFields.length).fill(new Fr(0)));
+            // Build the binary proof from the raw field data
+            const rawProofBuffer = Buffer.concat(proofFieldArrays.map((f)=>Buffer.from(f)));
+            const binaryProof = new Proof(rawProofBuffer, /*numPublicInputs=*/ 0);
+            const avmProof = new RecursiveProof(proofFieldsPadded, binaryProof, true, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
             const circuitType = 'avm-circuit';
             const appCircuitName = 'unknown';
-            this.instrumentation.recordAvmDuration('provingDuration', appCircuitName, provingResult.durationMs);
+            this.instrumentation.recordAvmDuration('provingDuration', appCircuitName, durationMs);
             this.instrumentation.recordAvmSize('proofSize', appCircuitName, avmProof.binaryProof.buffer.length);
-            logger.info(`Generated proof for ${circuitType}(${input.hints.tx.hash}) in ${Math.ceil(provingResult.durationMs)} ms`, {
+            logger.info(`Generated proof for ${circuitType}(${input.hints.tx.hash}) in ${Math.ceil(durationMs)} ms`, {
                 circuitName: circuitType,
                 appCircuitName: input.hints.tx.hash,
-                // does not include reading the proof from disk
-                duration: provingResult.durationMs,
+                duration: durationMs,
                 proofSize: avmProof.binaryProof.buffer.length,
                 eventName: 'circuit-proving',
-                inputSize: input.serializeWithMessagePack().length,
+                inputSize: inputsBuffer.length,
                 circuitSize: 1 << 21,
                 numPublicInputs: 0
             });
             return avmProof;
-        };
-        return await this.runInDirectory(operation);
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
+        }
     }
     /**
    * Executes a circuit and returns its outputs and corresponding proof with embedded aggregation object
@@ -620,21 +722,21 @@ _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
    * @param convertOutput - Function for parsing the output witness to it's corresponding object
    * @returns The circuits output object and it's proof
    */ async createRecursiveProof(input, circuitType, proofLength, convertInput, convertOutput) {
-        // this probably is gonna need to call chonk
-        const operation = async (bbWorkingDirectory)=>{
-            const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+        // Still need runInDirectory for ACVM witness generation temp files
+        const operation = async (workingDirectory)=>{
+            const { proofResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, workingDirectory);
             const vkData = this.getVerificationKeyDataForCircuit(circuitType);
-            // Read the proof as fields
-            const proof = await readProofsFromOutputDirectory(provingResult.proofPath, vkData, proofLength, logger);
+            // Construct proof from in-memory buffers (no file I/O needed)
+            const proof = constructRecursiveProofFromBuffers(proofResult.proofFields, proofResult.publicInputFields, vkData, proofLength);
             const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
-            this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
+            this.instrumentation.recordDuration('provingDuration', circuitName, proofResult.durationMs);
             this.instrumentation.recordSize('proofSize', circuitName, proof.binaryProof.buffer.length);
             this.instrumentation.recordSize('circuitPublicInputCount', circuitName, vkData.numPublicInputs);
             this.instrumentation.recordSize('circuitSize', circuitName, vkData.circuitSize);
-            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.durationMs)} ms, size: ${proof.proof.length} fields`, {
+            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(proofResult.durationMs)} ms, size: ${proof.proof.length} fields`, {
                 circuitName,
                 circuitSize: vkData.circuitSize,
-                duration: provingResult.durationMs,
+                duration: proofResult.durationMs,
                 inputSize: output.toBuffer().length,
                 proofSize: proof.binaryProof.buffer.length,
                 eventName: 'circuit-proving',
@@ -648,35 +750,69 @@ _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
         return await this.runInDirectory(operation);
     }
     /**
-   * Verifies a proof, will generate the verification key if one is not cached internally
+   * Verifies a proof via bb.js API (no temp files needed).
    * @param circuitType - The type of circuit whose proof is to be verified
    * @param proof - The proof to be verified
    */ async verifyProof(circuitType, proof) {
         const verificationKey = this.getVerificationKeyDataForCircuit(circuitType);
-        return await this.verifyInternal(proof, verificationKey, (proofPath, vkPath)=>verifyProof(this.config.bbBinaryPath, proofPath, vkPath, getUltraHonkFlavorForCircuit(circuitType), logger));
-    }
-    async verifyAvmProof(proof, publicInputs) {
-        return await this.verifyInternal(proof, /*verificationKey=*/ undefined, (proofPath, /*unused*/ _vkPath)=>verifyAvmProof(this.config.bbBinaryPath, this.config.bbWorkingDirectory, proofPath, publicInputs, logger));
-    }
-    async verifyInternal(proof, verificationKey, verificationFunction) {
-        const operation = async (bbWorkingDirectory)=>{
-            const publicInputsFileName = path.join(bbWorkingDirectory, PUBLIC_INPUTS_FILENAME);
-            const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
-            const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
-            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13189): Put this proof parsing logic in the proof class.
-            await fs.writeFile(publicInputsFileName, proof.buffer.subarray(0, proof.numPublicInputs * 32));
-            await fs.writeFile(proofFileName, proof.buffer.subarray(proof.numPublicInputs * 32));
-            if (verificationKey !== undefined) {
-                await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
-            }
-            const result = await verificationFunction(proofFileName, verificationKeyPath);
-            if (result.status === BB_RESULT.FAILURE) {
-                const errorMessage = `Failed to verify proof from key!`;
-                throw new ProvingError(errorMessage, result, result.retry);
+        const flavor = getUltraHonkFlavorForCircuit(circuitType);
+        // 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));
+        let verified;
+        let durationMs;
+        try {
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                const instance = _ts_add_disposable_resource(env, await this.bbJsFactory.getInstance(), true);
+                ({ verified, durationMs } = await instance.verifyProof(proofFields, verificationKey.keyAsBytes, publicInputFields, flavor));
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                const result = _ts_dispose_resources(env);
+                if (result) await result;
             }
-            logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
+        } catch (error) {
+            throw new ProvingError(`Failed to verify proof for ${circuitType}: ${error}`);
+        }
+        if (!verified) {
+            throw new ProvingError('Failed to verify proof from key!');
+        }
+        logger.info(`Successfully verified proof from key in ${durationMs} ms`);
+    }
+    /** Verify an AVM proof via bb.js API. */ async verifyAvmProof(proof, publicInputs) {
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
         };
-        await this.runInDirectory(operation);
+        try {
+            // For AVM proofs, numPublicInputs is 0, so the full buffer is the proof.
+            const proofBuffer = proof.buffer.subarray(proof.numPublicInputs * 32);
+            // Split the raw proof buffer into 32-byte field element arrays
+            const proofFields = [];
+            for(let i = 0; i < proofBuffer.length; i += Fr.SIZE_IN_BYTES){
+                proofFields.push(new Uint8Array(proofBuffer.subarray(i, i + Fr.SIZE_IN_BYTES)));
+            }
+            const piBuffer = publicInputs.serializeWithMessagePack();
+            const instance = _ts_add_disposable_resource(env, await this.bbJsFactory.getInstance(), true);
+            const { verified, durationMs } = await instance.verifyAvmProof(proofFields, piBuffer);
+            if (!verified) {
+                throw new ProvingError('Failed to verify AVM proof!');
+            }
+            logger.info(`Successfully verified AVM proof in ${durationMs} ms`);
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
+        } finally{
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
+        }
     }
     /**
    * Returns the verification key data for a circuit.
@@ -689,20 +825,6 @@ _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
         }
         return vk;
     }
-    async readAvmProofAsFields(proofFilename) {
-        const rawProofBuffer = await fs.readFile(proofFilename);
-        const reader = BufferReader.asReader(rawProofBuffer);
-        const proofFields = reader.readArray(rawProofBuffer.length / Fr.SIZE_IN_BYTES, Fr);
-        // We extend to a fixed-size padded proof as during development any new AVM circuit column changes the
-        // proof length and we do not have a mechanism to feedback a cpp constant to noir/TS.
-        // TODO(#13390): Revive a non-padded AVM proof
-        if (proofFields.length > AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED) {
-            throw new Error(`Proof has ${proofFields.length} fields, expected no more than ${AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED}.`);
-        }
-        const proofFieldsPadded = proofFields.concat(Array(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED - proofFields.length).fill(new Fr(0)));
-        const proof = new Proof(rawProofBuffer, /*numPublicInputs=*/ 0);
-        return new RecursiveProof(proofFieldsPadded, proof, true, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
-    }
     runInDirectory(fn) {
         return runInDirectory(this.config.bbWorkingDirectory, (dir)=>fn(dir).catch((err)=>{
                 logger.error(`Error running operation at ${dir}: ${err}`);
@@ -710,3 +832,10 @@ _dec = trackSpan('BBNativeRollupProver.getBaseParityProof', {
             }), this.config.bbSkipCleanup, logger);
     }
 }
+/** 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/verification_key/verification_key_data.js

@@ -3,7 +3,7 @@ import { BufferReader } from '@aztec/foundation/serialize';
 import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { VK_FILENAME } from '../bb/execute.js';
+import { VK_FILENAME } from '../bb/file_names.js';
 /**
  * Reads the verification key data stored at the specified location and parses into a VerificationKeyData
  * @param vkDirectoryPath - The directory containing the verification key data files

package/dest/verifier/batch_chonk_verifier.d.ts

@@ -0,0 +1,56 @@
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
+import type { Tx } from '@aztec/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;
+    /** 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":"AAMA,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AACjH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAU3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAwB7C;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,YAAW,6BAA6B;IAkBpE,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,KAAK;IApBf,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,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,eASN;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;IA6BpB,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"}