@aztec/bb-prover 0.52.0 → 0.53.0

package/src/bb/execute.ts

@@ -8,6 +8,8 @@ import * as proc from 'child_process';
 import * as fs from 'fs/promises';
 import { basename, dirname, join } from 'path';
 
+import { type UltraHonkFlavor } from '../honk.js';
+
 export const VK_FILENAME = 'vk';
 export const VK_FIELDS_FILENAME = 'vk_fields.json';
 export const PROOF_FILENAME = 'proof';
@@ -113,7 +115,7 @@ export async function generateKeyForNoirCircuit(
   workingDirectory: string,
   circuitName: string,
   compiledCircuit: NoirCompiledCircuit,
-  key: 'vk' | 'pk',
+  flavor: UltraHonkFlavor,
   log: LogFn,
   force = false,
 ): Promise<BBSuccess | BBFailure> {
@@ -123,7 +125,7 @@ export async function generateKeyForNoirCircuit(
   // The bytecode hash file is also written here as /workingDirectory/pk/BaseParityArtifact/bytecode-hash
   // The bytecode is written to e.g. /workingDirectory/pk/BaseParityArtifact/bytecode
   // The bytecode is removed after the key is generated, leaving just the hash file
-  const circuitOutputDirectory = `${workingDirectory}/${key}/${circuitName}`;
+  const circuitOutputDirectory = `${workingDirectory}/vk/${circuitName}`;
   const outputPath = `${circuitOutputDirectory}`;
   const bytecodeHash = sha256(bytecode);
 
@@ -148,11 +150,11 @@ export async function generateKeyForNoirCircuit(
       // args are the output path and the input bytecode path
       const args = ['-o', `${outputPath}/${VK_FILENAME}`, '-b', bytecodePath];
       const timer = new Timer();
-      let result = await executeBB(pathToBB, `write_${key}_ultra_honk`, args, log);
+      let result = await executeBB(pathToBB, `write_vk_${flavor}`, args, log);
       // If we succeeded and the type of key if verification, have bb write the 'fields' version too
-      if (result.status == BB_RESULT.SUCCESS && key === 'vk') {
+      if (result.status == BB_RESULT.SUCCESS) {
         const asFieldsArgs = ['-k', `${outputPath}/${VK_FILENAME}`, '-o', `${outputPath}/${VK_FIELDS_FILENAME}`, '-v'];
-        result = await executeBB(pathToBB, `vk_as_fields_ultra_honk`, asFieldsArgs, log);
+        result = await executeBB(pathToBB, `vk_as_fields_${flavor}`, asFieldsArgs, log);
       }
       const duration = timer.ms();
 
@@ -160,8 +162,8 @@ export async function generateKeyForNoirCircuit(
         return {
           status: BB_RESULT.SUCCESS,
           durationMs: duration,
-          pkPath: key === 'pk' ? outputPath : undefined,
-          vkPath: key === 'vk' ? outputPath : undefined,
+          pkPath: undefined,
+          vkPath: outputPath,
           proofPath: undefined,
         };
       }
@@ -179,8 +181,8 @@ export async function generateKeyForNoirCircuit(
     return {
       status: BB_RESULT.ALREADY_PRESENT,
       durationMs: 0,
-      pkPath: key === 'pk' ? outputPath : undefined,
-      vkPath: key === 'vk' ? outputPath : undefined,
+      pkPath: undefined,
+      vkPath: outputPath,
     };
   }
 
@@ -261,6 +263,7 @@ export async function computeVerificationKey(
   workingDirectory: string,
   circuitName: string,
   bytecode: Buffer,
+  flavor: UltraHonkFlavor,
   log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
@@ -293,7 +296,7 @@ export async function computeVerificationKey(
     };
     let result = await executeBB(
       pathToBB,
-      'write_vk_ultra_honk',
+      `write_vk_${flavor}`,
       ['-o', outputPath, '-b', bytecodePath, '-v'],
       logFunction,
     );
@@ -302,7 +305,7 @@ export async function computeVerificationKey(
     }
     result = await executeBB(
       pathToBB,
-      'vk_as_fields_ultra_honk',
+      `vk_as_fields_${flavor}`,
       ['-o', outputPath + '_fields.json', '-k', outputPath, '-v'],
       logFunction,
     );
@@ -343,6 +346,7 @@ export async function generateProof(
   circuitName: string,
   bytecode: Buffer,
   inputWitnessFile: string,
+  flavor: UltraHonkFlavor,
   log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
@@ -355,7 +359,7 @@ export async function generateProof(
   // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
   const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
 
-  // The proof is written to e.g. /workingDirectory/proof
+  // The proof is written to e.g. /workingDirectory/ultra_honk/proof
   const outputPath = `${workingDirectory}`;
 
   const binaryPresent = await fs
@@ -374,7 +378,7 @@ export async function generateProof(
     const logFunction = (message: string) => {
       log(`${circuitName} BB out - ${message}`);
     };
-    const result = await executeBB(pathToBB, 'prove_ultra_honk_output_all', args, logFunction);
+    const result = await executeBB(pathToBB, `prove_${flavor}_output_all`, args, logFunction);
     const duration = timer.ms();
 
     if (result.status == BB_RESULT.SUCCESS) {
@@ -420,7 +424,7 @@ export async function generateTubeProof(
   }
 
   // // Paths for the inputs
-  const vkPath = join(workingDirectory, 'inst_vk.bin'); // the vk of the last instance
+  const vkPath = join(workingDirectory, 'final_decider_vk.bin'); // the vk of the last instance
   const accPath = join(workingDirectory, 'pg_acc.bin');
   const proofPath = join(workingDirectory, 'client_ivc_proof.bin');
   const translatorVkPath = join(workingDirectory, 'translator_vk.bin');
@@ -599,9 +603,10 @@ export async function verifyProof(
   pathToBB: string,
   proofFullPath: string,
   verificationKeyPath: string,
+  ultraHonkFlavor: UltraHonkFlavor,
   log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
-  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'verify_ultra_honk', log);
+  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, `verify_${ultraHonkFlavor}`, log);
 }
 
 /**
@@ -674,7 +679,7 @@ async function verifyProofInternal(
   pathToBB: string,
   proofFullPath: string,
   verificationKeyPath: string,
-  command: 'verify_ultra_honk' | 'avm_verify',
+  command: 'verify_ultra_honk' | 'verify_ultra_keccak_honk' | 'avm_verify',
   log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
@@ -851,7 +856,7 @@ export async function generateContractForCircuit(
     workingDirectory,
     circuitName,
     compiledCircuit,
-    'vk',
+    'ultra_keccak_honk',
     log,
     force,
   );

package/src/honk.ts

@@ -0,0 +1,18 @@
+import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+
+export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk';
+
+const UltraKeccakHonkCircuits = ['BlockRootRollupArtifact'] as const;
+type UltraKeccakHonkCircuits = (typeof UltraKeccakHonkCircuits)[number];
+type UltraHonkCircuits = Exclude<ProtocolArtifact, UltraKeccakHonkCircuits>;
+
+export function getUltraHonkFlavorForCircuit(artifact: UltraKeccakHonkCircuits): 'ultra_keccak_honk';
+export function getUltraHonkFlavorForCircuit(artifact: UltraHonkCircuits): 'ultra_honk';
+export function getUltraHonkFlavorForCircuit(artifact: ProtocolArtifact): UltraHonkFlavor;
+export function getUltraHonkFlavorForCircuit(artifact: ProtocolArtifact): UltraHonkFlavor {
+  return isUltraKeccakHonkCircuit(artifact) ? 'ultra_keccak_honk' : 'ultra_honk';
+}
+
+function isUltraKeccakHonkCircuit(artifact: ProtocolArtifact): artifact is UltraKeccakHonkCircuits {
+  return UltraKeccakHonkCircuits.includes(artifact as UltraKeccakHonkCircuits);
+}

package/src/prover/bb_private_kernel_prover.ts

@@ -58,6 +58,7 @@ import {
   verifyProof,
 } from '../bb/execute.js';
 import { type BBConfig } from '../config.js';
+import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../honk.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
 
@@ -213,7 +214,12 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
       this.log.debug(`${circuitType} BB out - ${message}`);
     };
 
-    const result = await this.verifyProofFromKey(verificationKey.keyAsBytes, proof, logFunction);
+    const result = await this.verifyProofFromKey(
+      getUltraHonkFlavorForCircuit(circuitType),
+      verificationKey.keyAsBytes,
+      proof,
+      logFunction,
+    );
 
     if (result.status === BB_RESULT.FAILURE) {
       const errorMessage = `Failed to verify ${circuitType} proof!`;
@@ -224,6 +230,7 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
   }
 
   private async verifyProofFromKey(
+    flavor: UltraHonkFlavor,
     verificationKey: Buffer,
     proof: Proof,
     logFunction: (message: string) => void = () => {},
@@ -234,7 +241,7 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
 
       await fs.writeFile(proofFileName, proof.buffer);
       await fs.writeFile(verificationKeyPath, verificationKey);
-      return await verifyProof(this.bbBinaryPath, proofFileName, verificationKeyPath!, logFunction);
+      return await verifyProof(this.bbBinaryPath, proofFileName, verificationKeyPath!, flavor, logFunction);
     };
     return await this.runInDirectory(operation);
   }
@@ -301,7 +308,14 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
 
     const timer = new Timer();
 
-    const vkResult = await computeVerificationKey(this.bbBinaryPath, directory, circuitType, bytecode, this.log.debug);
+    const vkResult = await computeVerificationKey(
+      this.bbBinaryPath,
+      directory,
+      circuitType,
+      bytecode,
+      circuitType === 'App' ? 'ultra_honk' : getUltraHonkFlavorForCircuit(circuitType),
+      this.log.debug,
+    );
 
     if (vkResult.status === BB_RESULT.FAILURE) {
       this.log.error(`Failed to generate proof for ${circuitType}${dbgCircuitName}: ${vkResult.reason}`);

package/src/prover/bb_prover.ts

@@ -77,12 +77,12 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 
 import {
+  type BBFailure,
   type BBSuccess,
   BB_RESULT,
   PROOF_FIELDS_FILENAME,
   PROOF_FILENAME,
   VK_FILENAME,
-  type VerificationFunction,
   generateAvmProof,
   generateKeyForNoirCircuit,
   generateProof,
@@ -92,6 +92,7 @@ import {
   writeProofAsFields,
 } from '../bb/execute.js';
 import type { ACVMConfig, BBConfig } from '../config.js';
+import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../honk.js';
 import { ProverInstrumentation } from '../instrumentation.js';
 import { PublicKernelArtifactMapping } from '../mappings/mappings.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
@@ -99,11 +100,6 @@ import { extractAvmVkData, extractVkData } from '../verification_key/verificatio
 
 const logger = createDebugLogger('aztec:bb-prover');
 
-const CIRCUITS_WITHOUT_AGGREGATION: Set<ServerProtocolArtifact> = new Set([
-  'BaseParityArtifact',
-  'EmptyNestedArtifact',
-]);
-
 export interface BBProverConfig extends BBConfig, ACVMConfig {
   // list of circuits supported by this prover. defaults to all circuits if empty
   circuitFilter?: ServerProtocolArtifact[];
@@ -113,8 +109,8 @@ export interface BBProverConfig extends BBConfig, ACVMConfig {
  * Prover implementation that uses barretenberg native proving
  */
 export class BBNativeRollupProver implements ServerCircuitProver {
-  private verificationKeys: Map<ServerProtocolArtifact, Promise<VerificationKeyData>> = new Map<
-    ServerProtocolArtifact,
+  private verificationKeys = new Map<
+    `ultra${'_keccak_' | '_'}honk_${ServerProtocolArtifact}`,
     Promise<VerificationKeyData>
   >();
 
@@ -235,6 +231,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     );
 
     await this.verifyWithKey(
+      getUltraHonkFlavorForCircuit(kernelOps.artifact),
       kernelRequest.inputs.previousKernel.vk,
       kernelRequest.inputs.previousKernel.proof.binaryProof,
     );
@@ -539,6 +536,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       circuitType,
       Buffer.from(artifact.bytecode, 'base64'),
       outputWitnessFile,
+      getUltraHonkFlavorForCircuit(circuitType),
       logger.debug,
     );
 
@@ -682,9 +680,8 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       this.instrumentation.recordSize('circuitSize', 'tubeCircuit', tubeVK.circuitSize);
 
       // Sanity check the tube proof (can be removed later)
-      await this.verifyWithKey(tubeVK, tubeProof.binaryProof);
+      await this.verifyWithKey('ultra_honk', tubeVK, tubeProof.binaryProof);
 
-      // TODO(#7369): properly time tube construction
       logger.info(
         `Generated proof for tubeCircuit in ${Math.ceil(provingResult.durationMs)} ms, size: ${
           tubeProof.proof.length
@@ -762,22 +759,25 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async verifyProof(circuitType: ServerProtocolArtifact, proof: Proof) {
     const verificationKey = await this.getVerificationKeyDataForCircuit(circuitType);
-    // info(`vkey in: ${verificationKey.keyAsFields.key}`);
-    return await this.verifyWithKey(verificationKey, proof);
+    return await this.verifyWithKey(getUltraHonkFlavorForCircuit(circuitType), verificationKey, proof);
   }
 
   public async verifyAvmProof(proof: Proof, verificationKey: AvmVerificationKeyData) {
-    return await this.verifyWithKeyInternal(proof, verificationKey, verifyAvmProof);
+    return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) =>
+      verifyAvmProof(this.config.bbBinaryPath, proofPath, vkPath, logger.debug),
+    );
   }
 
-  public async verifyWithKey(verificationKey: VerificationKeyData, proof: Proof) {
-    return await this.verifyWithKeyInternal(proof, verificationKey, verifyProof);
+  public async verifyWithKey(flavor: UltraHonkFlavor, verificationKey: VerificationKeyData, proof: Proof) {
+    return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) =>
+      verifyProof(this.config.bbBinaryPath, proofPath, vkPath, flavor, logger.debug),
+    );
   }
 
   private async verifyWithKeyInternal(
     proof: Proof,
     verificationKey: { keyAsBytes: Buffer },
-    verificationFunction: VerificationFunction,
+    verificationFunction: (proofPath: string, vkPath: string) => Promise<BBFailure | BBSuccess>,
   ) {
     const operation = async (bbWorkingDirectory: string) => {
       const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
@@ -786,16 +786,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       await fs.writeFile(proofFileName, proof.buffer);
       await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
 
-      const logFunction = (message: string) => {
-        logger.verbose(`BB out - ${message}`);
-      };
-
-      const result = await verificationFunction(
-        this.config.bbBinaryPath,
-        proofFileName,
-        verificationKeyPath!,
-        logFunction,
-      );
+      const result = await verificationFunction(proofFileName, verificationKeyPath!);
 
       if (result.status === BB_RESULT.FAILURE) {
         const errorMessage = `Failed to verify proof from key!`;
@@ -886,14 +877,15 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @returns The verification key data
    */
   private async getVerificationKeyDataForCircuit(circuitType: ServerProtocolArtifact): Promise<VerificationKeyData> {
-    let promise = this.verificationKeys.get(circuitType);
+    const flavor = getUltraHonkFlavorForCircuit(circuitType);
+    let promise = this.verificationKeys.get(`${flavor}_${circuitType}`);
     if (!promise) {
       promise = generateKeyForNoirCircuit(
         this.config.bbBinaryPath,
         this.config.bbWorkingDirectory,
         circuitType,
         ServerCircuitArtifacts[circuitType],
-        'vk',
+        flavor,
         logger.debug,
       ).then(result => {
         if (result.status === BB_RESULT.FAILURE) {
@@ -901,7 +893,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         }
         return extractVkData(result.vkPath!);
       });
-      this.verificationKeys.set(circuitType, promise);
+      this.verificationKeys.set(`${flavor}_${circuitType}`, promise);
     }
     const vk = await promise;
     return vk.clone();
@@ -916,10 +908,11 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     filePath: string,
     circuitType: ServerProtocolArtifact,
   ): Promise<VerificationKeyData> {
-    let promise = this.verificationKeys.get(circuitType);
+    const flavor = getUltraHonkFlavorForCircuit(circuitType);
+    let promise = this.verificationKeys.get(`${flavor}_${circuitType}`);
     if (!promise) {
       promise = extractVkData(filePath);
-      this.verificationKeys.set(circuitType, promise);
+      this.verificationKeys.set(`${flavor}_${circuitType}`, promise);
     }
     return promise;
   }
@@ -943,20 +936,13 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       fs.readFile(proofFieldsFilename, { encoding: 'utf-8' }),
     ]);
     const json = JSON.parse(proofString);
-    const vkData = await this.verificationKeys.get(circuitType);
-    if (!vkData) {
-      throw new Error(`Invalid verification key for ${circuitType}`);
-    }
+    const vkData = await this.getVerificationKeyDataForCircuit(circuitType);
     const numPublicInputs = vkData.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
     const fieldsWithoutPublicInputs = json
       .slice(0, 3)
       .map(Fr.fromString)
       .concat(json.slice(3 + numPublicInputs).map(Fr.fromString));
-    logger.debug(
-      `num pub inputs ${vkData.numPublicInputs} and without aggregation ${CIRCUITS_WITHOUT_AGGREGATION.has(
-        circuitType,
-      )}`,
-    );
+    logger.debug(`num pub inputs ${vkData.numPublicInputs} circuit=${circuitType}`);
 
     const proof = new RecursiveProof<PROOF_LENGTH>(
       fieldsWithoutPublicInputs,

package/src/verification_key/verification_key_data.ts

@@ -3,11 +3,9 @@ import {
   AvmVerificationKeyAsFields,
   AvmVerificationKeyData,
   Fr,
-  VERIFICATION_KEY_LENGTH_IN_FIELDS,
   VerificationKeyAsFields,
   VerificationKeyData,
 } from '@aztec/circuits.js';
-import { type Tuple } from '@aztec/foundation/serialize';
 
 import { strict as assert } from 'assert';
 import * as fs from 'fs/promises';
@@ -29,10 +27,8 @@ export async function extractVkData(vkDirectoryPath: string): Promise<Verificati
   const fields = fieldsJson.map(Fr.fromString);
   // The first item is the hash, this is not part of the actual VK
   const vkHash = fields[0];
-  assert(fields.length === VERIFICATION_KEY_LENGTH_IN_FIELDS, 'Invalid verification key length');
-  const vkAsFields = new VerificationKeyAsFields(fields as Tuple<Fr, typeof VERIFICATION_KEY_LENGTH_IN_FIELDS>, vkHash);
-  const vk = new VerificationKeyData(vkAsFields, rawBinary);
-  return vk;
+  const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+  return new VerificationKeyData(vkAsFields, rawBinary);
 }
 
 // TODO: This was adapted from the above function. A refactor might be needed.

package/src/verifier/bb_verifier.ts

@@ -22,6 +22,7 @@ import {
   verifyProof,
 } from '../bb/execute.js';
 import { type BBConfig } from '../config.js';
+import { getUltraHonkFlavorForCircuit } from '../honk.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
 
@@ -62,7 +63,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
       workingDirectory,
       circuit,
       ProtocolCircuitArtifacts[circuit],
-      'vk',
+      getUltraHonkFlavorForCircuit(circuit),
       logFn,
     ).then(result => {
       if (result.status === BB_RESULT.FAILURE) {
@@ -103,7 +104,13 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
         this.logger.debug(`${circuit} BB out - ${message}`);
       };
 
-      const result = await verifyProof(this.config.bbBinaryPath, proofFileName, verificationKeyPath!, logFunction);
+      const result = await verifyProof(
+        this.config.bbBinaryPath,
+        proofFileName,
+        verificationKeyPath!,
+        getUltraHonkFlavorForCircuit(circuit),
+        logFunction,
+      );
 
       if (result.status === BB_RESULT.FAILURE) {
         const errorMessage = `Failed to verify ${circuit} proof!`;