@aztec/bb-prover 0.76.4 → 0.77.0-testnet-ignition.21

package/src/bb/execute.ts

@@ -1,19 +1,20 @@
-import { type AvmCircuitInputs, serializeWithMessagePack } from '@aztec/circuits.js';
 import { sha256 } from '@aztec/foundation/crypto';
-import { type LogFn, type Logger } from '@aztec/foundation/log';
+import type { LogFn, Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
 
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
 import { basename, dirname, join } from 'path';
 
-import { type UltraHonkFlavor } from '../honk.js';
+import type { UltraHonkFlavor } from '../honk.js';
 import { CLIENT_IVC_PROOF_FILE_NAME, CLIENT_IVC_VK_FILE_NAME } from '../prover/client_ivc_proof_utils.js';
 
 export const VK_FILENAME = 'vk';
 export const VK_FIELDS_FILENAME = 'vk_fields.json';
 export const PROOF_FILENAME = 'proof';
 export const PROOF_FIELDS_FILENAME = 'proof_fields.json';
+export const AVM_INPUTS_FILENAME = 'avm_inputs.bin';
 export const AVM_BYTECODE_FILENAME = 'avm_bytecode.bin';
 export const AVM_PUBLIC_INPUTS_FILENAME = 'avm_public_inputs.bin';
 export const AVM_HINTS_FILENAME = 'avm_hints.bin';
@@ -139,6 +140,7 @@ export async function executeBbClientIvcProof(
       'client_ivc',
       '--input_type',
       'runtime_stack',
+      '--write_vk',
     ];
 
     const timer = new Timer();
@@ -169,83 +171,17 @@ export async function executeBbClientIvcProof(
   }
 }
 
