@aztec/bb-prover 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/prover/bb_prover.js

@@ -1,20 +1,27 @@
-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';
+/* 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 { AGGREGATION_OBJECT_LENGTH, AVM_PROOF_LENGTH_IN_FIELDS, IPA_CLAIM_LENGTH, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
 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 { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
+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/server/vks';
 import { NativeACVMSimulator } from '@aztec/simulator/server';
+import { ProvingError } from '@aztec/stdlib/errors';
+import { makeProofAndVerificationKey, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import { Proof, RecursiveProof, makeRecursiveProofFromBinary } from '@aztec/stdlib/proofs';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 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 } from '../bb/execute.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
 import { ProverInstrumentation } from '../instrumentation.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
@@ -25,444 +32,392 @@ const logger = createLogger('bb-prover');
 const SERVER_CIRCUIT_RECURSIVE = true;
 /**
  * Prover implementation that uses barretenberg native proving
- */
-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');
+ */ 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.serializeWithMessagePack().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);
             }
-            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 _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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"}
+            logger.info(`Successfully verified proof from key in ${result.durationMs} ms`);
+        };
+        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, logger);
+    }
+}
+_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);