@aztec/bb-prover 0.0.1-commit.b655e406 → 0.0.1-commit.d1f2d6c

package/src/prover/client/bb_private_kernel_prover.ts

@@ -1,4 +1,7 @@
-import { createLogger } from '@aztec/foundation/log';
+import { AztecClientBackend, type BackendOptions, Barretenberg } from '@aztec/bb.js';
+import { type LogLevel, type Logger, createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { serializeWitness } from '@aztec/noir-noirc_abi';
 import {
   convertHidingKernelPublicInputsToWitnessMapWithAbi,
   convertHidingKernelToRollupInputsToWitnessMapWithAbi,
@@ -37,15 +40,22 @@ import type {
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
 import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
-import type { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
+import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
 import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 
+import { ungzip } from 'pako';
+
+export type BBPrivateKernelProverOptions = Omit<BackendOptions, 'logger'> & { logger?: Logger };
 export abstract class BBPrivateKernelProver implements PrivateKernelProver {
+  private log: Logger;
+
   constructor(
     protected artifactProvider: ArtifactProvider,
     protected simulator: CircuitSimulator,
-    protected log = createLogger('bb-prover'),
-  ) {}
+    protected options: BBPrivateKernelProverOptions = {},
+  ) {
+    this.log = options.logger || createLogger('bb-prover:private-kernel');
+  }
 
   public async generateInitOutput(
     inputs: PrivateKernelInitCircuitPrivateInputs,
@@ -263,11 +273,38 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     return kernelProofOutput;
   }
 
-  public createChonkProof(_executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs> {
-    throw new Error('Not implemented');
+  public async createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs> {
+    const timer = new Timer();
+    this.log.info(`Generating ClientIVC proof...`);
+    const barretenberg = await Barretenberg.initSingleton({
+      ...this.options,
+      logger: this.options.logger?.[(process.env.LOG_LEVEL as LogLevel) || 'verbose'],
+    });
+    const backend = new AztecClientBackend(
+      executionSteps.map(step => ungzip(step.bytecode)),
+      barretenberg,
+    );
+
+    const [proof] = await backend.prove(
+      executionSteps.map(step => ungzip(serializeWitness(step.witness))),
+      executionSteps.map(step => step.vk),
+    );
+    this.log.info(`Generated ClientIVC proof`, {
+      eventName: 'client-ivc-proof-generation',
+      duration: timer.ms(),
+      proofSize: proof.length,
+    });
+    return ChonkProofWithPublicInputs.fromBufferArray(proof);
   }
 
-  public computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number> {
-    throw new Error('Not implemented');
+  public async computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number> {
+    // Note we do not pass the vk to the backend. This is unneeded for gate counts.
+    const barretenberg = await Barretenberg.initSingleton({
+      ...this.options,
+      logger: this.options.logger?.[(process.env.LOG_LEVEL as LogLevel) || 'verbose'],
+    });
+    const backend = new AztecClientBackend([ungzip(_bytecode)], barretenberg);
+    const gateCount = await backend.gates();
+    return gateCount[0];
   }
 }

package/src/prover/client/bundle.ts

@@ -0,0 +1,10 @@
+import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
+import type { CircuitSimulator } from '@aztec/simulator/client';
+
+import { BBPrivateKernelProver, type BBPrivateKernelProverOptions } from './bb_private_kernel_prover.js';
+
+export class BBBundlePrivateKernelProver extends BBPrivateKernelProver {
+  constructor(simulator: CircuitSimulator, options: BBPrivateKernelProverOptions = {}) {
+    super(new BundleArtifactProvider(), simulator, options);
+  }
+}

package/src/prover/client/lazy.ts

@@ -0,0 +1,10 @@
+import { LazyArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/lazy';
+import type { CircuitSimulator } from '@aztec/simulator/client';
+
+import { BBPrivateKernelProver, type BBPrivateKernelProverOptions } from './bb_private_kernel_prover.js';
+
+export class BBLazyPrivateKernelProver extends BBPrivateKernelProver {
+  constructor(simulator: CircuitSimulator, options: BBPrivateKernelProverOptions = {}) {
+    super(new LazyArtifactProvider(), simulator, options);
+  }
+}

package/src/prover/proof_utils.ts

@@ -7,7 +7,7 @@ import {
   PAIRING_POINTS_SIZE,
   ULTRA_KECCAK_PROOF_LENGTH,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
 import { ChonkProofWithPublicInputs, Proof, RecursiveProof } from '@aztec/stdlib/proofs';
 import type { VerificationKeyData } from '@aztec/stdlib/vks';

package/src/prover/server/bb_prover.ts

@@ -6,7 +6,7 @@ import {
   RECURSIVE_PROOF_LENGTH,
   ULTRA_KECCAK_PROOF_LENGTH,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';
@@ -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';
@@ -84,10 +82,9 @@ import {
   type RootRollupPublicInputs,
   type TxMergeRollupPrivateInputs,
   type TxRollupPublicInputs,
-  enhanceProofWithPiValidationFlag,
 } 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';
@@ -106,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');
@@ -192,14 +188,10 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }))
   public async getAvmProof(
     inputs: AvmCircuitInputs,
-    skipPublicInputsValidation: boolean = false,
-  ): 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);
-
-    // TODO(#14234)[Unconditional PIs validation]: remove next lines and directly return proofAndVk
-    proofAndVk.proof.proof = enhanceProofWithPiValidationFlag(proofAndVk.proof.proof, skipPublicInputsValidation);
-    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(
@@ -535,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;
@@ -562,7 +553,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         } satisfies CircuitProvingStats,
       );
 
-      return makeProofAndVerificationKey(avmProof, avmVK);
+      return avmProof;
     };
     return await this.runInDirectory(operation);
   }
@@ -636,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) => {
@@ -665,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

@@ -1,43 +1,47 @@
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 export const WITGEN_DELAY_MS: Record<ProvingRequestType, number> = {
-  [ProvingRequestType.PARITY_BASE]: 60,
-  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 650,
-  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 60_000,
-  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 40_000,
-  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 20_000,
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 60,
+  [ProvingRequestType.PARITY_BASE]: 1_600,
+  [ProvingRequestType.PARITY_ROOT]: 40,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 45,
+  [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]: 20_000,
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
-  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 650,
-  [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
-  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 400_000,
-  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 470_000,
-  [ProvingRequestType.PARITY_ROOT]: 100,
-  [ProvingRequestType.ROOT_ROLLUP]: 650,
-  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 0,
-  [ProvingRequestType.PUBLIC_VM]: 0,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 2_500, // Guess based on public
 };
 
 export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
-  [ProvingRequestType.PARITY_BASE]: 3_000,
+  [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]: 10_000,
+
+  // TBD
   [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 15_000,
-  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 55_000,
-  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 35_000,
-  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 15_000,
   [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]: 15_000,
   [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: 0,
-  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 15_000,
-  [ProvingRequestType.TX_MERGE_ROLLUP]: 0,
-  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: 145_000,
-  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: 160_000,
-  [ProvingRequestType.PARITY_ROOT]: 30_000,
-  [ProvingRequestType.ROOT_ROLLUP]: 15_000,
-  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 30_000,
-  [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/test/test_verifier.ts

@@ -2,7 +2,15 @@ import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '
 import type { Tx } from '@aztec/stdlib/tx';
 
 export class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
+  constructor(private verificationDelayMs?: number) {}
   verifyProof(_tx: Tx): Promise<IVCProofVerificationResult> {
+    if (this.verificationDelayMs !== undefined && this.verificationDelayMs > 0) {
+      return new Promise(resolve => {
+        setTimeout(() => {
+          resolve({ valid: true, durationMs: this.verificationDelayMs!, totalDurationMs: this.verificationDelayMs! });
+        }, this.verificationDelayMs);
+      });
+    }
     return Promise.resolve({ valid: true, durationMs: 0, totalDurationMs: 0 });
   }
 

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/fields';
+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

@@ -40,6 +40,9 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
   }
 
   public static async new(config: BBConfig, logger = createLogger('bb-prover:verifier')) {
+    if (!config.bbWorkingDirectory) {
+      throw new Error(`Barretenberg working directory (BB_WORKING_DIRECTORY) is not set`);
+    }
     await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
     return new BBCircuitVerifier(config, logger);
   }
@@ -99,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);
 
@@ -115,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));

package/dest/prover/client/native/bb_native_private_kernel_prover.d.ts

@@ -1,23 +0,0 @@
-import { type Logger } from '@aztec/foundation/log';
-import type { CircuitSimulator } from '@aztec/simulator/server';
-import { type PrivateExecutionStep } from '@aztec/stdlib/kernel';
-import type { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
-import type { BBConfig } from '../../../config.js';
-import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
-/**
- * This proof creator implementation uses the native bb binary.
- */
-export declare class BBNativePrivateKernelProver extends BBPrivateKernelProver {
-    private bbBinaryPath;
-    private bbWorkingDirectory;
-    private skipCleanup;
-    protected simulator: CircuitSimulator;
-    protected log: Logger;
-    private constructor();
-    static new(config: BBConfig, simulator: CircuitSimulator, log?: Logger): Promise<BBNativePrivateKernelProver>;
-    private _createChonkProof;
-    createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs>;
-    computeGateCountForCircuit(bytecode: Buffer, circuitName: string): Promise<number>;
-    private runInDirectory;
-}
-//# sourceMappingURL=bb_native_private_kernel_prover.d.ts.map

package/dest/prover/client/native/bb_native_private_kernel_prover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bb_native_private_kernel_prover.d.ts","sourceRoot":"","sources":["../../../../src/prover/client/native/bb_native_private_kernel_prover.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,KAAK,oBAAoB,EAAkC,MAAM,sBAAsB,CAAC;AACjG,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAMvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,qBAAqB;IAElE,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,WAAW;cACA,SAAS,EAAE,gBAAgB;cAC3B,GAAG;IALxB,OAAO;WAUa,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,CAAC,EAAE,MAAM;YAWrE,iBAAiB;IAuBT,gBAAgB,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAQ7F,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBxG,OAAO,CAAC,cAAc;CAavB"}

package/dest/prover/client/native/bb_native_private_kernel_prover.js

@@ -1,66 +0,0 @@
-import { runInDirectory } from '@aztec/foundation/fs';
-import { createLogger } from '@aztec/foundation/log';
-import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
-import { serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { BB_RESULT, computeGateCountForCircuit, executeBbChonkProof } from '../../../bb/execute.js';
-import { readChonkProofFromOutputDirectory } from '../../proof_utils.js';
-import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
-/**
- * This proof creator implementation uses the native bb binary.
- */ export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
-    bbBinaryPath;
-    bbWorkingDirectory;
-    skipCleanup;
-    simulator;
-    log;
-    constructor(bbBinaryPath, bbWorkingDirectory, skipCleanup, simulator, log = createLogger('bb-prover:native')){
-        super(new BundleArtifactProvider(), simulator, log), this.bbBinaryPath = bbBinaryPath, this.bbWorkingDirectory = bbWorkingDirectory, this.skipCleanup = skipCleanup, this.simulator = simulator, this.log = log;
-    }
-    static async new(config, simulator, log) {
-        await fs.mkdir(config.bbWorkingDirectory, {
-            recursive: true
-        });
-        return new BBNativePrivateKernelProver(config.bbBinaryPath, config.bbWorkingDirectory, !!config.bbSkipCleanup, simulator, log);
-    }
-    async _createChonkProof(directory, executionSteps) {
-        const inputsPath = path.join(directory, 'ivc-inputs.msgpack');
-        await fs.writeFile(inputsPath, serializePrivateExecutionSteps(executionSteps));
-        const provingResult = await executeBbChonkProof(this.bbBinaryPath, directory, inputsPath, this.log.info);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            this.log.error(`Failed to generate chonk proof`);
-            throw new Error(provingResult.reason);
-        }
-        const proof = await readChonkProofFromOutputDirectory(directory);
-        this.log.info(`Generated Chonk proof`, {
-            duration: provingResult.durationMs,
-            eventName: 'circuit-proving'
-        });
-        return proof;
-    }
-    async createChonkProof(executionSteps) {
-        this.log.info(`Generating Chonk proof`);
-        const operation = async (directory)=>{
-            return await this._createChonkProof(directory, executionSteps);
-        };
-        return await this.runInDirectory(operation);
-    }
-    async computeGateCountForCircuit(bytecode, circuitName) {
-        const logFunction = (message)=>{
-            this.log.debug(`$bb gates ${circuitName} - ${message}`);
-        };
-        const result = await computeGateCountForCircuit(this.bbBinaryPath, this.bbWorkingDirectory, circuitName, bytecode, 'mega_honk', logFunction);
-        if (result.status === BB_RESULT.FAILURE) {
-            throw new Error(result.reason);
-        }
-        return result.circuitSize;
-    }
-    runInDirectory(fn) {
-        const log = this.log;
-        return runInDirectory(this.bbWorkingDirectory, (dir)=>fn(dir).catch((err)=>{
-                log.error(`Error running operation at ${dir}: ${err}`);
-                throw err;
-            }), this.skipCleanup, this.log);
-    }
-}

package/dest/prover/client/wasm/bb_wasm_private_kernel_prover.d.ts

@@ -1,15 +0,0 @@
-import type { ArtifactProvider } from '@aztec/noir-protocol-circuits-types/types';
-import type { CircuitSimulator } from '@aztec/simulator/client';
-import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
-import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
-import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
-export declare abstract class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
-    protected artifactProvider: ArtifactProvider;
-    protected simulator: CircuitSimulator;
-    private threads;
-    protected log: import("@aztec/foundation/log").Logger;
-    constructor(artifactProvider: ArtifactProvider, simulator: CircuitSimulator, threads?: number, log?: import("@aztec/foundation/log").Logger);
-    createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs>;
-    computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number>;
-}
-//# sourceMappingURL=bb_wasm_private_kernel_prover.d.ts.map

package/dest/prover/client/wasm/bb_wasm_private_kernel_prover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bb_wasm_private_kernel_prover.d.ts","sourceRoot":"","sources":["../../../../src/prover/client/wasm/bb_wasm_private_kernel_prover.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAIlE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,8BAAsB,yBAA0B,SAAQ,qBAAqB;cAEtD,gBAAgB,EAAE,gBAAgB;cAClC,SAAS,EAAE,gBAAgB;IAC9C,OAAO,CAAC,OAAO;cACI,GAAG;gBAHH,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,gBAAgB,EACtC,OAAO,GAAE,MAAU,EACR,GAAG,yCAAiC;IAKnC,gBAAgB,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAqB7F,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAa3G"}