@aztec/bb-prover 0.40.1 → 0.42.0

package/src/prover/bb_prover.ts

@@ -1,39 +1,45 @@
 /* eslint-disable require-await */
 import {
-  type PublicInputsAndProof,
+  type ProofAndVerificationKey,
+  type PublicInputsAndRecursiveProof,
   type PublicKernelNonTailRequest,
   type PublicKernelTailRequest,
   PublicKernelType,
   type ServerCircuitProver,
-  makePublicInputsAndProof,
+  makePublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
+import { type CircuitProvingStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
+  AGGREGATION_OBJECT_LENGTH,
+  type AvmCircuitInputs,
   type BaseOrMergeRollupPublicInputs,
   type BaseParityInputs,
   type BaseRollupInputs,
+  EmptyNestedCircuitInputs,
+  EmptyNestedData,
   Fr,
   type KernelCircuitPublicInputs,
   type MergeRollupInputs,
-  type NESTED_RECURSIVE_PROOF_LENGTH,
-  type ParityPublicInputs,
-  type PreviousRollupData,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  type PrivateKernelEmptyInputData,
+  PrivateKernelEmptyInputs,
   Proof,
   type PublicKernelCircuitPublicInputs,
-  type RECURSIVE_PROOF_LENGTH,
+  RECURSIVE_PROOF_LENGTH,
   RecursiveProof,
-  RollupTypes,
   RootParityInput,
   type RootParityInputs,
   type RootRollupInputs,
   type RootRollupPublicInputs,
-  type VERIFICATION_KEY_LENGTH_IN_FIELDS,
-  VerificationKeyAsFields,
+  type VerificationKeyAsFields,
+  type VerificationKeyData,
+  makeRecursiveProofFromBinary,
 } from '@aztec/circuits.js';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { runInDirectory } from '@aztec/foundation/fs';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { type Tuple } from '@aztec/foundation/serialize';
 import { Timer } from '@aztec/foundation/timer';
 import {
+  EmptyNestedArtifact,
   ServerCircuitArtifacts,
   type ServerProtocolArtifact,
   convertBaseParityInputsToWitnessMap,
@@ -42,6 +48,8 @@ import {
   convertBaseRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
+  convertPrivateKernelEmptyInputsToWitnessMap,
+  convertPrivateKernelEmptyOutputsFromWitnessMap,
   convertPublicTailInputsToWitnessMap,
   convertPublicTailOutputFromWitnessMap,
   convertRootParityInputsToWitnessMap,
@@ -51,41 +59,41 @@ import {
 } from '@aztec/noir-protocol-circuits-types';
 import { NativeACVMSimulator } from '@aztec/simulator';
 
-import { type WitnessMap } from '@noir-lang/types';
+import { abiEncode } from '@noir-lang/noirc_abi';
+import { type Abi, type WitnessMap } from '@noir-lang/types';
 import * as fs from 'fs/promises';
+import * as path from 'path';
 
 import {
+  type BBSuccess,
   BB_RESULT,
   PROOF_FIELDS_FILENAME,
   PROOF_FILENAME,
-  VK_FIELDS_FILENAME,
   VK_FILENAME,
+  type VerificationFunction,
+  generateAvmProof,
   generateKeyForNoirCircuit,
   generateProof,
+  verifyAvmProof,
   verifyProof,
+  writeProofAsFields,
 } from '../bb/execute.js';
+import type { ACVMConfig, BBConfig } from '../config.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,
-  type VerificationKeyData,
-} 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: Set<ServerProtocolArtifact> = new Set(['BaseParityArtifact']);
+const CIRCUITS_WITHOUT_AGGREGATION: Set<ServerProtocolArtifact> = new Set([
+  'BaseParityArtifact',
+  'EmptyNestedArtifact',
+]);
 
-export type BBProverConfig = {
-  bbBinaryPath: string;
-  bbWorkingDirectory: string;
-  acvmBinaryPath: string;
-  acvmWorkingDirectory: string;
+export interface BBProverConfig extends BBConfig, ACVMConfig {
   // list of circuits supported by this prover. defaults to all circuits if empty
   circuitFilter?: ServerProtocolArtifact[];
-};
+}
 
 /**
  * Prover implementation that uses barretenberg native proving
@@ -114,19 +122,19 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @returns The public inputs of the parity circuit.
    */
   public async getBaseParityProof(inputs: BaseParityInputs): Promise<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>> {
-    const witnessMap = convertBaseParityInputsToWitnessMap(inputs);
-
-    const [circuitOutput, proof] = await this.createRecursiveProof<typeof RECURSIVE_PROOF_LENGTH, ParityPublicInputs>(
-      witnessMap,
+    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);
+    await this.verifyProof('BaseParityArtifact', proof.binaryProof);
 
-    return new RootParityInput(proof, vk, circuitOutput);
+    return new RootParityInput(proof, verificationKey.keyAsFields, circuitOutput);
   }
 
   /**
@@ -137,18 +145,30 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   public async getRootParityProof(
     inputs: RootParityInputs,
   ): Promise<RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
-    const witnessMap = convertRootParityInputsToWitnessMap(inputs);
-
-    const [circuitOutput, proof] = await this.createRecursiveProof<
-      typeof NESTED_RECURSIVE_PROOF_LENGTH,
-      ParityPublicInputs
-    >(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);
+    await this.verifyProof('RootParityArtifact', proof.binaryProof);
+
+    return new RootParityInput(proof, verificationKey.keyAsFields, circuitOutput);
+  }
 
-    return new RootParityInput(proof, vk, circuitOutput);
+  /**
+   * Creates an AVM proof and verifies it.
+   * @param inputs - The inputs to the AVM circuit.
+   * @returns The proof.
+   */
+  public async getAvmProof(inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
+    const proofAndVk = await this.createAvmProof(inputs);
+    await this.verifyAvmProof(proofAndVk.proof, proofAndVk.verificationKey);
+    return proofAndVk;
   }
 
   /**
@@ -158,17 +178,37 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async getPublicKernelProof(
     kernelRequest: PublicKernelNonTailRequest,
-  ): Promise<PublicInputsAndProof<PublicKernelCircuitPublicInputs>> {
+  ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
     const kernelOps = PublicKernelArtifactMapping[kernelRequest.type];
     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);
+    // 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);
 
-    const result = kernelOps.convertOutputs(outputWitness);
-    return makePublicInputsAndProof(result, proof);
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
   }
 
   /**
@@ -178,13 +218,20 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async getPublicTailProof(
     kernelRequest: PublicKernelTailRequest,
-  ): Promise<PublicInputsAndProof<KernelCircuitPublicInputs>> {
-    const witnessMap = convertPublicTailInputsToWitnessMap(kernelRequest.inputs);
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    const { circuitOutput, proof } = await this.createRecursiveProof(
+      kernelRequest.inputs,
+      'PublicKernelTailArtifact',
+      NESTED_RECURSIVE_PROOF_LENGTH,
+      convertPublicTailInputsToWitnessMap,
+      convertPublicTailOutputFromWitnessMap,
+    );
+
+    const verificationKey = await this.getVerificationKeyDataForCircuit('PublicKernelTailArtifact');
 
-    const [outputWitness, proof] = await this.createProof(witnessMap, 'PublicKernelTailArtifact');
+    await this.verifyProof('PublicKernelTailArtifact', proof.binaryProof);
 
-    const result = convertPublicTailOutputFromWitnessMap(outputWitness);
-    return makePublicInputsAndProof(result, proof);
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
   }
 
   /**
@@ -194,15 +241,29 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async getBaseRollupProof(
     input: BaseRollupInputs,
-  ): Promise<PublicInputsAndProof<BaseOrMergeRollupPublicInputs>> {
-    const witnessMap = convertBaseRollupInputsToWitnessMap(input);
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
+    // 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 [outputWitness, proof] = await this.createProof(witnessMap, 'BaseRollupArtifact');
+    const verificationKey = await this.getVerificationKeyDataForCircuit('BaseRollupArtifact');
 
-    const result = convertBaseRollupOutputsFromWitnessMap(outputWitness);
+    await this.verifyProof('BaseRollupArtifact', proof.binaryProof);
 
-    return makePublicInputsAndProof(result, proof);
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
   }
+
   /**
    * Simulates the merge rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
@@ -210,17 +271,20 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async getMergeRollupProof(
     input: MergeRollupInputs,
-  ): Promise<PublicInputsAndProof<BaseOrMergeRollupPublicInputs>> {
-    // verify both inputs
-    await Promise.all(input.previousRollupData.map(prev => this.verifyPreviousRollupProof(prev)));
-
-    const witnessMap = convertMergeRollupInputsToWitnessMap(input);
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
+    const { circuitOutput, proof } = await this.createRecursiveProof(
+      input,
+      'MergeRollupArtifact',
+      NESTED_RECURSIVE_PROOF_LENGTH,
+      convertMergeRollupInputsToWitnessMap,
+      convertMergeRollupOutputsFromWitnessMap,
+    );
 
-    const [outputWitness, proof] = await this.createProof(witnessMap, 'MergeRollupArtifact');
+    const verificationKey = await this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
 
-    const result = convertMergeRollupOutputsFromWitnessMap(outputWitness);
+    await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
 
-    return makePublicInputsAndProof(result, proof);
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
   }
 
   /**
@@ -228,30 +292,84 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  public async getRootRollupProof(input: RootRollupInputs): Promise<PublicInputsAndProof<RootRollupPublicInputs>> {
-    // verify the inputs
-    await Promise.all(input.previousRollupData.map(prev => this.verifyPreviousRollupProof(prev)));
+  public async getRootRollupProof(
+    input: RootRollupInputs,
+  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
+    const { circuitOutput, proof } = await this.createProof(
+      input,
+      'RootRollupArtifact',
+      convertRootRollupInputsToWitnessMap,
+      convertRootRollupOutputsFromWitnessMap,
+    );
 
-    const witnessMap = convertRootRollupInputsToWitnessMap(input);
+    const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
 
-    const [outputWitness, proof] = await this.createProof(witnessMap, 'RootRollupArtifact');
+    const verificationKey = await this.getVerificationKeyDataForCircuit('RootRollupArtifact');
 
     await this.verifyProof('RootRollupArtifact', proof);
 
-    const result = convertRootRollupOutputsFromWitnessMap(outputWitness);
-    return makePublicInputsAndProof(result, proof);
+    return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, verificationKey);
+  }
+
+  public async getEmptyPrivateKernelProof(
+    inputs: PrivateKernelEmptyInputData,
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    const emptyNested = await this.getEmptyNestedProof();
+    const emptyPrivateKernelProof = await this.getEmptyPrivateKernelProofFromEmptyNested(
+      PrivateKernelEmptyInputs.from({
+        ...inputs,
+        emptyNested,
+      }),
+    );
+
+    return emptyPrivateKernelProof;
+  }
+
+  private async getEmptyNestedProof(): Promise<EmptyNestedData> {
+    const inputs = new EmptyNestedCircuitInputs();
+    const { proof } = await this.createRecursiveProof(
+      inputs,
+      'EmptyNestedArtifact',
+      RECURSIVE_PROOF_LENGTH,
+      (nothing: any) => abiEncode(EmptyNestedArtifact.abi as Abi, { _inputs: nothing as any }),
+      () => new EmptyNestedCircuitInputs(),
+    );
+
+    const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyNestedArtifact');
+    await this.verifyProof('EmptyNestedArtifact', proof.binaryProof);
+
+    return new EmptyNestedData(proof, verificationKey.keyAsFields);
   }
 
-  // TODO(@PhilWindle): Delete when no longer required
-  public async createProof(witnessMap: WitnessMap, circuitType: ServerProtocolArtifact): Promise<[WitnessMap, 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 });
+  private async getEmptyPrivateKernelProofFromEmptyNested(
+    inputs: PrivateKernelEmptyInputs,
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    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);
 
-    await fs.access(bbWorkingDirectory);
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+  }
 
+  private async generateProofWithBB<
+    Input extends { toBuffer: () => Buffer },
+    Output extends { toBuffer: () => Buffer },
+  >(
+    input: Input,
+    circuitType: ServerProtocolArtifact,
+    convertInput: (input: Input) => WitnessMap,
+    convertOutput: (outputWitness: WitnessMap) => Output,
+    workingDirectory: string,
+  ): Promise<{ circuitOutput: Output; vkData: VerificationKeyData; provingResult: BBSuccess }> {
     // 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
@@ -265,22 +383,25 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     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',
+    } satisfies CircuitWitnessGenerationStats);
 
     // Now prove the circuit from the generated witness
     logger.debug(`Proving ${circuitType}...`);
 
     const provingResult = await generateProof(
       this.config.bbBinaryPath,
-      bbWorkingDirectory,
+      workingDirectory,
       circuitType,
       Buffer.from(artifact.bytecode, 'base64'),
       outputWitnessFile,
@@ -293,115 +414,150 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     }
 
     // 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`);
+    const vkData = await this.updateVerificationKeyAfterProof(provingResult.vkPath!, circuitType);
 
-    return [outputWitness, new Proof(proof)];
+    return {
+      circuitOutput: output,
+      vkData,
+      provingResult,
+    };
   }
 
-  /**
-   * 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 convertOutput - Function for parsing the output witness to it's corresponding object
-   * @returns The circuits output object and it's proof
-   */
-  public async createRecursiveProof<PROOF_LENGTH extends number, CircuitOutputType>(
-    witnessMap: WitnessMap,
+  private async createProof<Input extends { toBuffer: () => Buffer }, Output extends { toBuffer: () => Buffer }>(
+    input: Input,
     circuitType: ServerProtocolArtifact,
-    convertOutput: (outputWitness: WitnessMap) => CircuitOutputType,
-  ): Promise<[CircuitOutputType, RecursiveProof<PROOF_LENGTH>]> {
-    // 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,
+    convertInput: (input: Input) => WitnessMap,
+    convertOutput: (outputWitness: WitnessMap) => Output,
+  ): Promise<{ circuitOutput: Output; proof: Proof }> {
+    const operation = async (bbWorkingDirectory: string) => {
+      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,
+        } satisfies CircuitProvingStats,
       );
 
-      const artifact = ServerCircuitArtifacts[circuitType];
+      return { circuitOutput: output, proof };
+    };
+    return await runInDirectory(this.config.bbWorkingDirectory, operation);
+  }
 
-      logger.debug(`Generating witness data for ${circuitType}`);
+  private async generateAvmProofWithBB(input: AvmCircuitInputs, workingDirectory: string): Promise<BBSuccess> {
+    logger.debug(`Proving avm-circuit...`);
 
-      const timer = new Timer();
-      const outputWitness = await simulator.simulateCircuit(witnessMap, artifact);
+    const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger.debug);
 
-      emitCircuitWitnessGenerationStats(
-        circuitTypeToCircuitName(circuitType),
-        timer.ms(),
-        witnessMap.size * Fr.SIZE_IN_BYTES,
-        outputWitness.size * Fr.SIZE_IN_BYTES,
-        logger,
-      );
+    if (provingResult.status === BB_RESULT.FAILURE) {
+      logger.error(`Failed to generate proof for avm-circuit: ${provingResult.reason}`);
+      throw new Error(provingResult.reason);
+    }
 
-      const outputType = convertOutput(outputWitness);
+    return provingResult;
+  }
 
