@aztec/bb-prover 0.43.0 → 0.44.0

package/dest/prover/bb_prover.js

@@ -1,3 +1,4 @@
+import { __esDecorate, __runInitializers } from "tslib";
 /* eslint-disable require-await */
 import { makePublicInputsAndRecursiveProof, } from '@aztec/circuit-types';
 import { AGGREGATION_OBJECT_LENGTH, EmptyNestedCircuitInputs, EmptyNestedData, Fr, NESTED_RECURSIVE_PROOF_LENGTH, PrivateKernelEmptyInputs, Proof, RECURSIVE_PROOF_LENGTH, RecursiveProof, RootParityInput, makeRecursiveProofFromBinary, } from '@aztec/circuits.js';
@@ -6,10 +7,12 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { EmptyNestedArtifact, ServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBaseRollupInputsToWitnessMap, convertBaseRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPrivateKernelEmptyInputsToWitnessMap, convertPrivateKernelEmptyOutputsFromWitnessMap, convertPublicTailInputsToWitnessMap, convertPublicTailOutputFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, } from '@aztec/noir-protocol-circuits-types';
 import { NativeACVMSimulator } from '@aztec/simulator';
+import { Attributes, trackSpan } from '@aztec/telemetry-client';
 import { abiEncode } from '@noir-lang/noirc_abi';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { BB_RESULT, PROOF_FIELDS_FILENAME, PROOF_FILENAME, VK_FILENAME, generateAvmProof, generateKeyForNoirCircuit, generateProof, verifyAvmProof, verifyProof, writeProofAsFields, } from '../bb/execute.js';
+import { ProverInstrumentation } from '../instrumentation.js';
 import { PublicKernelArtifactMapping } from '../mappings/mappings.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
