@aztec/bb-prover 0.40.1 → 0.42.0

package/dest/prover/bb_prover.js

@@ -1,18 +1,23 @@
 /* eslint-disable require-await */
-import { PublicKernelType, makePublicInputsAndProof, } from '@aztec/circuit-types';
-import { Fr, Proof, RecursiveProof, RollupTypes, RootParityInput, VerificationKeyAsFields, } from '@aztec/circuits.js';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { PublicKernelType, makePublicInputsAndRecursiveProof, } from '@aztec/circuit-types';
+import { AGGREGATION_OBJECT_LENGTH, EmptyNestedCircuitInputs, EmptyNestedData, Fr, NESTED_RECURSIVE_PROOF_LENGTH, PrivateKernelEmptyInputs, Proof, RECURSIVE_PROOF_LENGTH, RecursiveProof, RootParityInput, makeRecursiveProofFromBinary, } from '@aztec/circuits.js';
+import { runInDirectory } from '@aztec/foundation/fs';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBaseRollupInputsToWitnessMap, convertBaseRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPublicTailInputsToWitnessMap, convertPublicTailOutputFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, } from '@aztec/noir-protocol-circuits-types';
+import { EmptyNestedArtifact, ServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBaseRollupInputsToWitnessMap, convertBaseRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertPrivateKernelEmptyInputsToWitnessMap, convertPrivateKernelEmptyOutputsFromWitnessMap, convertPublicTailInputsToWitnessMap, convertPublicTailOutputFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, } from '@aztec/noir-protocol-circuits-types';
 import { NativeACVMSimulator } from '@aztec/simulator';
+import { abiEncode } from '@noir-lang/noirc_abi';
 import * as fs from 'fs/promises';
-import { BB_RESULT, PROOF_FIELDS_FILENAME, PROOF_FILENAME, VK_FIELDS_FILENAME, VK_FILENAME, generateKeyForNoirCircuit, generateProof, verifyProof, } from '../bb/execute.js';
+import * as path from 'path';
+import { BB_RESULT, PROOF_FIELDS_FILENAME, PROOF_FILENAME, VK_FILENAME, generateAvmProof, generateKeyForNoirCircuit, generateProof, verifyAvmProof, verifyProof, writeProofAsFields, } from '../bb/execute.js';
 import { PublicKernelArtifactMapping } from '../mappings/mappings.js';
-import { circuitTypeToCircuitName, emitCircuitProvingStats, emitCircuitWitnessGenerationStats } from '../stats.js';
-import { AGGREGATION_OBJECT_SIZE, CIRCUIT_PUBLIC_INPUTS_INDEX, CIRCUIT_RECURSIVE_INDEX, CIRCUIT_SIZE_INDEX, } from './verification_key_data.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+import { extractVkData } from '../verification_key/verification_key_data.js';
 const logger = createDebugLogger('aztec:bb-prover');
-const CIRCUITS_WITHOUT_AGGREGATION = new Set(['BaseParityArtifact']);
+const CIRCUITS_WITHOUT_AGGREGATION = new Set([
+    'BaseParityArtifact',
+    'EmptyNestedArtifact',
+]);
 /**
  * Prover implementation that uses barretenberg native proving
  */
