@aztec/bb-prover 0.70.0 → 0.72.1

package/src/prover/bb_prover.ts

@@ -23,7 +23,6 @@ import {
   RecursiveProof,
   type RootParityInputs,
   TUBE_PROOF_LENGTH,
-  type VerificationKeyAsFields,
   type VerificationKeyData,
   makeRecursiveProofFromBinary,
 } from '@aztec/circuits.js';
@@ -69,8 +68,9 @@ import {
   convertSingleTxBlockRootRollupInputsToWitnessMap,
   convertSingleTxBlockRootRollupOutputsFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types/server';
+import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
 import { NativeACVMSimulator } from '@aztec/simulator/server';
-import { Attributes, type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { type WitnessMap } from '@noir-lang/types';
 import { assert } from 'console';
@@ -86,7 +86,6 @@ import {
   PROOF_FILENAME,
   VK_FILENAME,
   generateAvmProof,
-  generateKeyForNoirCircuit,
   generateProof,
   generateTubeProof,
   verifyAvmProof,
@@ -114,11 +113,6 @@ export interface BBProverConfig extends BBConfig, ACVMConfig {
  * Prover implementation that uses barretenberg native proving
  */
 export class BBNativeRollupProver implements ServerCircuitProver {
-  private verificationKeys = new Map<
-    `ultra${'_keccak_' | '_' | '_rollup_'}honk_${ServerProtocolArtifact}`,
-    Promise<VerificationKeyData>
-  >();
-
   private instrumentation: ProverInstrumentation;
 
   constructor(private config: BBProverConfig, telemetry: TelemetryClient) {
@@ -129,7 +123,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     return this.instrumentation.tracer;
   }
 
-  static async new(config: BBProverConfig, telemetry: TelemetryClient) {
+  static async new(config: BBProverConfig, telemetry: TelemetryClient = getTelemetryClient()) {
     await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
     await fs.mkdir(config.acvmWorkingDirectory, { recursive: true });
     await fs.access(config.bbBinaryPath, fs.constants.R_OK);
@@ -157,7 +151,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertBaseParityOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('BaseParityArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('BaseParityArtifact');
     await this.verifyProof('BaseParityArtifact', proof.binaryProof);
 
     return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
@@ -180,7 +174,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertRootParityOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('RootParityArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('RootParityArtifact');
     await this.verifyProof('RootParityArtifact', proof.binaryProof);
 
     return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
@@ -222,7 +216,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertPrivateBaseRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit(artifactName);
+    const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
 
     await this.verifyProof(artifactName, proof.binaryProof);
 
@@ -249,7 +243,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertPublicBaseRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit(artifactName);
+    const verificationKey = this.getVerificationKeyDataForCircuit(artifactName);
 
     await this.verifyProof(artifactName, proof.binaryProof);
 
@@ -274,7 +268,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertMergeRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('MergeRollupArtifact');
 
     await this.verifyProof('MergeRollupArtifact', proof.binaryProof);
 
@@ -299,7 +293,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertBlockRootRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
 
     await this.verifyProof('BlockRootRollupArtifact', proof.binaryProof);
 
@@ -319,7 +313,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertSingleTxBlockRootRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('SingleTxBlockRootRollupArtifact');
 
     await this.verifyProof('SingleTxBlockRootRollupArtifact', proof.binaryProof);
 
@@ -344,7 +338,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertEmptyBlockRootRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
 
     await this.verifyProof('EmptyBlockRootRollupArtifact', proof.binaryProof);
 
@@ -369,7 +363,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       convertBlockMergeRollupOutputsFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('BlockMergeRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('BlockMergeRollupArtifact');
 
     await this.verifyProof('BlockMergeRollupArtifact', proof.binaryProof);
 
@@ -393,7 +387,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
     const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit('RootRollupArtifact');
+    const verificationKey = this.getVerificationKeyDataForCircuit('RootRollupArtifact');
 
     await this.verifyProof('RootRollupArtifact', proof);
 
@@ -409,7 +403,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     convertInput: (input: Input) => WitnessMap,
     convertOutput: (outputWitness: WitnessMap) => Output,
     workingDirectory: string,
-  ): Promise<{ circuitOutput: Output; vkData: VerificationKeyData; provingResult: BBSuccess }> {
+  ): Promise<{ circuitOutput: Output; provingResult: BBSuccess }> {
     // Have the ACVM write the partial witness here
     const outputWitnessFile = path.join(workingDirectory, 'partial-witness.gz');
 
@@ -462,12 +456,8 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       throw new ProvingError(provingResult.reason, provingResult, provingResult.retry);
     }
 
-    // Ensure our vk cache is up to date
-    const vkData = await this.updateVerificationKeyAfterProof(provingResult.vkPath!, circuitType);
-
     return {
       circuitOutput: output,
-      vkData,
       provingResult,
     };
   }
@@ -479,15 +469,17 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     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);
+      const { provingResult, circuitOutput: output } = await this.generateProofWithBB(
+        input,
+        circuitType,
+        convertInput,
+        convertOutput,
+        bbWorkingDirectory,
+      );
 
       // Read the binary proof
       const rawProof = await fs.readFile(`${provingResult.proofPath!}/${PROOF_FILENAME}`);
-
+      const vkData = this.getVerificationKeyDataForCircuit(circuitType);
       const proof = new Proof(rawProof, vkData.numPublicInputs);
       const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
 
@@ -581,12 +573,12 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }
 
   public async getTubeProof(input: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    // this probably is gonna need to call client ivc
     const operation = async (bbWorkingDirectory: string) => {
       logger.debug(`createTubeProof: ${bbWorkingDirectory}`);
       const provingResult = await this.generateTubeProofWithBB(bbWorkingDirectory, input);
 
       // Read the proof as fields
+      // TODO(AD): this is the only remaining use of extractVkData.
       const tubeVK = await extractVkData(provingResult.vkPath!);
       const tubeProof = await this.readProofAsFields(provingResult.proofPath!, tubeVK, TUBE_PROOF_LENGTH);
 
@@ -631,12 +623,15 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   ): Promise<{ circuitOutput: CircuitOutputType; proof: RecursiveProof<PROOF_LENGTH> }> {
     // this probably is gonna need to call client ivc
     const operation = async (bbWorkingDirectory: string) => {
-      const {
-        provingResult,
-        vkData,
-        circuitOutput: output,
-      } = await this.generateProofWithBB(input, circuitType, convertInput, convertOutput, bbWorkingDirectory);
+      const { provingResult, circuitOutput: output } = await this.generateProofWithBB(
+        input,
+        circuitType,
+        convertInput,
+        convertOutput,
+        bbWorkingDirectory,
+      );
 
+      const vkData = this.getVerificationKeyDataForCircuit(circuitType);
       // Read the proof as fields
       const proof = await this.readProofAsFields(provingResult.proofPath!, vkData, proofLength);
 
@@ -674,7 +669,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param proof - The proof to be verified
    */
   public async verifyProof(circuitType: ServerProtocolArtifact, proof: Proof) {
-    const verificationKey = await this.getVerificationKeyDataForCircuit(circuitType);
+    const verificationKey = this.getVerificationKeyDataForCircuit(circuitType);
     return await this.verifyWithKey(getUltraHonkFlavorForCircuit(circuitType), verificationKey, proof);
   }
 
@@ -715,16 +710,6 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     await this.runInDirectory(operation);
   }
 
-  /**
-   * Returns the verification key for a circuit, will generate it if not cached internally
-   * @param circuitType - The type of circuit for which the verification key is required
-   * @returns The verification key
-   */
-  public async getVerificationKeyForCircuit(circuitType: ServerProtocolArtifact): Promise<VerificationKeyAsFields> {
-    const vkData = await this.getVerificationKeyDataForCircuit(circuitType);
-    return vkData.clone().keyAsFields;
-  }
-
   /**
    * 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
@@ -789,54 +774,16 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }
 
   /**
-   * Returns the verification key data for a circuit, will generate and cache it if not cached internally
+   * Returns the verification key data for a circuit.
    * @param circuitType - The type of circuit for which the verification key is required
    * @returns The verification key data
    */
-  private async getVerificationKeyDataForCircuit(circuitType: ServerProtocolArtifact): Promise<VerificationKeyData> {
-    const flavor = getUltraHonkFlavorForCircuit(circuitType);
-    let promise = this.verificationKeys.get(`${flavor}_${circuitType}`);
-    if (!promise) {
-      promise = generateKeyForNoirCircuit(
-        this.config.bbBinaryPath,
-        this.config.bbWorkingDirectory,
-        circuitType,
-        ServerCircuitArtifacts[circuitType],
-        SERVER_CIRCUIT_RECURSIVE,
-        flavor,
-        logger.debug,
-      ).then(result => {
-        if (result.status === BB_RESULT.FAILURE) {
-          throw new ProvingError(
-            `Failed to generate verification key for ${circuitType}, ${result.reason}`,
-            result,
-            result.retry,
-          );
-        }
-        return extractVkData(result.vkPath!);
-      });
-      this.verificationKeys.set(`${flavor}_${circuitType}`, promise);
-    }
-    const vk = await promise;
-    return vk.clone();
-  }
-
-  /**
-   * Ensures our verification key cache includes the key data located at the specified directory
-   * @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,
-  ): Promise<VerificationKeyData> {
-    const flavor = getUltraHonkFlavorForCircuit(circuitType);
-    let promise = this.verificationKeys.get(`${flavor}_${circuitType}`);
-    if (!promise) {
-      promise = extractVkData(filePath);
-      this.verificationKeys.set(`${flavor}_${circuitType}`, promise);
+  private getVerificationKeyDataForCircuit(circuitType: ServerProtocolArtifact): VerificationKeyData {
+    const vk = ServerCircuitVks[circuitType];
+    if (vk === undefined) {
+      throw new Error('Could not find VK for server artifact ' + circuitType);
     }
-    return promise;
+    return vk;
   }
 
   private async readProofAsFields<PROOF_LENGTH extends number>(

package/src/test/test_avm.ts

@@ -6,7 +6,6 @@ import {
   Gas,
   GlobalVariables,
   L2ToL1Message,
-  LogHash,
   MAX_ENQUEUED_CALLS_PER_CALL,
   MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
   MAX_L2_TO_L1_MSGS_PER_CALL,
@@ -17,11 +16,12 @@ import {
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_CALL,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
-  MAX_UNENCRYPTED_LOGS_PER_CALL,
+  MAX_PUBLIC_LOGS_PER_CALL,
   NoteHash,
   Nullifier,
   PublicCircuitPublicInputs,
   PublicInnerCallRequest,
+  PublicLog,
   ReadRequest,
   RevertCode,
   TreeLeafReadRequest,
@@ -73,7 +73,7 @@ export function getPublicInputs(result: PublicFunctionCallResult): PublicCircuit
       MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
     ),
     publicCallRequests: padArrayEnd([], PublicInnerCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_CALL),
-    unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
+    publicLogs: padArrayEnd(result.publicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_CALL),
     historicalHeader: BlockHeader.empty(),
     globalVariables: GlobalVariables.empty(),
     startGasLeft: Gas.from(result.startGasLeft),

package/src/test/test_circuit_prover.ts

@@ -64,7 +64,7 @@ import {
 } from '@aztec/noir-protocol-circuits-types/server';
 import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
 import { type SimulationProvider, WASMSimulatorWithBlobs, emitCircuitSimulationStats } from '@aztec/simulator/server';
-import { type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { type WitnessMap } from '@noir-lang/types';
 
@@ -81,9 +81,9 @@ export class TestCircuitProver implements ServerCircuitProver {
   private logger = createLogger('bb-prover:test-prover');
 
   constructor(
-    telemetry: TelemetryClient,
     private simulationProvider?: SimulationProvider,
     private opts: { proverTestDelayMs: number } = { proverTestDelayMs: 0 },
+    telemetry: TelemetryClient = getTelemetryClient(),
   ) {
     this.instrumentation = new ProverInstrumentation(telemetry, 'TestCircuitProver');
   }

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