@aztec/bb-prover 4.0.0-nightly.20260107 → 4.0.0-nightly.20260110

package/src/prover/server/bb_prover.ts

@@ -55,10 +55,8 @@ import { NativeACVMSimulator } from '@aztec/simulator/server';
 import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
 import { ProvingError } from '@aztec/stdlib/errors';
 import {
-  type ProofAndVerificationKey,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
-  makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
 import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
@@ -86,7 +84,7 @@ import {
   type TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitProvingStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
-import type { VerificationKeyData } from '@aztec/stdlib/vks';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { promises as fs } from 'fs';
@@ -105,9 +103,8 @@ import {
   verifyProof,
 } from '../../bb/execute.js';
 import type { ACVMConfig, BBConfig } from '../../config.js';
-import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../../honk.js';
+import { getUltraHonkFlavorForCircuit } from '../../honk.js';
 import { ProverInstrumentation } from '../../instrumentation.js';
-import { extractAvmVkData } from '../../verification_key/verification_key_data.js';
 import { readProofsFromOutputDirectory } from '../proof_utils.js';
 
 const logger = createLogger('bb-prover');
@@ -191,10 +188,10 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }))
   public async getAvmProof(
     inputs: AvmCircuitInputs,
-  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
-    const proofAndVk = await this.createAvmProof(inputs);
-    await this.verifyAvmProof(proofAndVk.proof.binaryProof, proofAndVk.verificationKey, inputs.publicInputs);
-    return proofAndVk;
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+    const proof = await this.createAvmProof(inputs);
+    await this.verifyAvmProof(proof.binaryProof, inputs.publicInputs);
+    return proof;
   }
 
   public async getPublicChonkVerifierProof(
@@ -530,11 +527,10 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
   private async createAvmProof(
     input: AvmCircuitInputs,
-  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
     const operation = async (bbWorkingDirectory: string) => {
       const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
 
-      const avmVK = await extractAvmVkData(provingResult.vkDirectoryPath!);
       const avmProof = await this.readAvmProofAsFields(provingResult.proofPath!);
 
       const circuitType = 'avm-circuit' as const;
@@ -557,7 +553,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         } satisfies CircuitProvingStats,
       );
 
-      return makeProofAndVerificationKey(avmProof, avmVK);
+      return avmProof;
     };
     return await this.runInDirectory(operation);
   }
@@ -631,28 +627,19 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    */
   public async verifyProof(circuitType: ServerProtocolArtifact, proof: Proof) {
     const verificationKey = this.getVerificationKeyDataForCircuit(circuitType);
-    return await this.verifyWithKey(getUltraHonkFlavorForCircuit(circuitType), verificationKey, proof);
-  }
-
-  public async verifyAvmProof(
-    proof: Proof,
-    verificationKey: VerificationKeyData,
-    publicInputs: AvmCircuitPublicInputs,
-  ) {
-    return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) =>
-      verifyAvmProof(this.config.bbBinaryPath, this.config.bbWorkingDirectory, proofPath, publicInputs, vkPath, logger),
+    return await this.verifyInternal(proof, verificationKey, (proofPath, vkPath) =>
+      verifyProof(this.config.bbBinaryPath, proofPath, vkPath, getUltraHonkFlavorForCircuit(circuitType), logger),
     );
   }
 
-  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),
+  public async verifyAvmProof(proof: Proof, publicInputs: AvmCircuitPublicInputs) {
+    return await this.verifyInternal(proof, /*verificationKey=*/ undefined, (proofPath, /*unused*/ _vkPath) =>
+      verifyAvmProof(this.config.bbBinaryPath, this.config.bbWorkingDirectory, proofPath, publicInputs, logger),
     );
   }
