@aztec/bb-prover 0.40.1 → 0.42.0

package/src/prover/bb_native_proof_creator.ts

@@ -1,36 +1,42 @@
 import { type AppCircuitProofOutput, type KernelProofOutput, type ProofCreator } from '@aztec/circuit-types';
+import { type CircuitProvingStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
+  AGGREGATION_OBJECT_LENGTH,
   Fr,
   NESTED_RECURSIVE_PROOF_LENGTH,
   type PrivateCircuitPublicInputs,
   type PrivateKernelCircuitPublicInputs,
   type PrivateKernelInitCircuitPrivateInputs,
   type PrivateKernelInnerCircuitPrivateInputs,
+  type PrivateKernelResetCircuitPrivateInputsVariants,
   type PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
   Proof,
   RECURSIVE_PROOF_LENGTH,
   RecursiveProof,
-  type VERIFICATION_KEY_LENGTH_IN_FIELDS,
-  VerificationKeyAsFields,
+  type VerificationKeyAsFields,
+  type VerificationKeyData,
 } from '@aztec/circuits.js';
 import { siloNoteHash } from '@aztec/circuits.js/hash';
-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 {
   ClientCircuitArtifacts,
   type ClientProtocolArtifact,
+  PrivateResetTagToArtifactName,
   convertPrivateKernelInitInputsToWitnessMap,
   convertPrivateKernelInitOutputsFromWitnessMap,
   convertPrivateKernelInnerInputsToWitnessMap,
   convertPrivateKernelInnerOutputsFromWitnessMap,
+  convertPrivateKernelResetInputsToWitnessMap,
+  convertPrivateKernelResetOutputsFromWitnessMap,
   convertPrivateKernelTailForPublicOutputsFromWitnessMap,
   convertPrivateKernelTailInputsToWitnessMap,
   convertPrivateKernelTailOutputsFromWitnessMap,
   convertPrivateKernelTailToPublicInputsToWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
-import { type ACVMField, WASMSimulator } from '@aztec/simulator';
+import { WASMSimulator } from '@aztec/simulator';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { serializeWitness } from '@noir-lang/noirc_abi';
@@ -41,38 +47,12 @@ import {
   BB_RESULT,
   PROOF_FIELDS_FILENAME,
   PROOF_FILENAME,
-  VK_FIELDS_FILENAME,
-  VK_FILENAME,
   generateKeyForNoirCircuit,
   generateProof,
   verifyProof,
 } from '../bb/execute.js';
-import {
-  AGGREGATION_OBJECT_SIZE,
-  CIRCUIT_PUBLIC_INPUTS_INDEX,
-  CIRCUIT_RECURSIVE_INDEX,
-  CIRCUIT_SIZE_INDEX,
-  type VerificationKeyData,
-} from './verification_key_data.js';
-
-type PrivateKernelProvingOps = {
-  convertOutputs: (outputs: WitnessMap) => PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs;
-};
-
-const PrivateKernelArtifactMapping: Record<ClientProtocolArtifact, PrivateKernelProvingOps> = {
-  PrivateKernelInitArtifact: {
-    convertOutputs: convertPrivateKernelInitOutputsFromWitnessMap,
-  },
-  PrivateKernelInnerArtifact: {
-    convertOutputs: convertPrivateKernelInnerOutputsFromWitnessMap,
-  },
-  PrivateKernelTailArtifact: {
-    convertOutputs: convertPrivateKernelTailOutputsFromWitnessMap,
-  },
-  PrivateKernelTailToPublicArtifact: {
-    convertOutputs: convertPrivateKernelTailForPublicOutputsFromWitnessMap,
-  },
-};
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+import { extractVkData } from '../verification_key/verification_key_data.js';
 
 /**
  * This proof creator implementation uses the native bb binary.
@@ -103,38 +83,63 @@ export class BBNativeProofCreator implements ProofCreator {
   public async createProofInit(
     inputs: PrivateKernelInitCircuitPrivateInputs,
   ): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>> {
-    const witnessMap = convertPrivateKernelInitInputsToWitnessMap(inputs);
-    return await this.createSafeProof(witnessMap, 'PrivateKernelInitArtifact');
+    return await this.createSafeProof(
+      inputs,
+      'PrivateKernelInitArtifact',
+      convertPrivateKernelInitInputsToWitnessMap,
+      convertPrivateKernelInitOutputsFromWitnessMap,
+    );
   }
 
   public async createProofInner(
     inputs: PrivateKernelInnerCircuitPrivateInputs,
   ): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>> {
-    const witnessMap = convertPrivateKernelInnerInputsToWitnessMap(inputs);
-    return await this.createSafeProof(witnessMap, 'PrivateKernelInnerArtifact');
+    return await this.createSafeProof(
+      inputs,
+      'PrivateKernelInnerArtifact',
+      convertPrivateKernelInnerInputsToWitnessMap,
+      convertPrivateKernelInnerOutputsFromWitnessMap,
+    );
+  }
+
+  public async createProofReset(
+    inputs: PrivateKernelResetCircuitPrivateInputsVariants,
+  ): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.createSafeProof(
+      inputs,
+      PrivateResetTagToArtifactName[inputs.sizeTag],
+      convertPrivateKernelResetInputsToWitnessMap,
+      output => convertPrivateKernelResetOutputsFromWitnessMap(output, inputs.sizeTag),
+    );
   }
 
   public async createProofTail(
     inputs: PrivateKernelTailCircuitPrivateInputs,
   ): Promise<KernelProofOutput<PrivateKernelTailCircuitPublicInputs>> {
     if (!inputs.isForPublic()) {
-      const witnessMap = convertPrivateKernelTailInputsToWitnessMap(inputs);
-      return await this.createSafeProof(witnessMap, 'PrivateKernelTailArtifact');
+      return await this.createSafeProof(
+        inputs,
+        'PrivateKernelTailArtifact',
+        convertPrivateKernelTailInputsToWitnessMap,
+        convertPrivateKernelTailOutputsFromWitnessMap,
+      );
     }
-    const witnessMap = convertPrivateKernelTailToPublicInputsToWitnessMap(inputs);
-    return await this.createSafeProof(witnessMap, 'PrivateKernelTailToPublicArtifact');
+    return await this.createSafeProof(
+      inputs,
+      'PrivateKernelTailToPublicArtifact',
+      convertPrivateKernelTailToPublicInputsToWitnessMap,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMap,
+    );
   }
 
   public async createAppCircuitProof(
-    partialWitness: Map<number, ACVMField>,
+    partialWitness: WitnessMap,
     bytecode: Buffer,
+    appCircuitName?: string,
   ): Promise<AppCircuitProofOutput> {
-    const directory = `${this.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
-    await fs.mkdir(directory, { recursive: true });
-    this.log.debug(`Created directory: ${directory}`);
-    try {
+    const operation = async (directory: string) => {
       this.log.debug(`Proving app circuit`);
-      const proofOutput = await this.createProof(directory, partialWitness, bytecode, 'App');
+      const proofOutput = await this.createProof(directory, partialWitness, bytecode, 'App', appCircuitName);
       if (proofOutput.proof.proof.length != RECURSIVE_PROOF_LENGTH) {
         throw new Error(`Incorrect proof length`);
       }
@@ -144,10 +149,9 @@ export class BBNativeProofCreator implements ProofCreator {
         verificationKey: proofOutput.verificationKey,
       };
       return output;
-    } finally {
-      await fs.rm(directory, { recursive: true, force: true });
-      this.log.debug(`Deleted directory: ${directory}`);
-    }
+    };
+
+    return await runInDirectory(this.bbWorkingDirectory, operation);
   }
 
   /**
@@ -158,7 +162,7 @@ export class BBNativeProofCreator implements ProofCreator {
   public async verifyProofForProtocolCircuit(circuitType: ClientProtocolArtifact, proof: Proof) {
     const verificationKey = await this.getVerificationKeyDataForCircuit(circuitType);
 
-    this.log.debug(`Verifying with key: ${verificationKey.hash.toString()}`);
+    this.log.debug(`Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
 
     const logFunction = (message: string) => {
       this.log.debug(`${circuitType} BB out - ${message}`);
@@ -179,21 +183,15 @@ export class BBNativeProofCreator implements ProofCreator {
     proof: Proof,
     logFunction: (message: string) => void = () => {},
   ) {
-    // Create random directory to be used for temp files
-    const bbWorkingDirectory = `${this.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
-    await fs.mkdir(bbWorkingDirectory, { recursive: true });
-
-    const proofFileName = `${bbWorkingDirectory}/proof`;
-    const verificationKeyPath = `${bbWorkingDirectory}/vk`;
+    const operation = async (bbWorkingDirectory: string) => {
+      const proofFileName = `${bbWorkingDirectory}/proof`;
+      const verificationKeyPath = `${bbWorkingDirectory}/vk`;
 
-    await fs.writeFile(proofFileName, proof.buffer);
-    await fs.writeFile(verificationKeyPath, verificationKey);
-
-    try {
+      await fs.writeFile(proofFileName, proof.buffer);
+      await fs.writeFile(verificationKeyPath, verificationKey);
       return await verifyProof(this.bbBinaryPath, proofFileName, verificationKeyPath!, logFunction);
-    } finally {
-      await fs.rm(bbWorkingDirectory, { recursive: true, force: true });
-    }
+    };
+    return await runInDirectory(this.bbWorkingDirectory, operation);
   }
 
   /**
@@ -215,39 +213,13 @@ export class BBNativeProofCreator implements ProofCreator {
         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;
-  }
-
   /**
    * Ensures our verification key cache includes the key data located at the specified directory
    * @param filePath - The directory containing the verification key data files
@@ -256,41 +228,50 @@ export class BBNativeProofCreator implements ProofCreator {
   private async updateVerificationKeyAfterProof(filePath: string, circuitType: ClientProtocolArtifact) {
     let promise = this.verificationKeys.get(circuitType);
     if (!promise) {
-      promise = this.convertVk(filePath);
+      promise = extractVkData(filePath);
       this.log.debug(`Updated verification key for circuit: ${circuitType}`);
       this.verificationKeys.set(circuitType, promise);
     }
     return await promise;
   }
 
-  private async createSafeProof<T>(
-    inputs: WitnessMap,
+  private async createSafeProof<I extends { toBuffer: () => Buffer }, O extends { toBuffer: () => Buffer }>(
+    inputs: I,
     circuitType: ClientProtocolArtifact,
-  ): Promise<KernelProofOutput<T>> {
-    const directory = `${this.bbWorkingDirectory}/${randomBytes(8).toString('hex')}`;
-    await fs.mkdir(directory, { recursive: true });
-    this.log.debug(`Created directory: ${directory}`);
-    try {
-      return await this.generateWitnessAndCreateProof(inputs, circuitType, directory);
-    } finally {
-      await fs.rm(directory, { recursive: true, force: true });
-      this.log.debug(`Deleted directory: ${directory}`);
-    }
+    convertInputs: (inputs: I) => WitnessMap,
+    convertOutputs: (outputs: WitnessMap) => O,
+  ): Promise<KernelProofOutput<O>> {
+    const operation = async (directory: string) => {
+      return await this.generateWitnessAndCreateProof(inputs, circuitType, directory, convertInputs, convertOutputs);
+    };
+    return await runInDirectory(this.bbWorkingDirectory, operation);
   }
 
-  private async generateWitnessAndCreateProof<T>(
-    inputs: WitnessMap,
+  private async generateWitnessAndCreateProof<
+    I extends { toBuffer: () => Buffer },
+    O extends { toBuffer: () => Buffer },
+  >(
+    inputs: I,
     circuitType: ClientProtocolArtifact,
     directory: string,
-  ): Promise<KernelProofOutput<T>> {
+    convertInputs: (inputs: I) => WitnessMap,
+    convertOutputs: (outputs: WitnessMap) => O,
+  ): Promise<KernelProofOutput<O>> {
     this.log.debug(`Generating witness for ${circuitType}`);
     const compiledCircuit: NoirCompiledCircuit = ClientCircuitArtifacts[circuitType];
 
-    const outputWitness = await this.simulator.simulateCircuit(inputs, compiledCircuit);
+    const witnessMap = convertInputs(inputs);
+    const timer = new Timer();
+    const outputWitness = await this.simulator.simulateCircuit(witnessMap, compiledCircuit);
+    const output = convertOutputs(outputWitness);
 
-    this.log.debug(`Generated witness for ${circuitType}`);
-
-    const publicInputs = PrivateKernelArtifactMapping[circuitType].convertOutputs(outputWitness) as T;
+    this.log.debug(`Generated witness for ${circuitType}`, {
+      eventName: 'circuit-witness-generation',
+      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+      duration: timer.ms(),
+      inputSize: inputs.toBuffer().length,
+      outputSize: output.toBuffer().length,
+    } satisfies CircuitWitnessGenerationStats);
 
     const proofOutput = await this.createProof(
       directory,
@@ -303,8 +284,8 @@ export class BBNativeProofCreator implements ProofCreator {
     }
     const nestedProof = proofOutput.proof as RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>;
 
-    const kernelOutput: KernelProofOutput<T> = {
-      publicInputs,
+    const kernelOutput: KernelProofOutput<O> = {
+      publicInputs: output,
       proof: nestedProof,
       verificationKey: proofOutput.verificationKey,
     };
@@ -316,6 +297,7 @@ export class BBNativeProofCreator implements ProofCreator {
     partialWitness: WitnessMap,
     bytecode: Buffer,
     circuitType: ClientProtocolArtifact | 'App',
+    appCircuitName?: string,
   ): Promise<{
     proof: RecursiveProof<typeof RECURSIVE_PROOF_LENGTH> | RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>;
     verificationKey: VerificationKeyAsFields;
@@ -328,6 +310,10 @@ export class BBNativeProofCreator implements ProofCreator {
 
     this.log.debug(`Written ${inputsWitnessFile}`);
 
+    this.log.info(`Proving ${circuitType} circuit...`);
+
+    const timer = new Timer();
+
     const provingResult = await generateProof(
       this.bbBinaryPath,
       directory,
@@ -342,15 +328,45 @@ export class BBNativeProofCreator implements ProofCreator {
       throw new Error(provingResult.reason);
     }
 
+    this.log.info(
+      `Generated ${circuitType === 'App' ? appCircuitName : circuitType} circuit proof in ${timer.ms()} ms`,
+    );
+
     if (circuitType === 'App') {
-      const vkData = await this.convertVk(directory);
+      const vkData = await extractVkData(directory);
       const proof = await this.readProofAsFields<typeof RECURSIVE_PROOF_LENGTH>(directory, circuitType, vkData);
-      return { proof, verificationKey: new VerificationKeyAsFields(vkData.keyAsFields, vkData.hash) };
+
+      this.log.debug(`Generated proof`, {
+        eventName: 'circuit-proving',
+        circuitName: 'app-circuit',
+        duration: provingResult.duration,
+        inputSize: compressedBincodedWitness.length,
+        proofSize: proof.binaryProof.buffer.length,
+        appCircuitName,
+        circuitSize: vkData.circuitSize,
+        numPublicInputs: vkData.numPublicInputs,
+      } as CircuitProvingStats);
+
+      return { proof, verificationKey: vkData.keyAsFields };
     }
 
     const vkData = await this.updateVerificationKeyAfterProof(directory, circuitType);
+
     const proof = await this.readProofAsFields<typeof NESTED_RECURSIVE_PROOF_LENGTH>(directory, circuitType, vkData);
-    return { proof, verificationKey: new VerificationKeyAsFields(vkData.keyAsFields, vkData.hash) };
+
+    await this.verifyProofForProtocolCircuit(circuitType, proof.binaryProof);
+
+    this.log.debug(`Generated proof`, {
+      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+      duration: provingResult.duration,
+      eventName: 'circuit-proving',
+      inputSize: compressedBincodedWitness.length,
+      proofSize: proof.binaryProof.buffer.length,
+      circuitSize: vkData.circuitSize,
+      numPublicInputs: vkData.numPublicInputs,
+    } as CircuitProvingStats);
+
+    return { proof, verificationKey: vkData.keyAsFields };
   }
 
   /**
@@ -371,12 +387,16 @@ export class BBNativeProofCreator implements ProofCreator {
     const json = JSON.parse(proofString);
     const fields = json.map(Fr.fromString);
     const numPublicInputs =
-      circuitType === 'App' ? vkData.numPublicInputs : vkData.numPublicInputs - AGGREGATION_OBJECT_SIZE;
+      circuitType === 'App' ? vkData.numPublicInputs : vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
     const fieldsWithoutPublicInputs = fields.slice(numPublicInputs);
     this.log.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<PROOF_LENGTH>(fieldsWithoutPublicInputs, new Proof(binaryProof));
+    const proof = new RecursiveProof<PROOF_LENGTH>(
+      fieldsWithoutPublicInputs,
+      new Proof(binaryProof, vkData.numPublicInputs),
+      true,
+    );
     return proof;
   }
 }