-      // Now prove the circuit from the generated witness
-      logger.debug(`Proving ${circuitType}...`);
+  private async createAvmProof(input: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
+    const operation = async (bbWorkingDirectory: string): Promise<ProofAndVerificationKey> => {
+      const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
 
-      const provingResult = await generateProof(
-        this.config.bbBinaryPath,
-        bbWorkingDirectory,
-        circuitType,
-        Buffer.from(artifact.bytecode, 'base64'),
-        outputWitnessFile,
-        logger.debug,
+      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' as const;
+      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,
+        } satisfies CircuitProvingStats,
       );
 
-      if (provingResult.status === BB_RESULT.FAILURE) {
-        logger.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
-        throw new Error(provingResult.reason);
-      }
+      return { proof, verificationKey };
+    };
+    return await runInDirectory(this.config.bbWorkingDirectory, operation);
+  }
 
-      // Ensure our vk cache is up to date
-      await this.updateVerificationKeyAfterProof(provingResult.vkPath!, circuitType);
+  /**
+   * 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
+   */
+  private async createRecursiveProof<
+    PROOF_LENGTH extends number,
+    CircuitInputType extends { toBuffer: () => Buffer },
+    CircuitOutputType extends { toBuffer: () => Buffer },
+  >(
+    input: CircuitInputType,
+    circuitType: ServerProtocolArtifact,
+    proofLength: PROOF_LENGTH,
+    convertInput: (input: CircuitInputType) => WitnessMap,
+    convertOutput: (outputWitness: WitnessMap) => CircuitOutputType,
+  ): Promise<{ circuitOutput: CircuitOutputType; proof: RecursiveProof<PROOF_LENGTH> }> {
+    const operation = async (bbWorkingDirectory: string) => {
+      const {
+        provingResult,
+        vkData,
+        circuitOutput: output,
+      } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
 
-      // Read the proof and then cleanup up our temporary directory
-      const proof = await this.readProofAsFields<PROOF_LENGTH>(provingResult.proofPath!, circuitType);
+      // Read the proof as fields
+      const proof = await this.readProofAsFields(provingResult.proofPath!, circuitType, proofLength);
 
       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,
+        `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,
+        } satisfies CircuitProvingStats,
       );
 
-      return [outputType, proof];
-    } finally {
-      await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
-    }
+      return {
+        circuitOutput: output,
+        proof,
+      };
+    };
+    return await runInDirectory(this.config.bbWorkingDirectory, operation);
   }
 
   /**
@@ -410,33 +566,50 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param proof - The proof to be verified
    */
   public async verifyProof(circuitType: ServerProtocolArtifact, proof: 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);
+    return await this.verifyWithKey(verificationKey, proof);
+  }
 
-    logger.debug(`Verifying with key: ${verificationKey.hash.toString()}`);
+  public async verifyAvmProof(proof: Proof, verificationKey: VerificationKeyData) {
+    return await this.verifyWithKeyInternal(proof, verificationKey, verifyAvmProof);
+  }
 
-    await fs.writeFile(proofFileName, proof.buffer);
-    await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+  public async verifyWithKey(verificationKey: VerificationKeyData, proof: Proof) {
+    return await this.verifyWithKeyInternal(proof, verificationKey, verifyProof);
+  }
 
-    const logFunction = (message: string) => {
-      logger.debug(`${circuitType} BB out - ${message}`);
-    };
+  private async verifyWithKeyInternal(
+    proof: Proof,
+    verificationKey: VerificationKeyData,
+    verificationFunction: VerificationFunction,
+  ) {
+    const operation = async (bbWorkingDirectory: string) => {
+      const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
+      const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
 
-    const result = await verifyProof(this.config.bbBinaryPath, proofFileName, verificationKeyPath!, logFunction);
+      await fs.writeFile(proofFileName, proof.buffer);
+      await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
 
-    await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
+      const logFunction = (message: string) => {
+        logger.debug(`BB out - ${message}`);
+      };
 
-    if (result.status === BB_RESULT.FAILURE) {
-      const errorMessage = `Failed to verify ${circuitType} proof!`;
-      throw new Error(errorMessage);
-    }
+      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`);
+    };
 