@@ -21,397 +24,446 @@ const CIRCUITS_WITHOUT_AGGREGATION = new Set([
 /**
  * Prover implementation that uses barretenberg native proving
  */
-export class BBNativeRollupProver {
-    constructor(config) {
-        this.config = config;
-        this.verificationKeys = new Map();
-    }
-    static async new(config) {
-        await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
-        await fs.mkdir(config.acvmWorkingDirectory, { recursive: true });
-        await fs.access(config.bbBinaryPath, fs.constants.R_OK);
-        await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
-        logger.info(`Using native BB at ${config.bbBinaryPath} and working directory ${config.bbWorkingDirectory}`);
-        logger.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
-        return new BBNativeRollupProver(config);
-    }
-    /**
-     * Simulates the base parity circuit from its inputs.
-     * @param inputs - Inputs to the circuit.
-     * @returns The public inputs of the parity circuit.
-     */
-    async getBaseParityProof(inputs) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'BaseParityArtifact', RECURSIVE_PROOF_LENGTH, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap);
-        const verificationKey = await this.getVerificationKeyDataForCircuit('BaseParityArtifact');
-        await this.verifyProof('BaseParityArtifact', proof.binaryProof);
-        return new RootParityInput(proof, verificationKey.keyAsFields, circuitOutput);
-    }
-    /**
-     * Simulates the root parity circuit from its inputs.
-     * @param inputs - Inputs to the circuit.
-     * @returns The public inputs of the parity circuit.
-     */
-    async getRootParityProof(inputs) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'RootParityArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap);
-        const verificationKey = await this.getVerificationKeyDataForCircuit('RootParityArtifact');
-        await this.verifyProof('RootParityArtifact', proof.binaryProof);
-        return new RootParityInput(proof, verificationKey.keyAsFields, circuitOutput);
-    }
-    /**
-     * Creates an AVM proof and verifies it.
-     * @param inputs - The inputs to the AVM circuit.
-     * @returns The proof.
-     */
-    async getAvmProof(inputs) {
-        const proofAndVk = await this.createAvmProof(inputs);
-        await this.verifyAvmProof(proofAndVk.proof, proofAndVk.verificationKey);
-        return proofAndVk;
-    }
-    /**
-     * Requests that a public kernel circuit be executed and the proof generated
-     * @param kernelRequest - The object encapsulating the request for a proof
-     * @returns The requested circuit's public inputs and proof
-     */
-    async getPublicKernelProof(kernelRequest) {
-        const kernelOps = PublicKernelArtifactMapping[kernelRequest.type];
-        if (kernelOps === undefined) {
-            throw new Error(`Unable to prove kernel type ${kernelRequest.type}`);
-        }
-        // We may need to convert the recursive proof into fields format
-        kernelRequest.inputs.previousKernel.proof = await this.ensureValidProof(kernelRequest.inputs.previousKernel.proof, kernelOps.artifact, kernelRequest.inputs.previousKernel.vk);
-        await this.verifyWithKey(kernelRequest.inputs.previousKernel.vk, kernelRequest.inputs.previousKernel.proof.binaryProof);
-        const { circuitOutput, proof } = await this.createRecursiveProof(kernelRequest.inputs, kernelOps.artifact, NESTED_RECURSIVE_PROOF_LENGTH, kernelOps.convertInputs, kernelOps.convertOutputs);
-        const verificationKey = await this.getVerificationKeyDataForCircuit(kernelOps.artifact);
-        await this.verifyProof(kernelOps.artifact, proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-     * Requests that the public kernel tail circuit be executed and the proof generated
-     * @param kernelRequest - The object encapsulating the request for a proof
-     * @returns The requested circuit's public inputs and proof
-     */
-    async getPublicTailProof(kernelRequest) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(kernelRequest.inputs, 'PublicKernelTailArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertPublicTailInputsToWitnessMap, convertPublicTailOutputFromWitnessMap);
-        const verificationKey = await this.getVerificationKeyDataForCircuit('PublicKernelTailArtifact');
-        await this.verifyProof('PublicKernelTailArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-     * Simulates the base rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    async getBaseRollupProof(input) {
-        // We may need to convert the recursive proof into fields format
-        input.kernelData.proof = await this.ensureValidProof(input.kernelData.proof, 'BaseRollupArtifact', input.kernelData.vk);
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BaseRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertBaseRollupInputsToWitnessMap, convertBaseRollupOutputsFromWitnessMap);
-        const verificationKey = await this.getVerificationKeyDataForCircuit('BaseRollupArtifact');
-        await this.verifyProof('BaseRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-     * Simulates the merge rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    async getMergeRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'MergeRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap);
-        const verificationKey = await this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
-        await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-     * Simulates the root rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    async getRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createProof(input, 'RootRollupArtifact', convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap);
-        const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
-        const verificationKey = await this.getVerificationKeyDataForCircuit('RootRollupArtifact');
-        await this.verifyProof('RootRollupArtifact', proof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, verificationKey);
-    }
-    async getEmptyPrivateKernelProof(inputs) {
-        const emptyNested = await this.getEmptyNestedProof();
-        const emptyPrivateKernelProof = await this.getEmptyPrivateKernelProofFromEmptyNested(PrivateKernelEmptyInputs.from({
-            ...inputs,
-            emptyNested,
-        }));
-        return emptyPrivateKernelProof;
-    }
-    async getEmptyNestedProof() {
-        const inputs = new EmptyNestedCircuitInputs();
-        const { proof } = await this.createRecursiveProof(inputs, 'EmptyNestedArtifact', RECURSIVE_PROOF_LENGTH, (nothing) => abiEncode(EmptyNestedArtifact.abi, { _inputs: nothing }), () => new EmptyNestedCircuitInputs());
-        const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyNestedArtifact');
-        await this.verifyProof('EmptyNestedArtifact', proof.binaryProof);
-        return new EmptyNestedData(proof, verificationKey.keyAsFields);
-    }
-    async getEmptyPrivateKernelProofFromEmptyNested(inputs) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'PrivateKernelEmptyArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertPrivateKernelEmptyInputsToWitnessMap, convertPrivateKernelEmptyOutputsFromWitnessMap);
-        const verificationKey = await this.getVerificationKeyDataForCircuit('PrivateKernelEmptyArtifact');
-        await this.verifyProof('PrivateKernelEmptyArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    async generateProofWithBB(input, circuitType, convertInput, convertOutput, workingDirectory) {
-        // Have the ACVM write the partial witness here
-        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);
-        const artifact = ServerCircuitArtifacts[circuitType];
-        logger.debug(`Generating witness data for ${circuitType}`);
-        const inputWitness = convertInput(input);
-        const timer = new Timer();
-        const outputWitness = await simulator.simulateCircuit(inputWitness, artifact);
-        const witnessGenerationDuration = timer.ms();
-        const output = convertOutput(outputWitness);
-        logger.debug(`Generated witness`, {
-            circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-            duration: witnessGenerationDuration,
-            inputSize: input.toBuffer().length,
-            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'), outputWitnessFile, logger.debug);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
-            throw new Error(provingResult.reason);
-        }
-        // Ensure our vk cache is up to date
-        const vkData = await this.updateVerificationKeyAfterProof(provingResult.vkPath, circuitType);
-        return {
-            circuitOutput: output,
-            vkData,
-            provingResult,
-        };
-    }
-    async createProof(input, circuitType, convertInput, convertOutput) {
-        const operation = async (bbWorkingDirectory) => {
-            const { provingResult, vkData, circuitOutput: output, } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
-            // Read the binary proof
-            const rawProof = await fs.readFile(`${provingResult.proofPath}/${PROOF_FILENAME}`);
-            const proof = new Proof(rawProof, vkData.numPublicInputs);
-            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${proof.buffer.length} bytes`, {
-                circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-                // does not include reading the proof from disk
-                duration: provingResult.duration,
-                proofSize: proof.buffer.length,
-                eventName: 'circuit-proving',
-                // circuitOutput is the partial witness that became the input to the proof
-                inputSize: output.toBuffer().length,
-                circuitSize: vkData.circuitSize,
-                numPublicInputs: vkData.numPublicInputs,
-            });
-            return { circuitOutput: output, proof };
-        };
-        return await runInDirectory(this.config.bbWorkingDirectory, operation);
-    }
-    async generateAvmProofWithBB(input, workingDirectory) {
-        logger.debug(`Proving avm-circuit...`);
-        const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger.verbose);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate proof for avm-circuit: ${provingResult.reason}`);
-            throw new Error(provingResult.reason);
-        }
-        return provingResult;
-    }
-    async createAvmProof(input) {
-        const cleanupDir = !process.env.AVM_PROVING_PRESERVE_WORKING_DIR;
-        const operation = async (bbWorkingDirectory) => {
-            if (!cleanupDir) {
-                logger.info(`Preserving working directory ${bbWorkingDirectory}`);
+let BBNativeRollupProver = (() => {
+    var _a;
+    let _instanceExtraInitializers = [];
+    let _getBaseParityProof_decorators;
+    let _getRootParityProof_decorators;
+    let _getAvmProof_decorators;
+    let _getPublicKernelProof_decorators;
+    return _a = class BBNativeRollupProver {
+            constructor(config, telemetry) {
+                this.config = (__runInitializers(this, _instanceExtraInitializers), config);
+                this.verificationKeys = new Map();
+                this.instrumentation = new ProverInstrumentation(telemetry, 'BBNativeRollupProver');
             }
-            const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
-            const rawProof = await fs.readFile(provingResult.proofPath);
-            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6773): this VK data format is wrong.
-            // In particular, the number of public inputs, etc will be wrong.
-            const verificationKey = await extractVkData(provingResult.vkPath);
-            const proof = new Proof(rawProof, verificationKey.numPublicInputs);
-            const circuitType = 'avm-circuit';
-            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${proof.buffer.length} bytes`, {
-                circuitName: circuitType,
-                // does not include reading the proof from disk
-                duration: provingResult.duration,
-                proofSize: proof.buffer.length,
-                eventName: 'circuit-proving',
-                inputSize: input.toBuffer().length,
-                circuitSize: verificationKey.circuitSize,
-                numPublicInputs: verificationKey.numPublicInputs,
-            });
-            return { proof, verificationKey };
-        };
-        return await runInDirectory(this.config.bbWorkingDirectory, operation, cleanupDir);
-    }
-    /**
-     * Executes a circuit and returns it's outputs and corresponding proof with embedded aggregation object
-     * @param witnessMap - The input witness
-     * @param circuitType - The type of circuit to be executed
-     * @param proofLength - The length of the proof to be generated. This is a dummy parameter to aid in type checking
-     * @param convertInput - Function for mapping the input object to a witness map.
-     * @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) {
-        const operation = async (bbWorkingDirectory) => {
-            const { provingResult, vkData, circuitOutput: output, } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
-            // Read the proof as fields
-            const proof = await this.readProofAsFields(provingResult.proofPath, circuitType, proofLength);
-            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${proof.proof.length} fields`, {
-                circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-                circuitSize: vkData.circuitSize,
-                duration: provingResult.duration,
-                inputSize: output.toBuffer().length,
-                proofSize: proof.binaryProof.buffer.length,
-                eventName: 'circuit-proving',
-                numPublicInputs: vkData.numPublicInputs,
-            });
-            return {
-                circuitOutput: output,
-                proof,
-            };
-        };
-        return await runInDirectory(this.config.bbWorkingDirectory, operation);
-    }
-    /**
-     * Verifies a proof, will generate the verification key if one is not cached internally
-     * @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 = await this.getVerificationKeyDataForCircuit(circuitType);
-        return await this.verifyWithKey(verificationKey, proof);
-    }
-    async verifyAvmProof(proof, verificationKey) {
-        return await this.verifyWithKeyInternal(proof, verificationKey, verifyAvmProof);
-    }
-    async verifyWithKey(verificationKey, proof) {
-        return await this.verifyWithKeyInternal(proof, verificationKey, verifyProof);
-    }
-    async verifyWithKeyInternal(proof, verificationKey, verificationFunction) {
-        const operation = async (bbWorkingDirectory) => {
-            const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
-            const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
-            await fs.writeFile(proofFileName, proof.buffer);
-            await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
-            const logFunction = (message) => {
-                logger.debug(`BB out - ${message}`);
-            };
-            const result = await verificationFunction(this.config.bbBinaryPath, proofFileName, verificationKeyPath, logFunction);
-            if (result.status === BB_RESULT.FAILURE) {
-                const errorMessage = `Failed to verify proof from key!`;
-                throw new Error(errorMessage);
+            get tracer() {
+                return this.instrumentation.tracer;
             }
-            logger.debug(`Successfully verified proof from key in ${result.duration} ms`);
-        };
-        await runInDirectory(this.config.bbWorkingDirectory, operation);
-    }
-    /**
-     * Returns the verification key for a circuit, will generate it if not cached internally
-     * @param circuitType - The type of circuit for which the verification key is required
-     * @returns The verification key
-     */
-    async getVerificationKeyForCircuit(circuitType) {
-        const vkData = await this.getVerificationKeyDataForCircuit(circuitType);
-        return vkData.clone().keyAsFields;
-    }
-    /**
-     * Will check a recursive proof argument for validity of it's 'fields' format of proof and convert if required
-     * @param proof - The input proof that may need converting
-     * @returns - The valid proof
-     */
-    async ensureValidProof(proof, circuit, vk) {
-        // If the 'fields' proof is already valid then simply return
-        // This will be false for proofs coming from clients
-        if (proof.fieldsValid) {
-            return proof;
-        }
-        const operation = async (bbWorkingDirectory) => {
-            const numPublicInputs = vk.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-            const proofFullFilename = path.join(bbWorkingDirectory, PROOF_FILENAME);
-            const vkFullFilename = path.join(bbWorkingDirectory, VK_FILENAME);
-            logger.debug(`Converting proof to fields format for circuit ${circuit}, directory ${bbWorkingDirectory}, num public inputs: ${vk.numPublicInputs}, proof length ${proof.binaryProof.buffer.length}, vk length ${vk.keyAsBytes.length}`);
-            await fs.writeFile(proofFullFilename, proof.binaryProof.buffer);
-            await fs.writeFile(vkFullFilename, vk.keyAsBytes);
-            const logFunction = (message) => {
-                logger.debug(`${circuit} BB out - ${message}`);
-            };
-            const result = await writeProofAsFields(this.config.bbBinaryPath, bbWorkingDirectory, PROOF_FILENAME, vkFullFilename, logFunction);
-            if (result.status === BB_RESULT.FAILURE) {
-                const errorMessage = `Failed to convert ${circuit} proof to fields, ${result.reason}`;
-                throw new Error(errorMessage);
+            static async new(config, telemetry) {
+                await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
+                await fs.mkdir(config.acvmWorkingDirectory, { recursive: true });
+                await fs.access(config.bbBinaryPath, fs.constants.R_OK);
+                await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
+                logger.info(`Using native BB at ${config.bbBinaryPath} and working directory ${config.bbWorkingDirectory}`);
+                logger.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
+                return new _a(config, telemetry);
             }
-            const proofString = await fs.readFile(path.join(bbWorkingDirectory, PROOF_FIELDS_FILENAME), {
-                encoding: 'utf-8',
-            });
-            const json = JSON.parse(proofString);
-            const fields = json.slice(numPublicInputs).map(Fr.fromString);
-            return new RecursiveProof(fields, new Proof(proof.binaryProof.buffer, vk.numPublicInputs), true);
-        };
-        return await runInDirectory(this.config.bbWorkingDirectory, operation);
-    }
-    /**
-     * Returns the verification key data for a circuit, will generate and cache it if not cached internally
-     * @param circuitType - The type of circuit for which the verification key is required
-     * @returns The verification key data
-     */
-    async getVerificationKeyDataForCircuit(circuitType) {
-        let promise = this.verificationKeys.get(circuitType);
-        if (!promise) {
-            promise = generateKeyForNoirCircuit(this.config.bbBinaryPath, this.config.bbWorkingDirectory, circuitType, ServerCircuitArtifacts[circuitType], 'vk', logger.debug).then(result => {
-                if (result.status === BB_RESULT.FAILURE) {
-                    throw new Error(`Failed to generate verification key for ${circuitType}, ${result.reason}`);
+            /**
+             * Simulates the base parity circuit from its inputs.
+             * @param inputs - Inputs to the circuit.
+             * @returns The public inputs of the parity circuit.
+             */
+            async getBaseParityProof(inputs) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'BaseParityArtifact', RECURSIVE_PROOF_LENGTH, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap);
+                const verificationKey = await this.getVerificationKeyDataForCircuit('BaseParityArtifact');
+                await this.verifyProof('BaseParityArtifact', proof.binaryProof);
+                return new RootParityInput(proof, verificationKey.keyAsFields, circuitOutput);
+            }
+            /**
+             * Simulates the root parity circuit from its inputs.
+             * @param inputs - Inputs to the circuit.
+             * @returns The public inputs of the parity circuit.
+             */
+            async getRootParityProof(inputs) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'RootParityArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap);
+                const verificationKey = await this.getVerificationKeyDataForCircuit('RootParityArtifact');
+                await this.verifyProof('RootParityArtifact', proof.binaryProof);
+                return new RootParityInput(proof, verificationKey.keyAsFields, circuitOutput);
+            }
+            /**
+             * Creates an AVM proof and verifies it.
+             * @param inputs - The inputs to the AVM circuit.
+             * @returns The proof.
+             */
+            async getAvmProof(inputs) {
+                const proofAndVk = await this.createAvmProof(inputs);
+                await this.verifyAvmProof(proofAndVk.proof, proofAndVk.verificationKey);
+                return proofAndVk;
+            }
+            /**
+             * Requests that a public kernel circuit be executed and the proof generated
+             * @param kernelRequest - The object encapsulating the request for a proof
+             * @returns The requested circuit's public inputs and proof
+             */
+            async getPublicKernelProof(kernelRequest) {
+                const kernelOps = PublicKernelArtifactMapping[kernelRequest.type];
+                if (kernelOps === undefined) {
+                    throw new Error(`Unable to prove kernel type ${kernelRequest.type}`);
+                }
+                // We may need to convert the recursive proof into fields format
+                kernelRequest.inputs.previousKernel.proof = await this.ensureValidProof(kernelRequest.inputs.previousKernel.proof, kernelOps.artifact, kernelRequest.inputs.previousKernel.vk);
+                await this.verifyWithKey(kernelRequest.inputs.previousKernel.vk, kernelRequest.inputs.previousKernel.proof.binaryProof);
+                const { circuitOutput, proof } = await this.createRecursiveProof(kernelRequest.inputs, kernelOps.artifact, NESTED_RECURSIVE_PROOF_LENGTH, kernelOps.convertInputs, kernelOps.convertOutputs);
+                const verificationKey = await this.getVerificationKeyDataForCircuit(kernelOps.artifact);
+                await this.verifyProof(kernelOps.artifact, proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * Requests that the public kernel tail circuit be executed and the proof generated
+             * @param kernelRequest - The object encapsulating the request for a proof
+             * @returns The requested circuit's public inputs and proof
+             */
+            async getPublicTailProof(kernelRequest) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(kernelRequest.inputs, 'PublicKernelTailArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertPublicTailInputsToWitnessMap, convertPublicTailOutputFromWitnessMap);
+                const verificationKey = await this.getVerificationKeyDataForCircuit('PublicKernelTailArtifact');
+                await this.verifyProof('PublicKernelTailArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * Simulates the base rollup circuit from its inputs.
+             * @param input - Inputs to the circuit.
+             * @returns The public inputs as outputs of the simulation.
+             */
+            async getBaseRollupProof(input) {
+                // We may need to convert the recursive proof into fields format
+                input.kernelData.proof = await this.ensureValidProof(input.kernelData.proof, 'BaseRollupArtifact', input.kernelData.vk);
+                const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BaseRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertBaseRollupInputsToWitnessMap, convertBaseRollupOutputsFromWitnessMap);
+                const verificationKey = await this.getVerificationKeyDataForCircuit('BaseRollupArtifact');
+                await this.verifyProof('BaseRollupArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * Simulates the merge rollup circuit from its inputs.
+             * @param input - Inputs to the circuit.
+             * @returns The public inputs as outputs of the simulation.
+             */
+            async getMergeRollupProof(input) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(input, 'MergeRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap);
+                const verificationKey = await this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
+                await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * Simulates the root rollup circuit from its inputs.
+             * @param input - Inputs to the circuit.
+             * @returns The public inputs as outputs of the simulation.
+             */
+            async getRootRollupProof(input) {
+                const { circuitOutput, proof } = await this.createProof(input, 'RootRollupArtifact', convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap);
+                const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
+                const verificationKey = await this.getVerificationKeyDataForCircuit('RootRollupArtifact');
+                await this.verifyProof('RootRollupArtifact', proof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, verificationKey);
+            }
+            async getEmptyPrivateKernelProof(inputs) {
+                const emptyNested = await this.getEmptyNestedProof();
+                const emptyPrivateKernelProof = await this.getEmptyPrivateKernelProofFromEmptyNested(PrivateKernelEmptyInputs.from({
+                    ...inputs,
+                    emptyNested,
+                }));
+                return emptyPrivateKernelProof;
+            }
+            async getEmptyNestedProof() {
+                const inputs = new EmptyNestedCircuitInputs();
+                const { proof } = await this.createRecursiveProof(inputs, 'EmptyNestedArtifact', RECURSIVE_PROOF_LENGTH, (nothing) => abiEncode(EmptyNestedArtifact.abi, { _inputs: nothing }), () => new EmptyNestedCircuitInputs());
+                const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyNestedArtifact');
+                await this.verifyProof('EmptyNestedArtifact', proof.binaryProof);
+                return new EmptyNestedData(proof, verificationKey.keyAsFields);
+            }
+            async getEmptyPrivateKernelProofFromEmptyNested(inputs) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'PrivateKernelEmptyArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertPrivateKernelEmptyInputsToWitnessMap, convertPrivateKernelEmptyOutputsFromWitnessMap);
+                const verificationKey = await this.getVerificationKeyDataForCircuit('PrivateKernelEmptyArtifact');
+                await this.verifyProof('PrivateKernelEmptyArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            async generateProofWithBB(input, circuitType, convertInput, convertOutput, workingDirectory) {
+                // Have the ACVM write the partial witness here
+                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);
+                const artifact = ServerCircuitArtifacts[circuitType];
+                logger.debug(`Generating witness data for ${circuitType}`);
+                const inputWitness = convertInput(input);
+                const timer = new Timer();
+                const outputWitness = await simulator.simulateCircuit(inputWitness, artifact);
+                const output = convertOutput(outputWitness);
+                const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
+                this.instrumentation.recordDuration('witGenDuration', circuitName, timer);
+                this.instrumentation.recordSize('witGenInputSize', circuitName, input.toBuffer().length);
+                this.instrumentation.recordSize('witGenOutputSize', circuitName, output.toBuffer().length);
+                logger.debug(`Generated witness`, {
+                    circuitName,
+                    duration: timer.ms(),
+                    inputSize: input.toBuffer().length,
+                    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'), outputWitnessFile, logger.debug);
+                if (provingResult.status === BB_RESULT.FAILURE) {
+                    logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
+                    throw new Error(provingResult.reason);
+                }
+                // Ensure our vk cache is up to date
+                const vkData = await this.updateVerificationKeyAfterProof(provingResult.vkPath, circuitType);
+                return {
+                    circuitOutput: output,
+                    vkData,
+                    provingResult,
+                };
+            }
+            async createProof(input, circuitType, convertInput, convertOutput) {
+                const operation = async (bbWorkingDirectory) => {
+                    const { provingResult, vkData, circuitOutput: output, } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+                    // Read the binary proof
+                    const rawProof = await fs.readFile(`${provingResult.proofPath}/${PROOF_FILENAME}`);
+                    const proof = new Proof(rawProof, vkData.numPublicInputs);
+                    const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
+                    this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs / 1000);
+                    this.instrumentation.recordSize('proofSize', circuitName, proof.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`, {
+                        circuitName,
+                        // does not include reading the proof from disk
+                        duration: provingResult.durationMs,
+                        proofSize: proof.buffer.length,
+                        eventName: 'circuit-proving',
+                        // circuitOutput is the partial witness that became the input to the proof
+                        inputSize: output.toBuffer().length,
+                        circuitSize: vkData.circuitSize,
+                        numPublicInputs: vkData.numPublicInputs,
+                    });
+                    return { circuitOutput: output, proof };
+                };
+                return await runInDirectory(this.config.bbWorkingDirectory, operation);
+            }
+            async generateAvmProofWithBB(input, workingDirectory) {
+                logger.info(`Proving avm-circuit for ${input.functionName}...`);
+                const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger.verbose);
+                if (provingResult.status === BB_RESULT.FAILURE) {
+                    logger.error(`Failed to generate AVM proof for ${input.functionName}: ${provingResult.reason}`);
+                    throw new Error(provingResult.reason);
+                }
+                return provingResult;
+            }
+            async createAvmProof(input) {
+                const cleanupDir = !process.env.AVM_PROVING_PRESERVE_WORKING_DIR;
+                const operation = async (bbWorkingDirectory) => {
+                    if (!cleanupDir) {
+                        logger.info(`Preserving working directory ${bbWorkingDirectory}`);
+                    }
+                    const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
+                    const rawProof = await fs.readFile(provingResult.proofPath);
+                    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6773): this VK data format is wrong.
+                    // In particular, the number of public inputs, etc will be wrong.
+                    const verificationKey = await extractVkData(provingResult.vkPath);
+                    const proof = new Proof(rawProof, verificationKey.numPublicInputs);
+                    const circuitType = 'avm-circuit';
+                    const appCircuitName = 'unknown';
+                    this.instrumentation.recordAvmDuration('provingDuration', appCircuitName, provingResult.durationMs);
+                    this.instrumentation.recordAvmSize('proofSize', appCircuitName, proof.buffer.length);
+                    this.instrumentation.recordAvmSize('circuitPublicInputCount', appCircuitName, verificationKey.numPublicInputs);
+                    this.instrumentation.recordAvmSize('circuitSize', appCircuitName, verificationKey.circuitSize);
+                    logger.info(`Generated proof for ${circuitType}(${input.functionName}) in ${Math.ceil(provingResult.durationMs)} ms`, {
+                        circuitName: circuitType,
+                        appCircuitName: input.functionName,
+                        // does not include reading the proof from disk
+                        duration: provingResult.durationMs,
+                        proofSize: proof.buffer.length,
+                        eventName: 'circuit-proving',
+                        inputSize: input.toBuffer().length,
+                        circuitSize: verificationKey.circuitSize, // FIX: wrong in VK
+                        numPublicInputs: verificationKey.numPublicInputs, // FIX: wrong in VK
+                    });
+                    return { proof, verificationKey };
+                };
+                return await runInDirectory(this.config.bbWorkingDirectory, operation, cleanupDir);
+            }
+            /**
+             * Executes a circuit and returns it's outputs and corresponding proof with embedded aggregation object
+             * @param witnessMap - The input witness
+             * @param circuitType - The type of circuit to be executed
+             * @param proofLength - The length of the proof to be generated. This is a dummy parameter to aid in type checking
+             * @param convertInput - Function for mapping the input object to a witness map.
+             * @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) {
+                const operation = async (bbWorkingDirectory) => {
+                    const { provingResult, vkData, circuitOutput: output, } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+                    // Read the proof as fields
+                    const proof = await this.readProofAsFields(provingResult.proofPath, circuitType, proofLength);
+                    const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
+                    this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs / 1000);
+                    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`, {
+                        circuitName,
+                        circuitSize: vkData.circuitSize,
+                        duration: provingResult.durationMs,
+                        inputSize: output.toBuffer().length,
+                        proofSize: proof.binaryProof.buffer.length,
+                        eventName: 'circuit-proving',
+                        numPublicInputs: vkData.numPublicInputs,
+                    });
+                    return {
+                        circuitOutput: output,
+                        proof,
+                    };
+                };
+                return await runInDirectory(this.config.bbWorkingDirectory, operation);
+            }
+            /**
+             * Verifies a proof, will generate the verification key if one is not cached internally
+             * @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 = await this.getVerificationKeyDataForCircuit(circuitType);
+                return await this.verifyWithKey(verificationKey, proof);
+            }
+            async verifyAvmProof(proof, verificationKey) {
+                return await this.verifyWithKeyInternal(proof, verificationKey, verifyAvmProof);
+            }
+            async verifyWithKey(verificationKey, proof) {
+                return await this.verifyWithKeyInternal(proof, verificationKey, verifyProof);
+            }
+            async verifyWithKeyInternal(proof, verificationKey, verificationFunction) {
+                const operation = async (bbWorkingDirectory) => {
+                    const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
+                    const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
+                    await fs.writeFile(proofFileName, proof.buffer);
+                    await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+                    const logFunction = (message) => {
+                        logger.debug(`BB out - ${message}`);
+                    };
+                    const result = await verificationFunction(this.config.bbBinaryPath, proofFileName, verificationKeyPath, logFunction);
+                    if (result.status === BB_RESULT.FAILURE) {
+                        const errorMessage = `Failed to verify proof from key!`;
+                        throw new Error(errorMessage);
+                    }
+                    logger.debug(`Successfully verified proof from key in ${result.durationMs} ms`);
+                };
+                await runInDirectory(this.config.bbWorkingDirectory, operation);
+            }
+            /**
+             * Returns the verification key for a circuit, will generate it if not cached internally
+             * @param circuitType - The type of circuit for which the verification key is required
+             * @returns The verification key
+             */
+            async getVerificationKeyForCircuit(circuitType) {
+                const vkData = await this.getVerificationKeyDataForCircuit(circuitType);
+                return vkData.clone().keyAsFields;
+            }
+            /**
+             * Will check a recursive proof argument for validity of it's 'fields' format of proof and convert if required
+             * @param proof - The input proof that may need converting
+             * @returns - The valid proof
+             */
+            async ensureValidProof(proof, circuit, vk) {
+                // If the 'fields' proof is already valid then simply return
+                // This will be false for proofs coming from clients
+                if (proof.fieldsValid) {
+                    return proof;
                 }
-                return extractVkData(result.vkPath);
-            });
-            this.verificationKeys.set(circuitType, promise);
-        }
-        const vk = await promise;
-        return vk.clone();
-    }
-    /**
-     * Ensures our verification key cache includes the key data located at the specified directory
-     * @param filePath - The directory containing the verification key data files
-     * @param circuitType - The type of circuit to which the verification key corresponds
-     */
-    async updateVerificationKeyAfterProof(filePath, circuitType) {
-        let promise = this.verificationKeys.get(circuitType);
-        if (!promise) {
-            promise = extractVkData(filePath);
-            this.verificationKeys.set(circuitType, promise);
-        }
-        return promise;
-    }
-    /**
-     * Parses and returns the proof data stored at the specified directory
-     * @param filePath - The directory containing the proof data
-     * @param circuitType - The type of circuit proven
-     * @returns The proof
-     */
-    async readProofAsFields(filePath, circuitType, proofLength) {
-        const proofFilename = path.join(filePath, PROOF_FILENAME);
-        const proofFieldsFilename = path.join(filePath, PROOF_FIELDS_FILENAME);
-        const [binaryProof, proofString] = await Promise.all([
-            fs.readFile(proofFilename),
-            fs.readFile(proofFieldsFilename, { encoding: 'utf-8' }),
-        ]);
-        const json = JSON.parse(proofString);
-        const vkData = await this.verificationKeys.get(circuitType);
-        if (!vkData) {
-            throw new Error(`Invalid verification key for ${circuitType}`);
-        }
-        const numPublicInputs = CIRCUITS_WITHOUT_AGGREGATION.has(circuitType)
-            ? vkData.numPublicInputs
-            : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-        const fieldsWithoutPublicInputs = json.slice(numPublicInputs).map(Fr.fromString);
-        logger.debug(`Circuit type: ${circuitType}, complete proof length: ${json.length}, without public inputs: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`);
-        const proof = new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProof, numPublicInputs), true);
-        if (proof.proof.length !== proofLength) {
-            throw new Error(`Proof length doesn't match expected length (${proof.proof.length} != ${proofLength})`);
-        }
-        return proof;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bb_prover.js","sourceRoot":"","sources":["../../src/prover/bb_prover.ts"],"names":[],"mappings":"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"}
+                const operation = async (bbWorkingDirectory) => {
+                    const numPublicInputs = vk.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+                    const proofFullFilename = path.join(bbWorkingDirectory, PROOF_FILENAME);
+                    const vkFullFilename = path.join(bbWorkingDirectory, VK_FILENAME);
+                    logger.debug(`Converting proof to fields format for circuit ${circuit}, directory ${bbWorkingDirectory}, num public inputs: ${vk.numPublicInputs}, proof length ${proof.binaryProof.buffer.length}, vk length ${vk.keyAsBytes.length}`);
+                    await fs.writeFile(proofFullFilename, proof.binaryProof.buffer);
+                    await fs.writeFile(vkFullFilename, vk.keyAsBytes);
+                    const logFunction = (message) => {
+                        logger.debug(`${circuit} BB out - ${message}`);
+                    };
+                    const result = await writeProofAsFields(this.config.bbBinaryPath, bbWorkingDirectory, PROOF_FILENAME, vkFullFilename, logFunction);
+                    if (result.status === BB_RESULT.FAILURE) {
+                        const errorMessage = `Failed to convert ${circuit} proof to fields, ${result.reason}`;
+                        throw new Error(errorMessage);
+                    }
+                    const proofString = await fs.readFile(path.join(bbWorkingDirectory, PROOF_FIELDS_FILENAME), {
+                        encoding: 'utf-8',
+                    });
+                    const json = JSON.parse(proofString);
+                    const fields = json.slice(numPublicInputs).map(Fr.fromString);
+                    return new RecursiveProof(fields, new Proof(proof.binaryProof.buffer, vk.numPublicInputs), true);
+                };
+                return await runInDirectory(this.config.bbWorkingDirectory, operation);
+            }
+            /**
+             * Returns the verification key data for a circuit, will generate and cache it if not cached internally
+             * @param circuitType - The type of circuit for which the verification key is required
+             * @returns The verification key data
+             */
+            async getVerificationKeyDataForCircuit(circuitType) {
+                let promise = this.verificationKeys.get(circuitType);
+                if (!promise) {
+                    promise = generateKeyForNoirCircuit(this.config.bbBinaryPath, this.config.bbWorkingDirectory, circuitType, ServerCircuitArtifacts[circuitType], 'vk', logger.debug).then(result => {
+                        if (result.status === BB_RESULT.FAILURE) {
+                            throw new Error(`Failed to generate verification key for ${circuitType}, ${result.reason}`);
+                        }
+                        return extractVkData(result.vkPath);
+                    });
+                    this.verificationKeys.set(circuitType, promise);
+                }
+                const vk = await promise;
+                return vk.clone();
+            }
+            /**
+             * Ensures our verification key cache includes the key data located at the specified directory
+             * @param filePath - The directory containing the verification key data files
+             * @param circuitType - The type of circuit to which the verification key corresponds
+             */
+            async updateVerificationKeyAfterProof(filePath, circuitType) {
+                let promise = this.verificationKeys.get(circuitType);
+                if (!promise) {
+                    promise = extractVkData(filePath);
+                    this.verificationKeys.set(circuitType, promise);
+                }
+                return promise;
+            }
+            /**
+             * Parses and returns the proof data stored at the specified directory
+             * @param filePath - The directory containing the proof data
+             * @param circuitType - The type of circuit proven
+             * @returns The proof
+             */
+            async readProofAsFields(filePath, circuitType, proofLength) {
+                const proofFilename = path.join(filePath, PROOF_FILENAME);
+                const proofFieldsFilename = path.join(filePath, PROOF_FIELDS_FILENAME);
+                const [binaryProof, proofString] = await Promise.all([
+                    fs.readFile(proofFilename),
+                    fs.readFile(proofFieldsFilename, { encoding: 'utf-8' }),
+                ]);
+                const json = JSON.parse(proofString);
+                const vkData = await this.verificationKeys.get(circuitType);
+                if (!vkData) {
+                    throw new Error(`Invalid verification key for ${circuitType}`);
+                }
+                const numPublicInputs = CIRCUITS_WITHOUT_AGGREGATION.has(circuitType)
+                    ? vkData.numPublicInputs
+                    : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+                const fieldsWithoutPublicInputs = json.slice(numPublicInputs).map(Fr.fromString);
+                logger.debug(`Circuit type: ${circuitType}, complete proof length: ${json.length}, without public inputs: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`);
+                const proof = new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProof, numPublicInputs), true);
+                if (proof.proof.length !== proofLength) {
+                    throw new Error(`Proof length doesn't match expected length (${proof.proof.length} != ${proofLength})`);
+                }
+                return proof;
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getBaseParityProof_decorators = [trackSpan('BBNativeRollupProver.getBaseParityProof', { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity' })];
+            _getRootParityProof_decorators = [trackSpan('BBNativeRollupProver.getRootParityProof', { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity' })];
+            _getAvmProof_decorators = [trackSpan('BBNativeRollupProver.getAvmProof', inputs => ({
+                    [Attributes.APP_CIRCUIT_NAME]: inputs.functionName,
+                }))];
+            _getPublicKernelProof_decorators = [trackSpan('BBNativeRollupProver.getPublicKernelProof', kernelReq => ({
+                    [Attributes.PROTOCOL_CIRCUIT_NAME]: mapProtocolArtifactNameToCircuitName(PublicKernelArtifactMapping[kernelReq.type].artifact),
+                }))];
+            __esDecorate(_a, null, _getBaseParityProof_decorators, { kind: "method", name: "getBaseParityProof", static: false, private: false, access: { has: obj => "getBaseParityProof" in obj, get: obj => obj.getBaseParityProof }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _getRootParityProof_decorators, { kind: "method", name: "getRootParityProof", static: false, private: false, access: { has: obj => "getRootParityProof" in obj, get: obj => obj.getRootParityProof }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _getAvmProof_decorators, { kind: "method", name: "getAvmProof", static: false, private: false, access: { has: obj => "getAvmProof" in obj, get: obj => obj.getAvmProof }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _getPublicKernelProof_decorators, { kind: "method", name: "getPublicKernelProof", static: false, private: false, access: { has: obj => "getPublicKernelProof" in obj, get: obj => obj.getPublicKernelProof }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { BBNativeRollupProver };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bb_prover.js","sourceRoot":"","sources":["../../src/prover/bb_prover.ts"],"names":[],"mappings":"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"}