@aztec/bb-prover 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.76.0

package/dest/prover/bb_prover.js

@@ -1,16 +1,12 @@
-/* eslint-disable require-await */ function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { ProvingError, makeProofAndVerificationKey, makePublicInputsAndRecursiveProof } from '@aztec/circuit-types';
-import { AGGREGATION_OBJECT_LENGTH, AVM_PROOF_LENGTH_IN_FIELDS, Fr, IPA_CLAIM_LENGTH, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, Proof, RECURSIVE_PROOF_LENGTH, RecursiveProof, TUBE_PROOF_LENGTH, makeRecursiveProofFromBinary } from '@aztec/circuits.js';
+import { __esDecorate, __runInitializers } from "tslib";
+/* eslint-disable require-await */
+import { ProvingError, makeProofAndVerificationKey, makePublicInputsAndRecursiveProof, } from '@aztec/circuit-types';
+import { AGGREGATION_OBJECT_LENGTH, AVM_PROOF_LENGTH_IN_FIELDS, Fr, IPA_CLAIM_LENGTH, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, Proof, RECURSIVE_PROOF_LENGTH, RecursiveProof, TUBE_PROOF_LENGTH, makeRecursiveProofFromBinary, } from '@aztec/circuits.js';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { Timer } from '@aztec/foundation/timer';
-import { ServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap, convertBlockRootRollupInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPrivateBaseRollupInputsToWitnessMap, convertPrivateBaseRollupOutputsFromWitnessMap, convertPublicBaseRollupInputsToWitnessMap, convertPublicBaseRollupOutputsFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertSingleTxBlockRootRollupInputsToWitnessMap, convertSingleTxBlockRootRollupOutputsFromWitnessMap } from '@aztec/noir-protocol-circuits-types/server';
+import { ServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap, convertBlockRootRollupInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPrivateBaseRollupInputsToWitnessMap, convertPrivateBaseRollupOutputsFromWitnessMap, convertPublicBaseRollupInputsToWitnessMap, convertPublicBaseRollupOutputsFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertSingleTxBlockRootRollupInputsToWitnessMap, convertSingleTxBlockRootRollupOutputsFromWitnessMap, } from '@aztec/noir-protocol-circuits-types/server';
 import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
 import { NativeACVMSimulator } from '@aztec/simulator/server';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
@@ -18,7 +14,7 @@ import { assert } from 'console';
 import crypto from 'crypto';
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { BB_RESULT, PROOF_FIELDS_FILENAME, PROOF_FILENAME, VK_FILENAME, generateAvmProof, generateProof, generateTubeProof, verifyAvmProof, verifyProof, writeProofAsFields } from '../bb/execute.js';
+import { BB_RESULT, PROOF_FIELDS_FILENAME, PROOF_FILENAME, VK_FILENAME, generateAvmProof, generateProof, generateTubeProof, verifyAvmProof, verifyProof, writeProofAsFields, } from '../bb/execute.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
 import { ProverInstrumentation } from '../instrumentation.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