-
-  private async verifyWithKeyInternal(
+  private async verifyInternal(
     proof: Proof,
-    verificationKey: { keyAsBytes: Buffer },
+    verificationKey: { keyAsBytes: Buffer } | undefined,
     verificationFunction: (proofPath: string, vkPath: string) => Promise<BBFailure | BBSuccess>,
   ) {
     const operation = async (bbWorkingDirectory: string) => {
@@ -660,11 +647,13 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
       const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
       // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13189): Put this proof parsing logic in the proof class.
-      await fs.writeFile(publicInputsFileName, proof.buffer.slice(0, proof.numPublicInputs * 32));
-      await fs.writeFile(proofFileName, proof.buffer.slice(proof.numPublicInputs * 32));
-      await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+      await fs.writeFile(publicInputsFileName, proof.buffer.subarray(0, proof.numPublicInputs * 32));
+      await fs.writeFile(proofFileName, proof.buffer.subarray(proof.numPublicInputs * 32));
+      if (verificationKey !== undefined) {
+        await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+      }
 
-      const result = await verificationFunction(proofFileName, verificationKeyPath!);
+      const result = await verificationFunction(proofFileName, verificationKeyPath);
 
       if (result.status === BB_RESULT.FAILURE) {
         const errorMessage = `Failed to verify proof from key!`;

package/src/test/delay_values.ts

@@ -43,5 +43,5 @@ export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
   [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 15_000,
   [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 35_000,
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
-  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 45_000, // Guess based on public
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 22_000,
 };

package/src/test/test_circuit_prover.ts

@@ -1,6 +1,5 @@
 import {
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
-  AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -51,14 +50,18 @@ import type { WitnessMap } from '@aztec/noir-types';
 import { type CircuitSimulator, WASMSimulatorWithBlobs, emitCircuitSimulationStats } from '@aztec/simulator/server';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import {
-  type ProofAndVerificationKey,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
-  makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
 import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
-import { type Proof, ProvingRequestType, makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
+import {
+  type Proof,
+  ProvingRequestType,
+  RecursiveProof,
+  makeEmptyRecursiveProof,
+  makeRecursiveProof,
+} from '@aztec/stdlib/proofs';
 import {
   type BlockMergeRollupPrivateInputs,
   type BlockRollupPublicInputs,
@@ -81,7 +84,6 @@ import {
   type TxMergeRollupPrivateInputs,
   type TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
-import { VerificationKeyData } from '@aztec/stdlib/vks';
 import { type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { ProverInstrumentation } from '../instrumentation.js';
@@ -400,17 +402,12 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
-  public getAvmProof(
-    _inputs: AvmCircuitInputs,
-  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+  public getAvmProof(_inputs: AvmCircuitInputs): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
     // We can't simulate the AVM because we don't have enough context to do so (e.g., DBs).
-    // We just return an empty proof and VK data.
+    // We just return an empty proof.
     this.logger.debug('Skipping AVM simulation in TestCircuitProver.');
     return this.applyDelay(ProvingRequestType.PUBLIC_VM, () =>
-      makeProofAndVerificationKey(
-        makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
-        VerificationKeyData.makeFake(AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED),
-      ),
+      makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
     );
   }
 

package/src/verification_key/verification_key_data.ts

@@ -1,9 +1,7 @@
-import { AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
 
-import { strict as assert } from 'assert';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 
@@ -25,26 +23,3 @@ export async function extractVkData(vkDirectoryPath: string): Promise<Verificati
   const vkAsFields = await VerificationKeyAsFields.fromKey(fields);
   return new VerificationKeyData(vkAsFields, rawBinary);
 }
-
-/**
- * Reads the verification key data stored in a binary file at the specified directory location and parses into a VerificationKeyData.
- * We do not assume any JSON file available but only the binary version, contrary to the above extractVkData() method.
- * @param vkDirectoryPath - The directory containing the verification key binary data file.
- * @returns The verification key data
- */
-export async function extractAvmVkData(vkDirectoryPath: string): Promise<VerificationKeyData> {
-  const rawBinary = await fs.readFile(path.join(vkDirectoryPath, VK_FILENAME));
-
-  const numFields = rawBinary.length / Fr.SIZE_IN_BYTES;
-  assert(numFields <= AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, 'Invalid AVM verification key length');
-  const reader = BufferReader.asReader(rawBinary);
-  const fieldsArray = reader.readArray(numFields, Fr);
-
-  const fieldsArrayPadded = fieldsArray.concat(
-    Array(AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED - fieldsArray.length).fill(new Fr(0)),
-  );
-  const vkAsFields = await VerificationKeyAsFields.fromKey(fieldsArrayPadded);
-  // TODO(#16644): We should have a different type for AVM verification keys since we don't have circuit size or num public inputs in AVM VKs.
-  const vk = new VerificationKeyData(vkAsFields, rawBinary);
-  return vk;
-}

package/src/verifier/bb_verifier.ts

@@ -102,10 +102,6 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
 
       // Block below is almost copy-pasted from verifyProofForCircuit
       const operation = async (bbWorkingDirectory: string) => {
-        const logFunction = (message: string) => {
-          this.logger.debug(`${proofType} BB out - ${message}`);
-        };
-
         const proofPath = path.join(bbWorkingDirectory, PROOF_FILENAME);
         await writeChonkProofToPath(tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields()), proofPath);
 
@@ -118,7 +114,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
           this.config.bbBinaryPath,
           proofPath,
           verificationKeyPath,
-          logFunction,
+          this.logger,
           this.config.bbIVCConcurrency,
         );
         verificationDuration = timer.ms();

package/src/verifier/queued_chonk_verifier.ts

@@ -10,7 +10,6 @@ import {
   type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
@@ -36,49 +35,18 @@ class IVCVerifierMetrics {
   constructor(client: TelemetryClient, name = 'QueuedIVCVerifier') {
     const meter = client.getMeter(name);
 
-    this.ivcVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TIME, {
-      unit: 'ms',
-      description: 'Duration to verify chonk proofs',
-      valueType: ValueType.INT,
-    });
+    this.ivcVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TIME);
 
-    this.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME, {
-      unit: 'ms',
-      description: 'Total duration to verify chonk proofs, including serde',
-      valueType: ValueType.INT,
-    });
+    this.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME);
 
-    this.ivcFailureCount = meter.createUpDownCounter(Metrics.IVC_VERIFIER_FAILURE_COUNT, {
-      description: 'Count of failed IVC proof verifications',
-      valueType: ValueType.INT,
-    });
+    this.ivcFailureCount = meter.createUpDownCounter(Metrics.IVC_VERIFIER_FAILURE_COUNT);
 
     this.aggDurationMetrics = {
-      avg: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_AVG, {
-        valueType: ValueType.DOUBLE,
-        description: 'AVG ivc verification',
-        unit: 'ms',
-      }),
-      max: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MAX, {
-        valueType: ValueType.DOUBLE,
-        description: 'MAX ivc verification',
-        unit: 'ms',
-      }),
-      min: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MIN, {
-        valueType: ValueType.DOUBLE,
-        description: 'MIN ivc verification',
-        unit: 'ms',
-      }),
-      p50: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P50, {
-        valueType: ValueType.DOUBLE,
-        description: 'P50 ivc verification',
-        unit: 'ms',
-      }),
-      p90: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P90, {
-        valueType: ValueType.DOUBLE,
-        description: 'P90 ivc verification',
-        unit: 'ms',
-      }),
+      avg: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_AVG),
+      max: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MAX),
+      min: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_MIN),
+      p50: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P50),
+      p90: meter.createObservableGauge(Metrics.IVC_VERIFIER_AGG_DURATION_P90),
     };
 
     meter.addBatchObservableCallback(this.aggregate, Object.values(this.aggDurationMetrics));