-    logger.info(`Successfully verified ${circuitType} proof in ${result.duration} ms`);
+    await runInDirectory(this.config.bbWorkingDirectory, operation);
   }
 
   /**
@@ -446,16 +619,66 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async getVerificationKeyForCircuit(circuitType: ServerProtocolArtifact): Promise<VerificationKeyAsFields> {
     const vkData = await this.getVerificationKeyDataForCircuit(circuitType);
-    return new VerificationKeyAsFields(vkData.keyAsFields, vkData.hash);
+    return vkData.clone().keyAsFields;
   }
 
-  private async verifyPreviousRollupProof(previousRollupData: 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
+   */
+  public async ensureValidProof(
+    proof: RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>,
+    circuit: ServerProtocolArtifact,
+    vk: VerificationKeyData,
+  ) {
+    // 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: string) => {
+      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: string) => {
+        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<typeof NESTED_RECURSIVE_PROOF_LENGTH>(
+        fields,
+        new Proof(proof.binaryProof.buffer, vk.numPublicInputs),
+        true,
+      );
+    };
+    return await runInDirectory(this.config.bbWorkingDirectory, operation);
   }
 
   /**
@@ -477,37 +700,12 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         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
-   */
-  private async convertVk(filePath: string): Promise<VerificationKeyData> {
-    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: VerificationKeyData = {
-      hash: vkHash,
-      keyAsFields: actualVk as Tuple<Fr, typeof VERIFICATION_KEY_LENGTH_IN_FIELDS>,
-      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();
   }
 
   /**
@@ -515,13 +713,16 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param filePath - The directory containing the verification key data files
    * @param circuitType - The type of circuit to which the verification key corresponds
    */
-  private async updateVerificationKeyAfterProof(filePath: string, circuitType: ServerProtocolArtifact) {
+  private async updateVerificationKeyAfterProof(
+    filePath: string,
+    circuitType: ServerProtocolArtifact,
+  ): Promise<VerificationKeyData> {
     let promise = this.verificationKeys.get(circuitType);
     if (!promise) {
-      promise = this.convertVk(filePath);
+      promise = extractVkData(filePath);
       this.verificationKeys.set(circuitType, promise);
     }
-    await promise;
+    return promise;
   }
 
   /**
@@ -533,25 +734,36 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   private async readProofAsFields<PROOF_LENGTH extends number>(
     filePath: string,
     circuitType: ServerProtocolArtifact,
+    proofLength: PROOF_LENGTH,
   ): Promise<RecursiveProof<PROOF_LENGTH>> {
+    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);
+      : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+    const fieldsWithoutPublicInputs = json.slice(numPublicInputs).map(Fr.fromString);
     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}`,
+      `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<PROOF_LENGTH>(fieldsWithoutPublicInputs, new Proof(binaryProof));
+    const proof = new RecursiveProof<PROOF_LENGTH>(
+      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;
   }
 }