@aztec/bb-prover 3.0.3 → 4.0.0-devnet.1-patch.0

package/src/test/delay_values.ts

@@ -1,43 +1,47 @@
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 export const WITGEN_DELAY_MS: Record<ProvingRequestType, number> = {
-  [ProvingRequestType.PARITY_BASE]: 2_000,
-  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 30,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 60,
+  [ProvingRequestType.PARITY_BASE]: 1_600,
+  [ProvingRequestType.PARITY_ROOT]: 40,
   [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 45,
-  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 27,
   [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 18,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 27,
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 30,
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 36_000,
+  [ProvingRequestType.ROOT_ROLLUP]: 35,
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 2_500,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: 25,
+  [ProvingRequestType.PUBLIC_VM]: 0,
+
+  // TBD
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 30,
   [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 40_000,
   [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 20_000,
   [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 40_000,
-  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 36_600,
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
-  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 30,
-  [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
   [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 2_500, // Guess based on public
-  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 2_500,
-  [ProvingRequestType.PARITY_ROOT]: 40,
-  [ProvingRequestType.ROOT_ROLLUP]: 35,
-  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 60,
-  [ProvingRequestType.PUBLIC_VM]: 0,
 };
 
 export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
-  [ProvingRequestType.PARITY_BASE]: 16_300,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 16_300,
+  [ProvingRequestType.PARITY_BASE]: 15_300,
+  [ProvingRequestType.PARITY_ROOT]: 18_600,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 17_400,
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 4_500,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 9_200,
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 10_200,
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 37_100,
+  [ProvingRequestType.ROOT_ROLLUP]: 93_000,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: 10_000,
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 44_500,
+  [ProvingRequestType.PUBLIC_VM]: 180_000,
+
+  // TBD
   [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 15_000,
-  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 16_500,
-  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 9_210,
-  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 4_560,
   [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 35_000,
   [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: 15_000,
   [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: 35_000,
-  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 38_800,
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
-  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 9_760,
-  [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
-  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 45_000, // Guess based on public
-  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 45_000,
-  [ProvingRequestType.PARITY_ROOT]: 18_600,
-  [ProvingRequestType.ROOT_ROLLUP]: 84_000,
-  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 16_300,
-  [ProvingRequestType.PUBLIC_VM]: 0,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 22_000,
 };

package/src/test/index.ts

@@ -1,2 +1,3 @@
 export * from './test_circuit_prover.js';
 export * from './test_verifier.js';
+export * from './delay_values.js';

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,7 @@ import {
   type ObservableGauge,
   type TelemetryClient,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
@@ -36,49 +36,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 = createUpDownCounterWithDefault(meter, 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));