@@ -36,11 +41,10 @@ export class BBNativeRollupProver {
      * @returns The public inputs of the parity circuit.
      */
     async getBaseParityProof(inputs) {
-        const witnessMap = convertBaseParityInputsToWitnessMap(inputs);
-        const [circuitOutput, proof] = await this.createRecursiveProof(witnessMap, 'BaseParityArtifact', convertBaseParityOutputsFromWitnessMap);
+        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'BaseParityArtifact', RECURSIVE_PROOF_LENGTH, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap);
         const verificationKey = await this.getVerificationKeyDataForCircuit('BaseParityArtifact');
-        const vk = new VerificationKeyAsFields(verificationKey.keyAsFields, verificationKey.hash);
-        return new RootParityInput(proof, vk, circuitOutput);
+        await this.verifyProof('BaseParityArtifact', proof.binaryProof);
+        return new RootParityInput(proof, verificationKey.keyAsFields, circuitOutput);
     }
     /**
      * Simulates the root parity circuit from its inputs.
@@ -48,11 +52,20 @@ export class BBNativeRollupProver {
      * @returns The public inputs of the parity circuit.
      */
     async getRootParityProof(inputs) {
-        const witnessMap = convertRootParityInputsToWitnessMap(inputs);
-        const [circuitOutput, proof] = await this.createRecursiveProof(witnessMap, 'RootParityArtifact', convertRootParityOutputsFromWitnessMap);
+        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'RootParityArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap);
         const verificationKey = await this.getVerificationKeyDataForCircuit('RootParityArtifact');
-        const vk = new VerificationKeyAsFields(verificationKey.keyAsFields, verificationKey.hash);
-        return new RootParityInput(proof, vk, circuitOutput);
+        await this.verifyProof('RootParityArtifact', proof.binaryProof);
+        return new RootParityInput(proof, verificationKey.keyAsFields, circuitOutput);
+    }
+    /**
+     * Creates an AVM proof and verifies it.
+     * @param inputs - The inputs to the AVM circuit.
+     * @returns The proof.
+     */
+    async getAvmProof(inputs) {
+        const proofAndVk = await this.createAvmProof(inputs);
+        await this.verifyAvmProof(proofAndVk.proof, proofAndVk.verificationKey);
+        return proofAndVk;
     }
     /**
      * Requests that a public kernel circuit be executed and the proof generated
@@ -64,10 +77,13 @@ export class BBNativeRollupProver {
         if (kernelOps === undefined) {
             throw new Error(`Unable to prove kernel type ${PublicKernelType[kernelRequest.type]}`);
         }
-        const witnessMap = kernelOps.convertInputs(kernelRequest.inputs);
-        const [outputWitness, proof] = await this.createProof(witnessMap, kernelOps.artifact);
-        const result = kernelOps.convertOutputs(outputWitness);
-        return makePublicInputsAndProof(result, proof);
+        // We may need to convert the recursive proof into fields format
+        kernelRequest.inputs.previousKernel.proof = await this.ensureValidProof(kernelRequest.inputs.previousKernel.proof, kernelOps.artifact, kernelRequest.inputs.previousKernel.vk);
+        await this.verifyWithKey(kernelRequest.inputs.previousKernel.vk, kernelRequest.inputs.previousKernel.proof.binaryProof);
+        const { circuitOutput, proof } = await this.createRecursiveProof(kernelRequest.inputs, kernelOps.artifact, NESTED_RECURSIVE_PROOF_LENGTH, kernelOps.convertInputs, kernelOps.convertOutputs);
+        const verificationKey = await this.getVerificationKeyDataForCircuit(kernelOps.artifact);
+        await this.verifyProof(kernelOps.artifact, proof.binaryProof);
+        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
     }
     /**
      * Requests that the public kernel tail circuit be executed and the proof generated
@@ -75,10 +91,10 @@ export class BBNativeRollupProver {
      * @returns The requested circuit's public inputs and proof
      */
     async getPublicTailProof(kernelRequest) {
-        const witnessMap = convertPublicTailInputsToWitnessMap(kernelRequest.inputs);
-        const [outputWitness, proof] = await this.createProof(witnessMap, 'PublicKernelTailArtifact');
-        const result = convertPublicTailOutputFromWitnessMap(outputWitness);
-        return makePublicInputsAndProof(result, proof);
+        const { circuitOutput, proof } = await this.createRecursiveProof(kernelRequest.inputs, 'PublicKernelTailArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertPublicTailInputsToWitnessMap, convertPublicTailOutputFromWitnessMap);
+        const verificationKey = await this.getVerificationKeyDataForCircuit('PublicKernelTailArtifact');
+        await this.verifyProof('PublicKernelTailArtifact', proof.binaryProof);
+        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
     }
     /**
      * Simulates the base rollup circuit from its inputs.
@@ -86,10 +102,12 @@ export class BBNativeRollupProver {
      * @returns The public inputs as outputs of the simulation.
      */
     async getBaseRollupProof(input) {
-        const witnessMap = convertBaseRollupInputsToWitnessMap(input);
-        const [outputWitness, proof] = await this.createProof(witnessMap, 'BaseRollupArtifact');
-        const result = convertBaseRollupOutputsFromWitnessMap(outputWitness);
-        return makePublicInputsAndProof(result, proof);
+        // We may need to convert the recursive proof into fields format
+        input.kernelData.proof = await this.ensureValidProof(input.kernelData.proof, 'BaseRollupArtifact', input.kernelData.vk);
+        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'BaseRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertBaseRollupInputsToWitnessMap, convertBaseRollupOutputsFromWitnessMap);
+        const verificationKey = await this.getVerificationKeyDataForCircuit('BaseRollupArtifact');
+        await this.verifyProof('BaseRollupArtifact', proof.binaryProof);
+        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
     }
     /**
      * Simulates the merge rollup circuit from its inputs.
@@ -97,12 +115,10 @@ export class BBNativeRollupProver {
      * @returns The public inputs as outputs of the simulation.
      */
     async getMergeRollupProof(input) {
-        // verify both inputs
-        await Promise.all(input.previousRollupData.map(prev => this.verifyPreviousRollupProof(prev)));
-        const witnessMap = convertMergeRollupInputsToWitnessMap(input);
-        const [outputWitness, proof] = await this.createProof(witnessMap, 'MergeRollupArtifact');
-        const result = convertMergeRollupOutputsFromWitnessMap(outputWitness);
-        return makePublicInputsAndProof(result, proof);
+        const { circuitOutput, proof } = await this.createRecursiveProof(input, 'MergeRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap);
+        const verificationKey = await this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
+        await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
+        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
     }
     /**
      * Simulates the root rollup circuit from its inputs.
@@ -110,89 +126,150 @@ export class BBNativeRollupProver {
      * @returns The public inputs as outputs of the simulation.
      */
     async getRootRollupProof(input) {
-        // verify the inputs
-        await Promise.all(input.previousRollupData.map(prev => this.verifyPreviousRollupProof(prev)));
-        const witnessMap = convertRootRollupInputsToWitnessMap(input);
-        const [outputWitness, proof] = await this.createProof(witnessMap, 'RootRollupArtifact');
+        const { circuitOutput, proof } = await this.createProof(input, 'RootRollupArtifact', convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap);
+        const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
+        const verificationKey = await this.getVerificationKeyDataForCircuit('RootRollupArtifact');
         await this.verifyProof('RootRollupArtifact', proof);
-        const result = convertRootRollupOutputsFromWitnessMap(outputWitness);
-        return makePublicInputsAndProof(result, proof);
+        return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, verificationKey);
+    }
+    async getEmptyPrivateKernelProof(inputs) {
+        const emptyNested = await this.getEmptyNestedProof();
+        const emptyPrivateKernelProof = await this.getEmptyPrivateKernelProofFromEmptyNested(PrivateKernelEmptyInputs.from({
+            ...inputs,
+            emptyNested,
+        }));
+        return emptyPrivateKernelProof;
+    }
+    async getEmptyNestedProof() {
+        const inputs = new EmptyNestedCircuitInputs();
+        const { proof } = await this.createRecursiveProof(inputs, 'EmptyNestedArtifact', RECURSIVE_PROOF_LENGTH, (nothing) => abiEncode(EmptyNestedArtifact.abi, { _inputs: nothing }), () => new EmptyNestedCircuitInputs());
+        const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyNestedArtifact');
+        await this.verifyProof('EmptyNestedArtifact', proof.binaryProof);
+        return new EmptyNestedData(proof, verificationKey.keyAsFields);
+    }
+    async getEmptyPrivateKernelProofFromEmptyNested(inputs) {
+        const { circuitOutput, proof } = await this.createRecursiveProof(inputs, 'PrivateKernelEmptyArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertPrivateKernelEmptyInputsToWitnessMap, convertPrivateKernelEmptyOutputsFromWitnessMap);
+        const verificationKey = await this.getVerificationKeyDataForCircuit('PrivateKernelEmptyArtifact');
+        await this.verifyProof('PrivateKernelEmptyArtifact', proof.binaryProof);
+        return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
     }
-    // TODO(@PhilWindle): Delete when no longer required
-    async createProof(witnessMap, circuitType) {
-        // Create random directory to be used for temp files
-        const bbWorkingDirectory = `${this.config.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
-        await fs.mkdir(bbWorkingDirectory, { recursive: true });
-        await fs.access(bbWorkingDirectory);
+    async generateProofWithBB(input, circuitType, convertInput, convertOutput, workingDirectory) {
         // Have the ACVM write the partial witness here
-        const outputWitnessFile = `${bbWorkingDirectory}/partial-witness.gz`;
+        const outputWitnessFile = path.join(workingDirectory, 'partial-witness.gz');
         // Generate the partial witness using the ACVM
         // A further temp directory will be created beneath ours and then cleaned up after the partial witness has been copied to our specified location
         const simulator = new NativeACVMSimulator(this.config.acvmWorkingDirectory, this.config.acvmBinaryPath, outputWitnessFile);
         const artifact = ServerCircuitArtifacts[circuitType];
         logger.debug(`Generating witness data for ${circuitType}`);
+        const inputWitness = convertInput(input);
         const timer = new Timer();
-        const outputWitness = await simulator.simulateCircuit(witnessMap, artifact);
-        emitCircuitWitnessGenerationStats(circuitTypeToCircuitName(circuitType), timer.ms(), witnessMap.size * Fr.SIZE_IN_BYTES, outputWitness.size * Fr.SIZE_IN_BYTES, logger);
+        const outputWitness = await simulator.simulateCircuit(inputWitness, artifact);
+        const witnessGenerationDuration = timer.ms();
+        const output = convertOutput(outputWitness);
+        logger.debug(`Generated witness`, {
+            circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+            duration: witnessGenerationDuration,
+            inputSize: input.toBuffer().length,
+            outputSize: output.toBuffer().length,
+            eventName: 'circuit-witness-generation',
+        });
         // Now prove the circuit from the generated witness
         logger.debug(`Proving ${circuitType}...`);
-        const provingResult = await generateProof(this.config.bbBinaryPath, bbWorkingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), outputWitnessFile, logger.debug);
+        const provingResult = await generateProof(this.config.bbBinaryPath, workingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), outputWitnessFile, logger.debug);
         if (provingResult.status === BB_RESULT.FAILURE) {
             logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
             throw new Error(provingResult.reason);
         }
         // Ensure our vk cache is up to date
-        await this.updateVerificationKeyAfterProof(provingResult.vkPath, circuitType);
-        // Read the proof and then cleanup up our temporary directory
-        const proof = await fs.readFile(`${provingResult.proofPath}/${PROOF_FILENAME}`);
-        // does not include reading the proof from disk above because duration comes from the bb wrapper
-        emitCircuitProvingStats(circuitTypeToCircuitName(circuitType), provingResult.duration, witnessMap.size * Fr.SIZE_IN_BYTES, outputWitness.size * Fr.SIZE_IN_BYTES, proof.length, logger);
-        await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
-        logger.info(`Generated proof for ${circuitType} in ${provingResult.duration} ms, size: ${proof.length} fields`);
-        return [outputWitness, new Proof(proof)];
+        const vkData = await this.updateVerificationKeyAfterProof(provingResult.vkPath, circuitType);
+        return {
+            circuitOutput: output,
+            vkData,
+            provingResult,
+        };
+    }
+    async createProof(input, circuitType, convertInput, convertOutput) {
+        const operation = async (bbWorkingDirectory) => {
+            const { provingResult, vkData, circuitOutput: output, } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+            // Read the binary proof
+            const rawProof = await fs.readFile(`${provingResult.proofPath}/${PROOF_FILENAME}`);
+            const proof = new Proof(rawProof, vkData.numPublicInputs);
+            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${proof.buffer.length} bytes`, {
+                circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+                // does not include reading the proof from disk
+                duration: provingResult.duration,
+                proofSize: proof.buffer.length,
+                eventName: 'circuit-proving',
+                // circuitOutput is the partial witness that became the input to the proof
+                inputSize: output.toBuffer().length,
+                circuitSize: vkData.circuitSize,
+                numPublicInputs: vkData.numPublicInputs,
+            });
+            return { circuitOutput: output, proof };
+        };
+        return await runInDirectory(this.config.bbWorkingDirectory, operation);
+    }
+    async generateAvmProofWithBB(input, workingDirectory) {
+        logger.debug(`Proving avm-circuit...`);
+        const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger.debug);
+        if (provingResult.status === BB_RESULT.FAILURE) {
+            logger.error(`Failed to generate proof for avm-circuit: ${provingResult.reason}`);
+            throw new Error(provingResult.reason);
+        }
+        return provingResult;
+    }
+    async createAvmProof(input) {
+        const operation = async (bbWorkingDirectory) => {
+            const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
+            const rawProof = await fs.readFile(provingResult.proofPath);
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6773): this VK data format is wrong.
+            // In particular, the number of public inputs, etc will be wrong.
+            const verificationKey = await extractVkData(provingResult.vkPath);
+            const proof = new Proof(rawProof, verificationKey.numPublicInputs);
+            const circuitType = 'avm-circuit';
+            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${proof.buffer.length} bytes`, {
+                circuitName: circuitType,
+                // does not include reading the proof from disk
+                duration: provingResult.duration,
+                proofSize: proof.buffer.length,
+                eventName: 'circuit-proving',
+                inputSize: input.toBuffer().length,
+                circuitSize: verificationKey.circuitSize,
+                numPublicInputs: verificationKey.numPublicInputs,
+            });
+            return { proof, verificationKey };
+        };
+        return await runInDirectory(this.config.bbWorkingDirectory, operation);
     }
     /**
      * Executes a circuit and returns it's outputs and corresponding proof with embedded aggregation object
      * @param witnessMap - The input witness
      * @param circuitType - The type of circuit to be executed
+     * @param proofLength - The length of the proof to be generated. This is a dummy parameter to aid in type checking
+     * @param convertInput - Function for mapping the input object to a witness map.
      * @param convertOutput - Function for parsing the output witness to it's corresponding object
      * @returns The circuits output object and it's proof
      */
-    async createRecursiveProof(witnessMap, circuitType, convertOutput) {
-        // Create random directory to be used for temp files
-        const bbWorkingDirectory = `${this.config.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
-        await fs.mkdir(bbWorkingDirectory, { recursive: true });
-        await fs.access(bbWorkingDirectory);
-        try {
-            // Have the ACVM write the partial witness here
-            const outputWitnessFile = `${bbWorkingDirectory}/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 timer = new Timer();
-            const outputWitness = await simulator.simulateCircuit(witnessMap, artifact);
-            emitCircuitWitnessGenerationStats(circuitTypeToCircuitName(circuitType), timer.ms(), witnessMap.size * Fr.SIZE_IN_BYTES, outputWitness.size * Fr.SIZE_IN_BYTES, logger);
-            const outputType = convertOutput(outputWitness);
-            // Now prove the circuit from the generated witness
-            logger.debug(`Proving ${circuitType}...`);
-            const provingResult = await generateProof(this.config.bbBinaryPath, bbWorkingDirectory, circuitType, Buffer.from(artifact.bytecode, 'base64'), outputWitnessFile, logger.debug);
-            if (provingResult.status === BB_RESULT.FAILURE) {
-                logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
-                throw new Error(provingResult.reason);
-            }
-            // Ensure our vk cache is up to date
-            await this.updateVerificationKeyAfterProof(provingResult.vkPath, circuitType);
-            // Read the proof and then cleanup up our temporary directory
-            const proof = await this.readProofAsFields(provingResult.proofPath, circuitType);
-            logger.info(`Generated proof for ${circuitType} in ${provingResult.duration} ms, size: ${proof.proof.length} fields`);
-            emitCircuitProvingStats(circuitTypeToCircuitName(circuitType), provingResult.duration, witnessMap.size * Fr.SIZE_IN_BYTES, outputWitness.size * Fr.SIZE_IN_BYTES, proof.binaryProof.buffer.length, logger);
-            return [outputType, proof];
-        }
-        finally {
-            await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
-        }
+    async createRecursiveProof(input, circuitType, proofLength, convertInput, convertOutput) {
+        const operation = async (bbWorkingDirectory) => {
+            const { provingResult, vkData, circuitOutput: output, } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+            // Read the proof as fields
+            const proof = await this.readProofAsFields(provingResult.proofPath, circuitType, proofLength);
+            logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${proof.proof.length} fields`, {
+                circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+                circuitSize: vkData.circuitSize,
+                duration: provingResult.duration,
+                inputSize: output.toBuffer().length,
+                proofSize: proof.binaryProof.buffer.length,
+                eventName: 'circuit-proving',
+                numPublicInputs: vkData.numPublicInputs,
+            });
+            return {
+                circuitOutput: output,
+                proof,
+            };
+        };
+        return await runInDirectory(this.config.bbWorkingDirectory, operation);
     }
     /**
      * Verifies a proof, will generate the verification key if one is not cached internally
@@ -200,25 +277,32 @@ export class BBNativeRollupProver {
      * @param proof - The proof to be verified
      */
     async verifyProof(circuitType, proof) {
-        // Create random directory to be used for temp files
-        const bbWorkingDirectory = `${this.config.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
-        await fs.mkdir(bbWorkingDirectory, { recursive: true });
-        const proofFileName = `${bbWorkingDirectory}/proof`;
-        const verificationKeyPath = `${bbWorkingDirectory}/vk`;
         const verificationKey = await this.getVerificationKeyDataForCircuit(circuitType);
-        logger.debug(`Verifying with key: ${verificationKey.hash.toString()}`);
-        await fs.writeFile(proofFileName, proof.buffer);
-        await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
-        const logFunction = (message) => {
-            logger.debug(`${circuitType} BB out - ${message}`);
+        return await this.verifyWithKey(verificationKey, proof);
+    }
+    async verifyAvmProof(proof, verificationKey) {
+        return await this.verifyWithKeyInternal(proof, verificationKey, verifyAvmProof);
+    }
+    async verifyWithKey(verificationKey, proof) {
+        return await this.verifyWithKeyInternal(proof, verificationKey, verifyProof);
+    }
+    async verifyWithKeyInternal(proof, verificationKey, verificationFunction) {
+        const operation = async (bbWorkingDirectory) => {
+            const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
+            const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
+            await fs.writeFile(proofFileName, proof.buffer);
+            await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+            const logFunction = (message) => {
+                logger.debug(`BB out - ${message}`);
+            };
+            const result = await verificationFunction(this.config.bbBinaryPath, proofFileName, verificationKeyPath, logFunction);
+            if (result.status === BB_RESULT.FAILURE) {
+                const errorMessage = `Failed to verify proof from key!`;
+                throw new Error(errorMessage);
+            }
+            logger.debug(`Successfully verified proof from key in ${result.duration} ms`);
         };
-        const result = await verifyProof(this.config.bbBinaryPath, proofFileName, verificationKeyPath, logFunction);
-        await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
-        if (result.status === BB_RESULT.FAILURE) {
-            const errorMessage = `Failed to verify ${circuitType} proof!`;
-            throw new Error(errorMessage);
-        }
-        logger.info(`Successfully verified ${circuitType} proof in ${result.duration} ms`);
+        await runInDirectory(this.config.bbWorkingDirectory, operation);
     }
     /**
      * Returns the verification key for a circuit, will generate it if not cached internally
@@ -227,14 +311,42 @@ export class BBNativeRollupProver {
      */
     async getVerificationKeyForCircuit(circuitType) {
         const vkData = await this.getVerificationKeyDataForCircuit(circuitType);
-        return new VerificationKeyAsFields(vkData.keyAsFields, vkData.hash);
+        return vkData.clone().keyAsFields;
     }
-    async verifyPreviousRollupProof(previousRollupData) {
-        const proof = previousRollupData.proof;
-        const circuitType = previousRollupData.baseOrMergeRollupPublicInputs.rollupType === RollupTypes.Base
-            ? 'BaseRollupArtifact'
-            : 'MergeRollupArtifact';
-        await this.verifyProof(circuitType, proof);
+    /**
+     * Will check a recursive proof argument for validity of it's 'fields' format of proof and convert if required
+     * @param proof - The input proof that may need converting
+     * @returns - The valid proof
+     */
+    async ensureValidProof(proof, circuit, vk) {
+        // If the 'fields' proof is already valid then simply return
+        // This will be false for proofs coming from clients
+        if (proof.fieldsValid) {
+            return proof;
+        }
+        const operation = async (bbWorkingDirectory) => {
+            const numPublicInputs = vk.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+            const proofFullFilename = path.join(bbWorkingDirectory, PROOF_FILENAME);
+            const vkFullFilename = path.join(bbWorkingDirectory, VK_FILENAME);
+            logger.debug(`Converting proof to fields format for circuit ${circuit}, directory ${bbWorkingDirectory}, num public inputs: ${vk.numPublicInputs}, proof length ${proof.binaryProof.buffer.length}, vk length ${vk.keyAsBytes.length}`);
+            await fs.writeFile(proofFullFilename, proof.binaryProof.buffer);
+            await fs.writeFile(vkFullFilename, vk.keyAsBytes);
+            const logFunction = (message) => {
+                logger.debug(`${circuit} BB out - ${message}`);
+            };
+            const result = await writeProofAsFields(this.config.bbBinaryPath, bbWorkingDirectory, PROOF_FILENAME, vkFullFilename, logFunction);
+            if (result.status === BB_RESULT.FAILURE) {
+                const errorMessage = `Failed to convert ${circuit} proof to fields, ${result.reason}`;
+                throw new Error(errorMessage);
+            }
+            const proofString = await fs.readFile(path.join(bbWorkingDirectory, PROOF_FIELDS_FILENAME), {
+                encoding: 'utf-8',
+            });
+            const json = JSON.parse(proofString);
+            const fields = json.slice(numPublicInputs).map(Fr.fromString);
+            return new RecursiveProof(fields, new Proof(proof.binaryProof.buffer, vk.numPublicInputs), true);
+        };
+        return await runInDirectory(this.config.bbWorkingDirectory, operation);
     }
     /**
      * Returns the verification key data for a circuit, will generate and cache it if not cached internally
@@ -248,36 +360,12 @@ export class BBNativeRollupProver {
                 if (result.status === BB_RESULT.FAILURE) {
                     throw new Error(`Failed to generate verification key for ${circuitType}, ${result.reason}`);
                 }
-                return this.convertVk(result.vkPath);
+                return extractVkData(result.vkPath);
             });
             this.verificationKeys.set(circuitType, promise);
         }
-        return await promise;
-    }
-    /**
-     * Reads the verification key data stored at the specified location and parses into a VerificationKeyData
-     * @param filePath - The directory containing the verification key data files
-     * @returns The verification key data
-     */
-    async convertVk(filePath) {
-        const [rawFields, rawBinary] = await Promise.all([
-            fs.readFile(`${filePath}/${VK_FIELDS_FILENAME}`, { encoding: 'utf-8' }),
-            fs.readFile(`${filePath}/${VK_FILENAME}`),
-        ]);
-        const fieldsJson = JSON.parse(rawFields);
-        const fields = fieldsJson.map(Fr.fromString);
-        // The first item is the hash, this is not part of the actual VK
-        const vkHash = fields[0];
-        const actualVk = fields.slice(1);
-        const vk = {
-            hash: vkHash,
-            keyAsFields: actualVk,
-            keyAsBytes: rawBinary,
-            numPublicInputs: Number(actualVk[CIRCUIT_PUBLIC_INPUTS_INDEX]),
-            circuitSize: Number(actualVk[CIRCUIT_SIZE_INDEX]),
-            isRecursive: actualVk[CIRCUIT_RECURSIVE_INDEX] == Fr.ONE,
-        };
-        return vk;
+        const vk = await promise;
+        return vk.clone();
     }
     /**
      * Ensures our verification key cache includes the key data located at the specified directory
@@ -287,10 +375,10 @@ export class BBNativeRollupProver {
     async updateVerificationKeyAfterProof(filePath, circuitType) {
         let promise = this.verificationKeys.get(circuitType);
         if (!promise) {
-            promise = this.convertVk(filePath);
+            promise = extractVkData(filePath);
             this.verificationKeys.set(circuitType, promise);
         }
-        await promise;
+        return promise;
     }
     /**
      * Parses and returns the proof data stored at the specified directory
@@ -298,24 +386,28 @@ export class BBNativeRollupProver {
      * @param circuitType - The type of circuit proven
      * @returns The proof
      */
-    async readProofAsFields(filePath, circuitType) {
+    async readProofAsFields(filePath, circuitType, proofLength) {
+        const proofFilename = path.join(filePath, PROOF_FILENAME);
+        const proofFieldsFilename = path.join(filePath, PROOF_FIELDS_FILENAME);
         const [binaryProof, proofString] = await Promise.all([
-            fs.readFile(`${filePath}/${PROOF_FILENAME}`),
-            fs.readFile(`${filePath}/${PROOF_FIELDS_FILENAME}`, { encoding: 'utf-8' }),
+            fs.readFile(proofFilename),
+            fs.readFile(proofFieldsFilename, { encoding: 'utf-8' }),
         ]);
         const json = JSON.parse(proofString);
-        const fields = json.map(Fr.fromString);
         const vkData = await this.verificationKeys.get(circuitType);
         if (!vkData) {
             throw new Error(`Invalid verification key for ${circuitType}`);
         }
         const numPublicInputs = CIRCUITS_WITHOUT_AGGREGATION.has(circuitType)
             ? vkData.numPublicInputs
-            : vkData.numPublicInputs - AGGREGATION_OBJECT_SIZE;
-        const fieldsWithoutPublicInputs = fields.slice(numPublicInputs);
-        logger.debug(`Circuit type: ${circuitType}, complete proof length: ${fields.length}, without public inputs: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`);
-        const proof = new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProof));
+            : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+        const fieldsWithoutPublicInputs = json.slice(numPublicInputs).map(Fr.fromString);
+        logger.debug(`Circuit type: ${circuitType}, complete proof length: ${json.length}, without public inputs: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}, is recursive: ${vkData.isRecursive}, raw length: ${binaryProof.length}`);
+        const proof = new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProof, numPublicInputs), true);
+        if (proof.proof.length !== proofLength) {
+            throw new Error(`Proof length doesn't match expected length (${proof.proof.length} != ${proofLength})`);
+        }
         return proof;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bb_prover.js","sourceRoot":"","sources":["../../src/prover/bb_prover.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bb_prover.js","sourceRoot":"","sources":["../../src/prover/bb_prover.ts"],"names":[],"mappings":"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"}