-/**
- * Used for generating verification keys of noir circuits.
- * It is assumed that the working directory is a temporary and/or random directory used solely for generating this VK.
- * @param pathToBB - The full path to the bb binary
- * @param workingDirectory - A working directory for use by bb
- * @param circuitName - An identifier for the circuit
- * @param bytecode - The compiled circuit bytecode
- * @param inputWitnessFile - The circuit input witness
- * @param log - A logging function
- * @returns An object containing a result indication, the location of the VK and the duration taken
- */
-export async function computeVerificationKey(
-  pathToBB: string,
-  workingDirectory: string,
-  circuitName: string,
-  bytecode: Buffer,
-  recursive: boolean,
-  flavor: UltraHonkFlavor | 'mega_honk',
-  log: LogFn,
-): Promise<BBFailure | BBSuccess> {
-  // Check that the working directory exists
-  try {
-    await fs.access(workingDirectory);
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
-  }
-
-  // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
-  const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
-
-  // The verification key is written to this path
-  const outputPath = `${workingDirectory}/vk`;
-
-  const binaryPresent = await fs
-    .access(pathToBB, fs.constants.R_OK)
-    .then(_ => true)
-    .catch(_ => false);
-  if (!binaryPresent) {
-    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
-  }
-
-  try {
-    // Write the bytecode to the working directory
-    await fs.writeFile(bytecodePath, bytecode);
-    const timer = new Timer();
-    const logFunction = (message: string) => {
-      log(`computeVerificationKey(${circuitName}) BB out - ${message}`);
-    };
-    const args = ['-o', outputPath, '-b', bytecodePath, '-v', recursive ? '--recursive' : ''];
-    let result = await executeBB(pathToBB, `write_vk_${flavor}`, args, logFunction);
-    if (result.status == BB_RESULT.FAILURE) {
-      return { status: BB_RESULT.FAILURE, reason: 'Failed writing VK.' };
+function getArgs(flavor: UltraHonkFlavor) {
+  switch (flavor) {
+    case 'ultra_honk': {
+      return ['--scheme', 'ultra_honk', '--oracle_hash', 'poseidon2'];
     }
-    result = await executeBB(
-      pathToBB,
-      `vk_as_fields_${flavor}`,
-      ['-o', outputPath + '_fields.json', '-k', outputPath, '-v'],
-      logFunction,
-    );
-    const duration = timer.ms();
-
-    if (result.status == BB_RESULT.SUCCESS) {
-      return {
-        status: BB_RESULT.SUCCESS,
-        durationMs: duration,
-        pkPath: undefined,
-        vkPath: `${outputPath}`,
-      };
+    case 'ultra_keccak_honk': {
+      return ['--scheme', 'ultra_honk', '--oracle_hash', 'keccak'];
+    }
+    case 'ultra_rollup_honk': {
+      return ['--scheme', 'ultra_honk', '--oracle_hash', 'poseidon2', '--ipa_accumulation'];
     }
-    // Not a great error message here but it is difficult to decipher what comes from bb
-    return {
-      status: BB_RESULT.FAILURE,
-      reason: `Failed to write VK. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
-    };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
   }
 }
 
@@ -294,12 +230,26 @@ export async function generateProof(
   try {
     // Write the bytecode to the working directory
     await fs.writeFile(bytecodePath, bytecode);
-    const args = ['-o', outputPath, '-b', bytecodePath, '-w', inputWitnessFile, '-v', recursive ? '--recursive' : ''];
+    const args = getArgs(flavor).concat([
+      '--output_format',
+      'bytes_and_fields',
+      '--write_vk',
+      '-o',
+      outputPath,
+      '-b',
+      bytecodePath,
+      '-w',
+      inputWitnessFile,
+      '-v',
+    ]);
+    if (recursive) {
+      args.push('--init_kzg_accumulator');
+    }
     const timer = new Timer();
     const logFunction = (message: string) => {
       log(`${circuitName} BB out - ${message}`);
     };
-    const result = await executeBB(pathToBB, `prove_${flavor}_output_all`, args, logFunction);
+    const result = await executeBB(pathToBB, `prove`, args, logFunction);
     const duration = timer.ms();
 
     if (result.status == BB_RESULT.SUCCESS) {
@@ -431,23 +381,22 @@ export async function generateAvmProofV2(
     return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
   }
 
-  const inputsBuffer = input.serializeForAvm2();
+  const inputsBuffer = input.serializeWithMessagePack();
 
   try {
     // Write the inputs to the working directory.
-    const avmInputsPath = join(workingDirectory, 'avm_inputs.bin');
+    const avmInputsPath = join(workingDirectory, AVM_INPUTS_FILENAME);
     await fs.writeFile(avmInputsPath, inputsBuffer);
     if (!(await filePresent(avmInputsPath))) {
       return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
     }
 
-    const args = [
-      '--avm-inputs',
-      avmInputsPath,
-      '-o',
-      outputPath,
-      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '',
-    ];
+    const args = ['--avm-inputs', avmInputsPath, '-o', outputPath];
+    const loggingArg =
+      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
+    if (loggingArg !== '') {
+      args.push(loggingArg);
+    }
     const timer = new Timer();
     const logFunction = (message: string) => {
       logger.verbose(`AvmCircuit (prove) BB out - ${message}`);
@@ -487,7 +436,7 @@ export async function generateAvmProofV2(
 export async function generateAvmProof(
   pathToBB: string,
   workingDirectory: string,
-  input: AvmCircuitInputs,
+  _input: AvmCircuitInputs,
   logger: Logger,
   checkCircuitOnly: boolean = false,
 ): Promise<BBFailure | BBSuccess> {
@@ -519,26 +468,24 @@ export async function generateAvmProof(
   try {
     // Write the inputs to the working directory.
 
-    await fs.writeFile(publicInputsPath, input.publicInputs.toBuffer());
-    if (!(await filePresent(publicInputsPath))) {
-      return { status: BB_RESULT.FAILURE, reason: `Could not write publicInputs at ${publicInputsPath}` };
-    }
-
-    await fs.writeFile(avmHintsPath, input.avmHints.toBuffer());
-    if (!(await filePresent(avmHintsPath))) {
-      return { status: BB_RESULT.FAILURE, reason: `Could not write avmHints at ${avmHintsPath}` };
+    // WARNING: Not writing the inputs since VM1 is disabled!
+    // await fs.writeFile(publicInputsPath, input.publicInputs.toBuffer());
+    // if (!(await filePresent(publicInputsPath))) {
+    //   return { status: BB_RESULT.FAILURE, reason: `Could not write publicInputs at ${publicInputsPath}` };
+    // }
+
+    // await fs.writeFile(avmHintsPath, input.avmHints.toBuffer());
+    // if (!(await filePresent(avmHintsPath))) {
+    //   return { status: BB_RESULT.FAILURE, reason: `Could not write avmHints at ${avmHintsPath}` };
+    // }
+
+    const args = ['--avm-public-inputs', publicInputsPath, '--avm-hints', avmHintsPath, '-o', outputPath];
+    const loggingArg =
+      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
+    if (loggingArg !== '') {
+      args.push(loggingArg);
     }
 
-    const args = [
-      '--avm-public-inputs',
-      publicInputsPath,
-      '--avm-hints',
-      avmHintsPath,
-      '-o',
-      outputPath,
-      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '',
-      checkCircuitOnly ? '--check-circuit-only' : '',
-    ];
     const timer = new Timer();
     const cmd = checkCircuitOnly ? 'check_circuit' : 'prove';
     const logFunction = (message: string) => {
@@ -582,7 +529,14 @@ export async function verifyProof(
   ultraHonkFlavor: UltraHonkFlavor,
   log: Logger,
 ): Promise<BBFailure | BBSuccess> {
-  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, `verify_${ultraHonkFlavor}`, log);
+  return await verifyProofInternal(
+    pathToBB,
+    proofFullPath,
+    verificationKeyPath,
+    `verify`,
+    log,
+    getArgs(ultraHonkFlavor),
+  );
 }
 
 /**
@@ -606,11 +560,11 @@ export async function verifyAvmProofV2(
   pathToBB: string,
   workingDirectory: string,
   proofFullPath: string,
-  publicInputs: any,
+  publicInputs: AvmCircuitPublicInputs,
   verificationKeyPath: string,
   logger: Logger,
 ): Promise<BBFailure | BBSuccess> {
-  const inputsBuffer = serializeWithMessagePack(publicInputs);
+  const inputsBuffer = publicInputs.serializeWithMessagePack();
 
   // Write the inputs to the working directory.
   const filePresent = async (file: string) =>
@@ -640,7 +594,8 @@ export async function verifyAvmProofV2(
  */
 export async function verifyClientIvcProof(
   pathToBB: string,
-  targetPath: string,
+  proofPath: string,
+  keyPath: string,
   log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
@@ -652,7 +607,7 @@ export async function verifyClientIvcProof(
   }
 
   try {
-    const args = ['-o', targetPath, '--scheme', 'client_ivc'];
+    const args = ['--scheme', 'client_ivc', '-p', proofPath, '-k', keyPath];
     const timer = new Timer();
     const command = 'verify';
     const result = await executeBB(pathToBB, command, args, log);
@@ -684,7 +639,7 @@ async function verifyProofInternal(
   pathToBB: string,
   proofFullPath: string,
   verificationKeyPath: string,
-  command: 'verify_ultra_honk' | 'verify_ultra_rollup_honk' | 'verify_ultra_keccak_honk' | 'avm_verify' | 'avm2_verify',
+  command: 'verify' | 'avm_verify' | 'avm2_verify',
   logger: Logger,
   extraArgs: string[] = [],
 ): Promise<BBFailure | BBSuccess> {
@@ -697,18 +652,16 @@ async function verifyProofInternal(
   }
 
   const logFunction = (message: string) => {
-    logger.verbose(`AvmCircuit (verify) BB out - ${message}`);
+    logger.verbose(`bb-prover (verify) BB out - ${message}`);
   };
 
   try {
-    const args = [
-      '-p',
-      proofFullPath,
-      '-k',
-      verificationKeyPath,
-      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '',
-      ...extraArgs,
-    ];
+    const args = ['-p', proofFullPath, '-k', verificationKeyPath, ...extraArgs];
+    const loggingArg =
+      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '';
+    if (loggingArg !== '') {
+      args.push(loggingArg);
+    }
     const timer = new Timer();
     const result = await executeBB(pathToBB, command, args, logFunction);
     const duration = timer.ms();
@@ -726,90 +679,6 @@ async function verifyProofInternal(
   }
 }
 
-/**
- * Used for verifying proofs of noir circuits
- * @param pathToBB - The full path to the bb binary
- * @param verificationKeyPath - The directory containing the binary verification key
- * @param verificationKeyFilename - The filename of the verification key
- * @param log - A logging function
- * @returns An object containing a result indication and duration taken
- */
-export async function writeVkAsFields(
-  pathToBB: string,
-  verificationKeyPath: string,
-  verificationKeyFilename: string,
-  log: LogFn,
-): Promise<BBFailure | BBSuccess> {
-  const binaryPresent = await fs
-    .access(pathToBB, fs.constants.R_OK)
-    .then(_ => true)
-    .catch(_ => false);
-  if (!binaryPresent) {
-    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
-  }
-
-  try {
-    const args = ['-k', `${verificationKeyPath}/${verificationKeyFilename}`, '-v'];
-    const timer = new Timer();
-    const result = await executeBB(pathToBB, 'vk_as_fields_ultra_honk', args, log);
-    const duration = timer.ms();
-    if (result.status == BB_RESULT.SUCCESS) {
-      return { status: BB_RESULT.SUCCESS, durationMs: duration, vkPath: verificationKeyPath };
-    }
-    // Not a great error message here but it is difficult to decipher what comes from bb
-    return {
-      status: BB_RESULT.FAILURE,
-      reason: `Failed to create vk as fields. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
-    };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
-  }
-}
-
-/**
- * Used for verifying proofs of noir circuits
- * @param pathToBB - The full path to the bb binary
- * @param proofPath - The directory containing the binary proof
- * @param proofFileName - The filename of the proof
- * @param vkFileName - The filename of the verification key
- * @param log - A logging function
- * @returns An object containing a result indication and duration taken
- */
-export async function writeProofAsFields(
-  pathToBB: string,
-  proofPath: string,
-  proofFileName: string,
-  vkFilePath: string,
-  log: LogFn,
-): Promise<BBFailure | BBSuccess> {
-  const binaryPresent = await fs
-    .access(pathToBB, fs.constants.R_OK)
-    .then(_ => true)
-    .catch(_ => false);
-  if (!binaryPresent) {
-    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
-  }
-
-  try {
-    const args = ['-p', `${proofPath}/${proofFileName}`, '-k', vkFilePath, '-v'];
-    const timer = new Timer();
-    const result = await executeBB(pathToBB, 'proof_as_fields_honk', args, log);
-    const duration = timer.ms();
-    if (result.status == BB_RESULT.SUCCESS) {
-      return { status: BB_RESULT.SUCCESS, durationMs: duration, proofPath: proofPath };
-    }
-    // Not a great error message here but it is difficult to decipher what comes from bb
-    return {
-      status: BB_RESULT.FAILURE,
-      reason: `Failed to create proof as fields. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
-    };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
-  }
-}
-
 export async function generateContractForVerificationKey(
   pathToBB: string,
   vkFilePath: string,
@@ -834,9 +703,9 @@ export async function generateContractForVerificationKey(
 
   const res = await fsCache<BBSuccess | BBFailure>(outputDir, cacheKey, log, false, async () => {
     try {
-      const args = ['-k', vkFilePath, '-o', contractPath, '-v'];
+      const args = ['--scheme', 'ultra_honk', '-k', vkFilePath, '-o', contractPath, '-v'];
       const timer = new Timer();
-      const result = await executeBB(pathToBB, 'contract_ultra_honk', args, log);
+      const result = await executeBB(pathToBB, 'contract', args, log);
       const duration = timer.ms();
       if (result.status == BB_RESULT.SUCCESS) {
         return { status: BB_RESULT.SUCCESS, durationMs: duration, contractPath };
@@ -912,8 +781,8 @@ export async function computeGateCountForCircuit(
 
     const result = await executeBB(
       pathToBB,
-      flavor === 'mega_honk' ? `gates_for_ivc` : `gates`,
-      ['-b', bytecodePath, '-v'],
+      'gates',
+      ['--scheme', flavor === 'mega_honk' ? 'client_ivc' : 'ultra_honk', '-b', bytecodePath, '-v'],
       logHandler,
     );
     const duration = timer.ms();

package/src/honk.ts

@@ -1,4 +1,4 @@
-import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
+import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
 
 export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_rollup_honk';
 

package/src/index.ts

@@ -5,4 +5,4 @@ export * from './config.js';
 export * from './bb/execute.js';
 export * from './honk.js';
 
-export { type ClientProtocolCircuitVerifier } from '@aztec/circuit-types';
+export { type ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';

package/src/instrumentation.ts

@@ -1,5 +1,5 @@
-import { type CircuitName } from '@aztec/circuit-types/stats';
-import { type Timer } from '@aztec/foundation/timer';
+import type { Timer } from '@aztec/foundation/timer';
+import type { CircuitName } from '@aztec/stdlib/stats';
 import {
   Attributes,
   type Gauge,
@@ -39,14 +39,14 @@ export class ProverInstrumentation {
 
     this.witGenDuration = meter.createHistogram(Metrics.CIRCUIT_WITNESS_GEN_DURATION, {
       description: 'Records how long it takes to generate the partial witness for a circuit',
-      unit: 'ms',
-      valueType: ValueType.INT,
+      unit: 's',
+      valueType: ValueType.DOUBLE,
     });
 
     this.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION, {
-      unit: 'ms',
+      unit: 's',
       description: 'Records how long it takes to prove a circuit',
-      valueType: ValueType.INT,
+      valueType: ValueType.DOUBLE,
     });
 
     this.witGenInputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_INPUT_SIZE, {
@@ -89,8 +89,8 @@ export class ProverInstrumentation {
     circuitName: CircuitName | 'tubeCircuit',
     timerOrMS: Timer | number,
   ) {
-    const ms = typeof timerOrMS === 'number' ? timerOrMS : timerOrMS.ms();
-    this[metric].record(Math.ceil(ms), {
+    const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+    this[metric].record(s, {
       [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
       [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
     });
@@ -103,8 +103,8 @@ export class ProverInstrumentation {
    * @param timerOrMS - The duration
    */
   recordAvmDuration(metric: 'witGenDuration' | 'provingDuration', appCircuitName: string, timerOrMS: Timer | number) {
-    const ms = typeof timerOrMS === 'number' ? timerOrMS : timerOrMS.s();
-    this[metric].record(Math.ceil(ms), {
+    const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+    this[metric].record(s, {
       [Attributes.APP_CIRCUIT_NAME]: appCircuitName,
     });
   }

package/src/prover/bb_native_private_kernel_prover.ts

@@ -1,17 +1,17 @@
-import { type ClientIvcProof } from '@aztec/circuits.js';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
-import { type SimulationProvider } from '@aztec/simulator/server';
+import type { SimulationProvider } from '@aztec/simulator/server';
+import type { ClientIvcProof } from '@aztec/stdlib/proofs';
 
 import { encode } from '@msgpack/msgpack';
 import { serializeWitness } from '@noir-lang/noirc_abi';
-import { type WitnessMap } from '@noir-lang/types';
+import type { WitnessMap } from '@noir-lang/types';
 import { promises as fs } from 'fs';
 import path from 'path';
 
 import { BB_RESULT, computeGateCountForCircuit, executeBbClientIvcProof } from '../bb/execute.js';
-import { type BBConfig } from '../config.js';
+import type { BBConfig } from '../config.js';
 import { BBPrivateKernelProver } from './bb_private_kernel_prover.js';
 import { readFromOutputDirectory } from './client_ivc_proof_utils.js';
 
@@ -113,6 +113,7 @@ export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
           throw err;
         }),
       this.skipCleanup,
+      this.log,
     );
   }
 }

package/src/prover/bb_private_kernel_prover.ts

@@ -1,14 +1,3 @@
-import { type PrivateKernelProver, type PrivateKernelSimulateOutput } from '@aztec/circuit-types';
-import { type CircuitSimulationStats, type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
-import {
-  type ClientIvcProof,
-  type PrivateKernelCircuitPublicInputs,
-  type PrivateKernelInitCircuitPrivateInputs,
-  type PrivateKernelInnerCircuitPrivateInputs,
-  type PrivateKernelResetCircuitPrivateInputs,
-  type PrivateKernelTailCircuitPrivateInputs,
-  type PrivateKernelTailCircuitPublicInputs,
-} from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import {
@@ -25,12 +14,23 @@ import {
   getPrivateKernelResetArtifactName,
   updateResetCircuitSampleInputs,
 } from '@aztec/noir-protocol-circuits-types/client';
-import { type ArtifactProvider, type ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
-import { ClientCircuitVks } from '@aztec/noir-protocol-circuits-types/vks';
-import { type SimulationProvider } from '@aztec/simulator/client';
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
-
-import { type Abi, type WitnessMap } from '@noir-lang/types';
+import type { ArtifactProvider, ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import type { SimulationProvider } from '@aztec/simulator/client';
+import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
+import type {
+  PrivateKernelCircuitPublicInputs,
+  PrivateKernelInitCircuitPrivateInputs,
+  PrivateKernelInnerCircuitPrivateInputs,
+  PrivateKernelResetCircuitPrivateInputs,
+  PrivateKernelSimulateOutput,
+  PrivateKernelTailCircuitPrivateInputs,
+  PrivateKernelTailCircuitPublicInputs,
+} from '@aztec/stdlib/kernel';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { ClientIvcProof } from '@aztec/stdlib/proofs';
+import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
+
+import type { Abi, WitnessMap } from '@noir-lang/types';
 
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 
@@ -215,7 +215,7 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
       outputSize: output.toBuffer().length,
     } satisfies CircuitWitnessGenerationStats);
 
-    const verificationKey = ClientCircuitVks[circuitType].keyAsFields;
+    const verificationKey = (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields;
     const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
 
     const kernelOutput: PrivateKernelSimulateOutput<O> = {
@@ -227,12 +227,12 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     return kernelOutput;
   }
 
-  public makeEmptyKernelSimulateOutput<
+  public async makeEmptyKernelSimulateOutput<
     PublicInputsType extends PrivateKernelTailCircuitPublicInputs | PrivateKernelCircuitPublicInputs,
   >(publicInputs: PublicInputsType, circuitType: ClientProtocolArtifact) {
     const kernelProofOutput: PrivateKernelSimulateOutput<PublicInputsType> = {
       publicInputs,
-      verificationKey: ClientCircuitVks[circuitType].keyAsFields,
+      verificationKey: (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields,
       outputWitness: new Map(),
       bytecode: Buffer.from([]),
     };