@aztec/bb-prover 0.71.0 → 0.72.1

package/src/verifier/bb_verifier.ts

@@ -2,101 +2,40 @@ import { type ClientProtocolCircuitVerifier, Tx } from '@aztec/circuit-types';
 import { type CircuitVerificationStats } from '@aztec/circuit-types/stats';
 import { type Proof, type VerificationKeyData } from '@aztec/circuits.js';
 import { runInDirectory } from '@aztec/foundation/fs';
-import { type LogFn, type Logger, createLogger } from '@aztec/foundation/log';
-import { ServerCircuitArtifacts } from '@aztec/noir-protocol-circuits-types/server';
-import {
-  type ClientProtocolArtifact,
-  type ProtocolArtifact,
-  type ServerProtocolArtifact,
-} from '@aztec/noir-protocol-circuits-types/types';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type ClientProtocolArtifact, type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
 
 import { promises as fs } from 'fs';
 import * as path from 'path';
 
-import {
-  BB_RESULT,
-  PROOF_FILENAME,
-  VK_FILENAME,
-  generateContractForCircuit,
-  generateKeyForNoirCircuit,
-  verifyClientIvcProof,
-  verifyProof,
-} from '../bb/execute.js';
+import { BB_RESULT, PROOF_FILENAME, VK_FILENAME, verifyClientIvcProof, verifyProof } from '../bb/execute.js';
 import { type BBConfig } from '../config.js';
-import { type UltraKeccakHonkServerProtocolArtifact, getUltraHonkFlavorForCircuit } from '../honk.js';
+import { getUltraHonkFlavorForCircuit } from '../honk.js';
 import { writeToOutputDirectory } from '../prover/client_ivc_proof_utils.js';
-import { isProtocolArtifactRecursive, mapProtocolArtifactNameToCircuitName } from '../stats.js';
-import { extractVkData } from '../verification_key/verification_key_data.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 
 export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
-  private constructor(
-    private config: BBConfig,
-    private verificationKeys = new Map<ProtocolArtifact, Promise<VerificationKeyData>>(),
-    private logger: Logger,
-  ) {}
-
-  public static async new(
-    config: BBConfig,
-    initialCircuits: ServerProtocolArtifact[] = [],
-    logger = createLogger('bb-prover:verifier'),
-  ) {
-    await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
-    const keys = new Map<ProtocolArtifact, Promise<VerificationKeyData>>();
-    for (const circuit of initialCircuits) {
-      const vkData = await this.generateVerificationKey(
-        circuit,
-        config.bbBinaryPath,
-        config.bbWorkingDirectory,
-        logger.debug,
-      );
-      keys.set(circuit, Promise.resolve(vkData));
-    }
-    return new BBCircuitVerifier(config, keys, logger);
-  }
-
-  private static async generateVerificationKey(
-    circuit: ServerProtocolArtifact,
-    bbPath: string,
-    workingDirectory: string,
-    logFn: LogFn,
-  ) {
-    return await generateKeyForNoirCircuit(
-      bbPath,
-      workingDirectory,
-      circuit,
-      ServerCircuitArtifacts[circuit],
-      isProtocolArtifactRecursive(circuit),
-      getUltraHonkFlavorForCircuit(circuit),
-      logFn,
-    ).then(result => {
-      if (result.status === BB_RESULT.FAILURE) {
-        throw new Error(`Failed to created verification key for ${circuit}, ${result.reason}`);
-      }
+  private constructor(private config: BBConfig, private logger: Logger) {}
 
-      return extractVkData(result.vkPath!);
-    });
+  public static async new(config: BBConfig, logger = createLogger('bb-prover:verifier')) {
+    await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
+    return new BBCircuitVerifier(config, logger);
   }
 
-  public async getVerificationKeyData(circuit: ServerProtocolArtifact) {
-    let promise = this.verificationKeys.get(circuit);
-    if (!promise) {
-      promise = BBCircuitVerifier.generateVerificationKey(
-        circuit,
-        this.config.bbBinaryPath,
-        this.config.bbWorkingDirectory,
-        this.logger.debug,
-      );
+  public getVerificationKeyData(circuitType: ServerProtocolArtifact): VerificationKeyData {
+    const vk = ServerCircuitVks[circuitType];
+    if (vk === undefined) {
+      throw new Error('Could not find VK for server artifact ' + circuitType);
     }
-    this.verificationKeys.set(circuit, promise);
-    const vk = await promise;
-    return vk.clone();
+    return vk;
   }
 
   public async verifyProofForCircuit(circuit: ServerProtocolArtifact, proof: Proof) {
     const operation = async (bbWorkingDirectory: string) => {
       const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
       const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
-      const verificationKey = await this.getVerificationKeyData(circuit);
+      const verificationKey = this.getVerificationKeyData(circuit);
 
       this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
 
@@ -126,23 +65,6 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
     await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup);
   }
 
-  public async generateSolidityContract(circuit: UltraKeccakHonkServerProtocolArtifact, contractName: string) {
-    const result = await generateContractForCircuit(
-      this.config.bbBinaryPath,
-      this.config.bbWorkingDirectory,
-      circuit,
-      ServerCircuitArtifacts[circuit],
-      contractName,
-      this.logger.debug,
-    );
-
-    if (result.status === BB_RESULT.FAILURE) {
-      throw new Error(`Failed to create verifier contract for ${circuit}, ${result.reason}`);
-    }
-
-    return fs.readFile(result.contractPath!, 'utf-8');
-  }
-
   public async verifyProof(tx: Tx): Promise<boolean> {
     try {
       // TODO(#7370) The verification keys should be supplied separately and based on the expectedCircuit