@@ -29,426 +25,444 @@ const logger = createLogger('bb-prover');
 const SERVER_CIRCUIT_RECURSIVE = true;
 /**
  * Prover implementation that uses barretenberg native proving
- */ export class BBNativeRollupProver {
-    config;
-    instrumentation;
-    constructor(config, telemetry){
-        this.config = config;
-        this.instrumentation = new ProverInstrumentation(telemetry, 'BBNativeRollupProver');
-    }
-    get tracer() {
-        return this.instrumentation.tracer;
-    }
-    static async new(config, telemetry = getTelemetryClient()) {
-        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, telemetry);
-    }
-    /**
-   * 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 = this.getVerificationKeyDataForCircuit('BaseParityArtifact');
-        await this.verifyProof('BaseParityArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * 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 = this.getVerificationKeyDataForCircuit('RootParityArtifact');
-        await this.verifyProof('RootParityArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * 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.binaryProof, proofAndVk.verificationKey);
-        return proofAndVk;
-    }
-    /**
-   * Simulates the base rollup circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getPrivateBaseRollupProof(inputs) {
-        const artifactName = 'PrivateBaseRollupArtifact';
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPrivateBaseRollupInputsToWitnessMap, convertPrivateBaseRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
-        await this.verifyProof(artifactName, 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 getPublicBaseRollupProof(inputs) {
-        const artifactName = 'PublicBaseRollupArtifact';
-        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPublicBaseRollupInputsToWitnessMap, convertPublicBaseRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
-        await this.verifyProof(artifactName, 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_ROLLUP_HONK_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
-        await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the block root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootRollupInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
-        await this.verifyProof('BlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    async getSingleTxBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'SingleTxBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSingleTxBlockRootRollupInputsToWitnessMap, convertSingleTxBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
-        await this.verifyProof('SingleTxBlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the empty block root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getEmptyBlockRootRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'EmptyBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
-        await this.verifyProof('EmptyBlockRootRollupArtifact', proof.binaryProof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
-    }
-    /**
-   * Simulates the block merge rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */ async getBlockMergeRollupProof(input) {
-        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BlockMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap);
-        const verificationKey = this.getVerificationKeyDataForCircuit('BlockMergeRollupArtifact');
-        await this.verifyProof('BlockMergeRollupArtifact', 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 = this.getVerificationKeyDataForCircuit('RootRollupArtifact');
-        await this.verifyProof('RootRollupArtifact', proof);
-        return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, 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.executeProtocolCircuit(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.info(`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'), SERVER_CIRCUIT_RECURSIVE, outputWitnessFile, getUltraHonkFlavorForCircuit(circuitType), logger.debug);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
-            throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
-        }
-        return {
-            circuitOutput: output,
-            provingResult
-        };
-    }
-    async createProof(input, circuitType, convertInput, convertOutput) {
-        const operation = async (bbWorkingDirectory)=>{
-            const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
-            // Read the binary proof
-            const rawProof = await fs.readFile(`${provingResult.proofPath}/${PROOF_FILENAME}`);
-            const vkData = this.getVerificationKeyDataForCircuit(circuitType);
-            const proof = new Proof(rawProof, vkData.numPublicInputs);
-            const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
-            this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
-            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 this.runInDirectory(operation);
-    }
-    async generateAvmProofWithBB(input, workingDirectory) {
-        logger.info(`Proving avm-circuit for ${input.functionName}...`);
-        const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate AVM proof for ${input.functionName}: ${provingResult.reason}`);
-            throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
-        }
-        return provingResult;
-    }
-    async generateTubeProofWithBB(bbWorkingDirectory, input) {
-        logger.debug(`Proving tube...`);
-        const hasher = crypto.createHash('sha256');
-        hasher.update(input.toBuffer());
-        await writeToOutputDirectory(input.clientIVCData, bbWorkingDirectory);
-        const provingResult = await generateTubeProof(this.config.bbBinaryPath, bbWorkingDirectory, logger.verbose);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            logger.error(`Failed to generate proof for tube circuit: ${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);
-            // 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 extractAvmVkData(provingResult.vkPath);
-            const avmProof = await this.readAvmProofAsFields(provingResult.proofPath, verificationKey);
-            const circuitType = 'avm-circuit';
-            const appCircuitName = 'unknown';
-            this.instrumentation.recordAvmDuration('provingDuration', appCircuitName, provingResult.durationMs);
-            this.instrumentation.recordAvmSize('proofSize', appCircuitName, avmProof.binaryProof.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: avmProof.binaryProof.buffer.length,
-                eventName: 'circuit-proving',
-                inputSize: input.toBuffer().length,
-                circuitSize: verificationKey.circuitSize,
-                numPublicInputs: verificationKey.numPublicInputs
-            });
-            return makeProofAndVerificationKey(avmProof, verificationKey);
-        };
-        return await this.runInDirectory(operation);
-    }
-    async getTubeProof(input) {
-        const operation = async (bbWorkingDirectory)=>{
-            logger.debug(`createTubeProof: ${bbWorkingDirectory}`);
-            const provingResult = await this.generateTubeProofWithBB(bbWorkingDirectory, input);
-            // Read the proof as fields
-            // TODO(AD): this is the only remaining use of extractVkData.
-            const tubeVK = await extractVkData(provingResult.vkPath);
-            const tubeProof = await this.readProofAsFields(provingResult.proofPath, tubeVK, TUBE_PROOF_LENGTH);
-            this.instrumentation.recordDuration('provingDuration', 'tubeCircuit', provingResult.durationMs);
-            this.instrumentation.recordSize('proofSize', 'tubeCircuit', tubeProof.binaryProof.buffer.length);
-            this.instrumentation.recordSize('circuitPublicInputCount', 'tubeCircuit', tubeVK.numPublicInputs);
-            this.instrumentation.recordSize('circuitSize', 'tubeCircuit', tubeVK.circuitSize);
-            // Sanity check the tube proof (can be removed later)
-            await this.verifyWithKey('ultra_rollup_honk', tubeVK, tubeProof.binaryProof);
-            logger.info(`Generated proof for tubeCircuit in ${Math.ceil(provingResult.durationMs)} ms, size: ${tubeProof.proof.length} fields`);
-            return makeProofAndVerificationKey(tubeProof, tubeVK);
-        };
-        return await this.runInDirectory(operation);
-    }
-    /**
-   * Executes a circuit and returns its 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) {
-        // this probably is gonna need to call client ivc
-        const operation = async (bbWorkingDirectory)=>{
-            const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
-            const vkData = this.getVerificationKeyDataForCircuit(circuitType);
-            // Read the proof as fields
-            const proof = await this.readProofAsFields(provingResult.proofPath, vkData, proofLength);
-            const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
-            this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.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`, {
-                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 this.runInDirectory(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 = this.getVerificationKeyDataForCircuit(circuitType);
-        return await this.verifyWithKey(getUltraHonkFlavorForCircuit(circuitType), verificationKey, proof);
-    }
-    async verifyAvmProof(proof, verificationKey) {
-        return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath)=>verifyAvmProof(this.config.bbBinaryPath, proofPath, vkPath, logger));
-    }
-    async verifyWithKey(flavor, verificationKey, proof) {
-        return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath)=>verifyProof(this.config.bbBinaryPath, proofPath, vkPath, flavor, logger));
-    }
-    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 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);
+ */
+let BBNativeRollupProver = (() => {
+    var _a;
+    let _instanceExtraInitializers = [];
+    let _getBaseParityProof_decorators;
+    let _getRootParityProof_decorators;
+    let _getAvmProof_decorators;
+    return _a = class BBNativeRollupProver {
+            constructor(config, telemetry) {
+                this.config = (__runInitializers(this, _instanceExtraInitializers), config);
+                this.instrumentation = new ProverInstrumentation(telemetry, 'BBNativeRollupProver');
             }
-            logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
-        };
-        await this.runInDirectory(operation);
-    }
-    /**
-   * 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 - IPA_CLAIM_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 ProvingError(errorMessage, result, result.retry);
+            get tracer() {
+                return this.instrumentation.tracer;
             }
-            const proofString = await fs.readFile(path.join(bbWorkingDirectory, PROOF_FIELDS_FILENAME), {
-                encoding: 'utf-8'
-            });
-            const json = JSON.parse(proofString);
-            const fields = json.slice(0, 3).map(Fr.fromHexString).concat(json.slice(3 + numPublicInputs).map(Fr.fromHexString));
-            return new RecursiveProof(fields, new Proof(proof.binaryProof.buffer, vk.numPublicInputs), true, NESTED_RECURSIVE_PROOF_LENGTH);
-        };
-        return await this.runInDirectory(operation);
-    }
-    /**
-   * Returns the verification key data for a circuit.
-   * @param circuitType - The type of circuit for which the verification key is required
-   * @returns The verification key data
-   */ getVerificationKeyDataForCircuit(circuitType) {
-        const vk = ServerCircuitVks[circuitType];
-        if (vk === undefined) {
-            throw new Error('Could not find VK for server artifact ' + circuitType);
-        }
-        return vk;
-    }
-    async readProofAsFields(filePath, vkData, 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);
-        let numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
-        if (proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH) {
-            numPublicInputs -= IPA_CLAIM_LENGTH;
-        }
-        assert(json.length - numPublicInputs == proofLength, 'Proof length mismatch');
-        const fieldsWithoutPublicInputs = json.slice(0, 3).map(Fr.fromHexString).concat(json.slice(3 + numPublicInputs).map(Fr.fromHexString));
-        logger.debug(`Circuit path: ${filePath}, complete proof length: ${json.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`);
-        return new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProof, numPublicInputs), true, proofLength);
-    }
-    async readAvmProofAsFields(proofFilename, vkData) {
-        const rawProof = await fs.readFile(proofFilename);
-        const reader = BufferReader.asReader(rawProof);
-        const fields = reader.readArray(rawProof.length / Fr.SIZE_IN_BYTES, Fr);
-        const fieldsWithoutPublicCols = fields.slice(-1 * AVM_PROOF_LENGTH_IN_FIELDS);
-        const proof = new Proof(rawProof, vkData.numPublicInputs);
-        return new RecursiveProof(fieldsWithoutPublicCols, proof, true, AVM_PROOF_LENGTH_IN_FIELDS);
-    }
-    runInDirectory(fn) {
-        return runInDirectory(this.config.bbWorkingDirectory, (dir)=>fn(dir).catch((err)=>{
-                logger.error(`Error running operation at ${dir}: ${err}`);
-                throw err;
-            }), this.config.bbSkipCleanup);
-    }
-}
-_ts_decorate([
-    trackSpan('BBNativeRollupProver.getBaseParityProof', {
-        [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity'
-    })
-], BBNativeRollupProver.prototype, "getBaseParityProof", null);
-_ts_decorate([
-    trackSpan('BBNativeRollupProver.getRootParityProof', {
-        [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity'
-    })
-], BBNativeRollupProver.prototype, "getRootParityProof", null);
-_ts_decorate([
-    trackSpan('BBNativeRollupProver.getAvmProof', (inputs)=>({
-            [Attributes.APP_CIRCUIT_NAME]: inputs.functionName
-        }))
-], BBNativeRollupProver.prototype, "getAvmProof", null);
+            static async new(config, telemetry = getTelemetryClient()) {
+                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);
+            }
+            /**
+             * 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 = this.getVerificationKeyDataForCircuit('BaseParityArtifact');
+                await this.verifyProof('BaseParityArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * 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 = this.getVerificationKeyDataForCircuit('RootParityArtifact');
+                await this.verifyProof('RootParityArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * 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.binaryProof, proofAndVk.verificationKey);
+                return proofAndVk;
+            }
+            /**
+             * Simulates the base rollup circuit from its inputs.
+             * @param inputs - Inputs to the circuit.
+             * @returns The public inputs as outputs of the simulation.
+             */
+            async getPrivateBaseRollupProof(inputs) {
+                const artifactName = 'PrivateBaseRollupArtifact';
+                const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPrivateBaseRollupInputsToWitnessMap, convertPrivateBaseRollupOutputsFromWitnessMap);
+                const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
+                await this.verifyProof(artifactName, 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 getPublicBaseRollupProof(inputs) {
+                const artifactName = 'PublicBaseRollupArtifact';
+                const { circuitOutput, proof } = await this.createRecursiveProof(inputs, artifactName, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertPublicBaseRollupInputsToWitnessMap, convertPublicBaseRollupOutputsFromWitnessMap);
+                const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
+                await this.verifyProof(artifactName, 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_ROLLUP_HONK_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap);
+                const verificationKey = this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
+                await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * Simulates the block root rollup circuit from its inputs.
+             * @param input - Inputs to the circuit.
+             * @returns The public inputs as outputs of the simulation.
+             */
+            async getBlockRootRollupProof(input) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockRootRollupInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap);
+                const verificationKey = this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
+                await this.verifyProof('BlockRootRollupArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            async getSingleTxBlockRootRollupProof(input) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(input, 'SingleTxBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSingleTxBlockRootRollupInputsToWitnessMap, convertSingleTxBlockRootRollupOutputsFromWitnessMap);
+                const verificationKey = this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
+                await this.verifyProof('SingleTxBlockRootRollupArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * Simulates the empty block root rollup circuit from its inputs.
+             * @param input - Inputs to the circuit.
+             * @returns The public inputs as outputs of the simulation.
+             */
+            async getEmptyBlockRootRollupProof(input) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(input, 'EmptyBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap);
+                const verificationKey = this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
+                await this.verifyProof('EmptyBlockRootRollupArtifact', proof.binaryProof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+            }
+            /**
+             * Simulates the block merge rollup circuit from its inputs.
+             * @param input - Inputs to the circuit.
+             * @returns The public inputs as outputs of the simulation.
+             */
+            async getBlockMergeRollupProof(input) {
+                const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BlockMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap);
+                const verificationKey = this.getVerificationKeyDataForCircuit('BlockMergeRollupArtifact');
+                await this.verifyProof('BlockMergeRollupArtifact', 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 = this.getVerificationKeyDataForCircuit('RootRollupArtifact');
+                await this.verifyProof('RootRollupArtifact', proof);
+                return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, 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.executeProtocolCircuit(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.info(`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'), SERVER_CIRCUIT_RECURSIVE, outputWitnessFile, getUltraHonkFlavorForCircuit(circuitType), logger.debug);
+                if (provingResult.status === BB_RESULT.FAILURE) {
+                    logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
+                    throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
+                }
+                return {
+                    circuitOutput: output,
+                    provingResult,
+                };
+            }
+            async createProof(input, circuitType, convertInput, convertOutput) {
+                const operation = async (bbWorkingDirectory) => {
+                    const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+                    // Read the binary proof
+                    const rawProof = await fs.readFile(`${provingResult.proofPath}/${PROOF_FILENAME}`);
+                    const vkData = this.getVerificationKeyDataForCircuit(circuitType);
+                    const proof = new Proof(rawProof, vkData.numPublicInputs);
+                    const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
+                    this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs);
+                    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 this.runInDirectory(operation);
+            }
+            async generateAvmProofWithBB(input, workingDirectory) {
+                logger.info(`Proving avm-circuit for ${input.functionName}...`);
+                const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger);
+                if (provingResult.status === BB_RESULT.FAILURE) {
+                    logger.error(`Failed to generate AVM proof for ${input.functionName}: ${provingResult.reason}`);
+                    throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
+                }
+                return provingResult;
+            }
+            async generateTubeProofWithBB(bbWorkingDirectory, input) {
+                logger.debug(`Proving tube...`);
+                const hasher = crypto.createHash('sha256');
+                hasher.update(input.toBuffer());
+                await writeToOutputDirectory(input.clientIVCData, bbWorkingDirectory);
+                const provingResult = await generateTubeProof(this.config.bbBinaryPath, bbWorkingDirectory, logger.verbose);
+                if (provingResult.status === BB_RESULT.FAILURE) {
+                    logger.error(`Failed to generate proof for tube circuit: ${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);
+                    // 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 extractAvmVkData(provingResult.vkPath);
+                    const avmProof = await this.readAvmProofAsFields(provingResult.proofPath, verificationKey);
+                    const circuitType = 'avm-circuit';
+                    const appCircuitName = 'unknown';
+                    this.instrumentation.recordAvmDuration('provingDuration', appCircuitName, provingResult.durationMs);
+                    this.instrumentation.recordAvmSize('proofSize', appCircuitName, avmProof.binaryProof.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: avmProof.binaryProof.buffer.length,
+                        eventName: 'circuit-proving',
+                        inputSize: input.toBuffer().length,
+                        circuitSize: verificationKey.circuitSize, // FIX: wrong in VK
+                        numPublicInputs: verificationKey.numPublicInputs, // FIX: wrong in VK
+                    });
+                    return makeProofAndVerificationKey(avmProof, verificationKey);
+                };
+                return await this.runInDirectory(operation);
+            }
+            async getTubeProof(input) {
+                const operation = async (bbWorkingDirectory) => {
+                    logger.debug(`createTubeProof: ${bbWorkingDirectory}`);
+                    const provingResult = await this.generateTubeProofWithBB(bbWorkingDirectory, input);
+                    // Read the proof as fields
+                    // TODO(AD): this is the only remaining use of extractVkData.
+                    const tubeVK = await extractVkData(provingResult.vkPath);
+                    const tubeProof = await this.readProofAsFields(provingResult.proofPath, tubeVK, TUBE_PROOF_LENGTH);
+                    this.instrumentation.recordDuration('provingDuration', 'tubeCircuit', provingResult.durationMs);
+                    this.instrumentation.recordSize('proofSize', 'tubeCircuit', tubeProof.binaryProof.buffer.length);
+                    this.instrumentation.recordSize('circuitPublicInputCount', 'tubeCircuit', tubeVK.numPublicInputs);
+                    this.instrumentation.recordSize('circuitSize', 'tubeCircuit', tubeVK.circuitSize);
+                    // Sanity check the tube proof (can be removed later)
+                    await this.verifyWithKey('ultra_rollup_honk', tubeVK, tubeProof.binaryProof);
+                    logger.info(`Generated proof for tubeCircuit in ${Math.ceil(provingResult.durationMs)} ms, size: ${tubeProof.proof.length} fields`);
+                    return makeProofAndVerificationKey(tubeProof, tubeVK);
+                };
+                return await this.runInDirectory(operation);
+            }
+            /**
+             * Executes a circuit and returns its 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) {
+                // this probably is gonna need to call client ivc
+                const operation = async (bbWorkingDirectory) => {
+                    const { provingResult, circuitOutput: output } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+                    const vkData = this.getVerificationKeyDataForCircuit(circuitType);
+                    // Read the proof as fields
+                    const proof = await this.readProofAsFields(provingResult.proofPath, vkData, proofLength);
+                    const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
+                    this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.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`, {
+                        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 this.runInDirectory(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 = this.getVerificationKeyDataForCircuit(circuitType);
+                return await this.verifyWithKey(getUltraHonkFlavorForCircuit(circuitType), verificationKey, proof);
+            }
+            async verifyAvmProof(proof, verificationKey) {
+                return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) => verifyAvmProof(this.config.bbBinaryPath, proofPath, vkPath, logger));
+            }
+            async verifyWithKey(flavor, verificationKey, proof) {
+                return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) => verifyProof(this.config.bbBinaryPath, proofPath, vkPath, flavor, logger));
+            }
+            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 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);
+                    }
+                    logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
+                };
+                await this.runInDirectory(operation);
+            }
+            /**
+             * 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, // WORKTODO
+            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 - IPA_CLAIM_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 ProvingError(errorMessage, result, result.retry);
+                    }
+                    const proofString = await fs.readFile(path.join(bbWorkingDirectory, PROOF_FIELDS_FILENAME), {
+                        encoding: 'utf-8',
+                    });
+                    const json = JSON.parse(proofString);
+                    const fields = json
+                        .slice(0, 3)
+                        .map(Fr.fromHexString)
+                        .concat(json.slice(3 + numPublicInputs).map(Fr.fromHexString));
+                    return new RecursiveProof(fields, new Proof(proof.binaryProof.buffer, vk.numPublicInputs), true, NESTED_RECURSIVE_PROOF_LENGTH);
+                };
+                return await this.runInDirectory(operation);
+            }
+            /**
+             * Returns the verification key data for a circuit.
+             * @param circuitType - The type of circuit for which the verification key is required
+             * @returns The verification key data
+             */
+            getVerificationKeyDataForCircuit(circuitType) {
+                const vk = ServerCircuitVks[circuitType];
+                if (vk === undefined) {
+                    throw new Error('Could not find VK for server artifact ' + circuitType);
+                }
+                return vk;
+            }
+            async readProofAsFields(filePath, vkData, 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);
+                let numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+                if (proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH) {
+                    numPublicInputs -= IPA_CLAIM_LENGTH;
+                }
+                assert(json.length - numPublicInputs == proofLength, 'Proof length mismatch');
+                const fieldsWithoutPublicInputs = json
+                    .slice(0, 3)
+                    .map(Fr.fromHexString)
+                    .concat(json.slice(3 + numPublicInputs).map(Fr.fromHexString));
+                logger.debug(`Circuit path: ${filePath}, complete proof length: ${json.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`);
+                return new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProof, numPublicInputs), true, proofLength);
+            }
+            async readAvmProofAsFields(proofFilename, vkData) {
+                const rawProof = await fs.readFile(proofFilename);
+                const reader = BufferReader.asReader(rawProof);
+                const fields = reader.readArray(rawProof.length / Fr.SIZE_IN_BYTES, Fr);
+                const fieldsWithoutPublicCols = fields.slice(-1 * AVM_PROOF_LENGTH_IN_FIELDS);
+                const proof = new Proof(rawProof, vkData.numPublicInputs);
+                return new RecursiveProof(fieldsWithoutPublicCols, proof, true, AVM_PROOF_LENGTH_IN_FIELDS);
+            }
+            runInDirectory(fn) {
+                return runInDirectory(this.config.bbWorkingDirectory, (dir) => fn(dir).catch(err => {
+                    logger.error(`Error running operation at ${dir}: ${err}`);
+                    throw err;
+                }), this.config.bbSkipCleanup);
+            }
+        },
+        (() => {
+            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,
+                }))];
+            __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);
+            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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"}