@aztec/bb-prover 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/bb/execute.ts

@@ -1,4 +1,4 @@
-import { sha256 } from '@aztec/foundation/crypto';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
@@ -6,6 +6,7 @@ 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 readline from 'readline';
 
 import type { UltraHonkFlavor } from '../honk.js';
 
@@ -15,7 +16,6 @@ export const PROOF_FILENAME = 'proof';
 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 CLIENT_IVC_PROOF_FILE_NAME = 'proof';
 
 export enum BB_RESULT {
   SUCCESS,
@@ -86,6 +86,7 @@ export function executeBB(
     logger(`BB concurrency: ${env.HARDWARE_CONCURRENCY}`);
     logger(`Executing BB with: ${pathToBB} ${command} ${args.join(' ')}`);
     const bb = proc.spawn(pathToBB, [command, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe'],
       env,
     });
 
@@ -100,14 +101,9 @@ export function executeBB(
       }, timeout);
     }
 
-    bb.stdout.on('data', data => {
-      const message = data.toString('utf-8').replace(/\n$/, '');
-      logger(message);
-    });
-    bb.stderr.on('data', data => {
-      const message = data.toString('utf-8').replace(/\n$/, '');
-      logger(message);
-    });
+    readline.createInterface({ input: bb.stdout }).on('line', logger);
+    readline.createInterface({ input: bb.stderr }).on('line', logger);
+
     bb.on('close', (exitCode: number, signal?: string) => {
       if (timeoutId) {
         clearTimeout(timeoutId);
@@ -121,7 +117,7 @@ export function executeBB(
   }).catch(_ => ({ status: BB_RESULT.FAILURE, exitCode: -1, signal: undefined }));
 }
 
-export async function executeBbClientIvcProof(
+export async function executeBbChonkProof(
   pathToBB: string,
   workingDirectory: string,
   inputsPath: string,
@@ -154,7 +150,7 @@ export async function executeBbClientIvcProof(
       log(`bb - ${message}`);
     };
 
-    const args = ['-o', outputPath, '--ivc_inputs_path', inputsPath, '-v', '--scheme', 'client_ivc'];
+    const args = ['-o', outputPath, '--ivc_inputs_path', inputsPath, '-v', '--scheme', 'chonk'];
     if (writeVk) {
       args.push('--write_vk');
     }
@@ -214,6 +210,7 @@ export async function generateProof(
   workingDirectory: string,
   circuitName: string,
   bytecode: Buffer,
+  verificationKey: Buffer,
   inputWitnessFile: string,
   flavor: UltraHonkFlavor,
   log: Logger,
@@ -225,8 +222,9 @@ export async function generateProof(
     return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
-  // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
+  // The bytecode is written to e.g. /workingDirectory/ParityBaseArtifact-bytecode
   const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
+  const vkPath = `${workingDirectory}/${circuitName}-vk`;
 
   // The proof is written to e.g. /workingDirectory/ultra_honk/proof
   const outputPath = `${workingDirectory}`;
@@ -240,16 +238,16 @@ export async function generateProof(
   }
 
   try {
-    // Write the bytecode to the working directory
-    await fs.writeFile(bytecodePath, bytecode);
-    // TODO(#15043): Avoid write_vk flag here.
+    // Write the bytecode and vk to the working directory
+    await Promise.all([fs.writeFile(bytecodePath, bytecode), fs.writeFile(vkPath, verificationKey)]);
     const args = getArgs(flavor).concat([
       '--disable_zk',
-      '--write_vk',
       '-o',
       outputPath,
       '-b',
       bytecodePath,
+      '-k',
+      vkPath,
       '-w',
       inputWitnessFile,
       '-v',
@@ -286,74 +284,6 @@ export async function generateProof(
   }
 }
 
-/**
- * Used for generating proofs of the tube circuit
- * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
- *
- * @returns An object containing a result indication, the location of the proof and the duration taken
- */
-export async function generateTubeProof(
-  pathToBB: string,
-  workingDirectory: string,
-  vkPath: string,
-  log: LogFn,
-): Promise<BBFailure | BBSuccess> {
-  // Check that the working directory exists
-  try {
-    await fs.access(workingDirectory);
-  } catch {
-    return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
-  }
-
-  // Paths for the inputs
-  const proofPath = join(workingDirectory, CLIENT_IVC_PROOF_FILE_NAME);
-
-  // The proof is written to e.g. /workingDirectory/proof
-  const outputPath = workingDirectory;
-  const filePresent = async (file: string) =>
-    await fs
-      .access(file, fs.constants.R_OK)
-      .then(_ => true)
-      .catch(_ => false);
-
-  const binaryPresent = await filePresent(pathToBB);
-  if (!binaryPresent) {
-    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
-  }
-
-  try {
-    if (!(await filePresent(proofPath))) {
-      return { status: BB_RESULT.FAILURE, reason: `Client IVC input files not present in  ${workingDirectory}` };
-    }
-    const args = ['-o', outputPath, '-k', vkPath, '-v'];
-
-    const timer = new Timer();
-    const logFunction = (message: string) => {
-      log(`TubeCircuit (prove) BB out - ${message}`);
-    };
-    const result = await executeBB(pathToBB, 'prove_tube', args, logFunction);
-    const durationMs = timer.ms();
-
-    if (result.status == BB_RESULT.SUCCESS) {
-      return {
-        status: BB_RESULT.SUCCESS,
-        durationMs,
-        proofPath: outputPath,
-        pkPath: undefined,
-        vkDirectoryPath: outputPath,
-      };
-    }
-    // Not a great error message here but it is difficult to decipher what comes from bb
-    return {
-      status: BB_RESULT.FAILURE,
-      reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
-    };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
-  }
-}
-
 /**
  * Used for generating AVM proofs.
  * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
@@ -423,7 +353,7 @@ export async function generateAvmProof(
         durationMs: duration,
         proofPath: join(outputPath, PROOF_FILENAME),
         pkPath: undefined,
-        vkDirectoryPath: outputPath,
+        vkDirectoryPath: undefined, // AVM VK is fixed in the binary.
       };
     }
     // Not a great error message here but it is difficult to decipher what comes from bb
@@ -442,7 +372,7 @@ export async function generateAvmProof(
  * @param pathToBB - The full path to the bb binary
  * @param proofFullPath - The full path to the proof to be verified
  * @param verificationKeyPath - The full path to the circuit verification key
- * @param log - A logging function
+ * @param logger - A logger
  * @returns An object containing a result indication and duration taken
  */
 export async function verifyProof(
@@ -450,16 +380,25 @@ export async function verifyProof(
   proofFullPath: string,
   verificationKeyPath: string,
   ultraHonkFlavor: UltraHonkFlavor,
-  log: Logger,
+  logger: Logger,
 ): Promise<BBFailure | BBSuccess> {
-  return await verifyProofInternal(
-    pathToBB,
+  // Specify the public inputs path in the case of UH verification.
+  // Take proofFullPath and remove the suffix past the / to get the directory.
+  const proofDir = proofFullPath.substring(0, proofFullPath.lastIndexOf('/'));
+  const publicInputsFullPath = join(proofDir, '/public_inputs');
+  logger.debug(`public inputs path: ${publicInputsFullPath}`);
+
+  const args = [
+    '-p',
     proofFullPath,
+    '-k',
     verificationKeyPath,
-    `verify`,
-    log,
-    getArgs(ultraHonkFlavor),
-  );
+    '-i',
+    publicInputsFullPath,
+    '--disable_zk',
+    ...getArgs(ultraHonkFlavor),
+  ];
+  return await verifyProofInternal(pathToBB, `verify`, args, logger);
 }
 
 export async function verifyAvmProof(
@@ -467,7 +406,6 @@ export async function verifyAvmProof(
   workingDirectory: string,
   proofFullPath: string,
   publicInputs: AvmCircuitPublicInputs,
-  verificationKeyPath: string,
   logger: Logger,
 ): Promise<BBFailure | BBSuccess> {
   const inputsBuffer = publicInputs.serializeWithMessagePack();
@@ -484,26 +422,24 @@ export async function verifyAvmProof(
     return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
   }
 
-  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', logger, [
-    '--avm-public-inputs',
-    avmInputsPath,
-  ]);
+  const args = ['-p', proofFullPath, '--avm-public-inputs', avmInputsPath];
+  return await verifyProofInternal(pathToBB, 'avm_verify', args, logger);
 }
 
 /**
- * Verifies a ClientIvcProof
+ * Verifies a ChonkProof
  * TODO(#7370) The verification keys should be supplied separately
  * @param pathToBB - The full path to the bb binary
  * @param targetPath - The path to the folder with the proof, accumulator, and verification keys
- * @param log - A logging function
+ * @param logger - A logger
  * @param concurrency - The number of threads to use for the verification
  * @returns An object containing a result indication and duration taken
  */
-export async function verifyClientIvcProof(
+export async function verifyChonkProof(
   pathToBB: string,
   proofPath: string,
   keyPath: string,
-  log: LogFn,
+  logger: Logger,
   concurrency = 1,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
@@ -514,43 +450,25 @@ export async function verifyClientIvcProof(
     return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
   }
 
-  try {
-    const args = ['--scheme', 'client_ivc', '-p', proofPath, '-k', keyPath, '-v'];
-    const timer = new Timer();
-    const command = 'verify';
-
-    const result = await executeBB(pathToBB, command, args, log, concurrency);
-    const duration = timer.ms();
-    if (result.status == BB_RESULT.SUCCESS) {
-      return { status: BB_RESULT.SUCCESS, durationMs: duration };
-    }
-    // Not a great error message here but it is difficult to decipher what comes from bb
-    return {
-      status: BB_RESULT.FAILURE,
-      reason: `Failed to verify proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
-      retry: !!result.signal,
-    };
-  } catch (error) {
-    return { status: BB_RESULT.FAILURE, reason: `${error}` };
-  }
+  const args = ['--scheme', 'chonk', '-p', proofPath, '-k', keyPath, '-v'];
+  return await verifyProofInternal(pathToBB, 'verify', args, logger, concurrency);
 }
 
 /**
  * Used for verifying proofs with BB
  * @param pathToBB - The full path to the bb binary
- * @param proofFullPath - The full path to the proof to be verified
- * @param verificationKeyPath - The full path to the circuit verification key
  * @param command - The BB command to execute (verify/avm_verify)
- * @param log - A logging function
+ * @param args - The arguments to pass to the command
+ * @param logger - A logger
+ * @param concurrency - The number of threads to use for the verification
  * @returns An object containing a result indication and duration taken
  */
 async function verifyProofInternal(
   pathToBB: string,
-  proofFullPath: string,
-  verificationKeyPath: string,
   command: 'verify' | 'avm_verify',
+  args: string[],
   logger: Logger,
-  extraArgs: string[] = [],
+  concurrency?: number,
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
     .access(pathToBB, fs.constants.R_OK)
@@ -565,28 +483,12 @@ async function verifyProofInternal(
   };
 
   try {
-    let args;
-
-    if (command == 'verify') {
-      // Specify the public inputs path in the case of UH verification.
-      // Take proofFullPath and remove the suffix past the / to get the directory.
-      const proofDir = proofFullPath.substring(0, proofFullPath.lastIndexOf('/'));
-      const publicInputsFullPath = join(proofDir, '/public_inputs');
-      logger.debug(`public inputs path: ${publicInputsFullPath}`);
-
-      args = ['-p', proofFullPath, '-k', verificationKeyPath, '-i', publicInputsFullPath, '--disable_zk', ...extraArgs];
-    } else {
-      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 finalArgs = loggingArg !== '' ? [...args, loggingArg] : args;
 
     const timer = new Timer();
-    const result = await executeBB(pathToBB, command, args, logFunction);
+    const result = await executeBB(pathToBB, command, finalArgs, logFunction, concurrency);
     const duration = timer.ms();
     if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, durationMs: duration };
@@ -679,7 +581,7 @@ export async function computeGateCountForCircuit(
     return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
-  // The bytecode is written to e.g. /workingDirectory/BaseParityArtifact-bytecode
+  // The bytecode is written to e.g. /workingDirectory/ParityBaseArtifact-bytecode
   const bytecodePath = `${workingDirectory}/${circuitName}-bytecode`;
 
   const binaryPresent = await fs
@@ -705,7 +607,7 @@ export async function computeGateCountForCircuit(
     const result = await executeBB(
       pathToBB,
       'gates',
-      ['--scheme', flavor === 'mega_honk' ? 'client_ivc' : 'ultra_honk', '-b', bytecodePath, '-v'],
+      ['--scheme', flavor === 'mega_honk' ? 'chonk' : 'ultra_honk', '-b', bytecodePath, '-v'],
       logHandler,
     );
     const duration = timer.ms();

package/src/honk.ts

@@ -3,7 +3,7 @@ import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types
 export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_starknet_honk' | 'ultra_rollup_honk';
 
 const UltraKeccakHonkCircuits = ['RootRollupArtifact'] as const satisfies ServerProtocolArtifact[];
-const UltraHonkCircuits = ['BaseParityArtifact', 'RootParityArtifact'] as const satisfies ServerProtocolArtifact[];
+const UltraHonkCircuits = ['ParityBaseArtifact', 'ParityRootArtifact'] as const satisfies ServerProtocolArtifact[];
 
 export type UltraKeccakHonkServerProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number];
 export type UltraHonkServerProtocolArtifact = (typeof UltraHonkCircuits)[number];

package/src/instrumentation.ts

@@ -7,7 +7,6 @@ import {
   Metrics,
   type TelemetryClient,
   type Tracer,
-  ValueType,
 } from '@aztec/telemetry-client';
 
 /**
@@ -31,51 +30,21 @@ export class ProverInstrumentation {
     this.tracer = telemetry.getTracer(name);
     const meter = telemetry.getMeter(name);
 
-    this.simulationDuration = meter.createHistogram(Metrics.CIRCUIT_SIMULATION_DURATION, {
-      description: 'Records how long it takes to simulate a circuit',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.simulationDuration = meter.createHistogram(Metrics.CIRCUIT_SIMULATION_DURATION);
 
-    this.witGenDuration = meter.createHistogram(Metrics.CIRCUIT_WITNESS_GEN_DURATION, {
-      description: 'Records how long it takes to generate the partial witness for a circuit',
-      unit: 's',
-      valueType: ValueType.DOUBLE,
-    });
+    this.witGenDuration = meter.createHistogram(Metrics.CIRCUIT_WITNESS_GEN_DURATION);
 
-    this.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION, {
-      unit: 's',
-      description: 'Records how long it takes to prove a circuit',
-      valueType: ValueType.DOUBLE,
-    });
+    this.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION);
 
-    this.witGenInputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_INPUT_SIZE, {
-      unit: 'By',
-      description: 'Records the size of the input to the witness generation',
-      valueType: ValueType.INT,
-    });
+    this.witGenInputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_INPUT_SIZE);
 
-    this.witGenOutputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_OUTPUT_SIZE, {
-      unit: 'By',
-      description: 'Records the size of the output of the witness generation',
-      valueType: ValueType.INT,
-    });
+    this.witGenOutputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_OUTPUT_SIZE);
 
-    this.proofSize = meter.createGauge(Metrics.CIRCUIT_PROVING_PROOF_SIZE, {
-      unit: 'By',
-      description: 'Records the size of the proof generated for a circuit',
-      valueType: ValueType.INT,
-    });
+    this.proofSize = meter.createGauge(Metrics.CIRCUIT_PROVING_PROOF_SIZE);
 
-    this.circuitPublicInputCount = meter.createGauge(Metrics.CIRCUIT_PUBLIC_INPUTS_COUNT, {
-      description: 'Records the number of public inputs in a circuit',
-      valueType: ValueType.INT,
-    });
+    this.circuitPublicInputCount = meter.createGauge(Metrics.CIRCUIT_PUBLIC_INPUTS_COUNT);
 
-    this.circuitSize = meter.createGauge(Metrics.CIRCUIT_SIZE, {
-      description: 'Records the size of the circuit in gates',
-      valueType: ValueType.INT,
-    });
+    this.circuitSize = meter.createGauge(Metrics.CIRCUIT_SIZE);
   }
 
   /**
@@ -86,13 +55,21 @@ export class ProverInstrumentation {
    */
   recordDuration(
     metric: 'simulationDuration' | 'witGenDuration' | 'provingDuration',
-    circuitName: CircuitName | 'tubeCircuit',
+    circuitName: CircuitName,
     timerOrMS: Timer | number,
   ) {
-    const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
-    this[metric].record(s, {
-      [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
-    });
+    // Simulation duration is stored in ms, while the others are stored in seconds
+    if (metric === 'simulationDuration') {
+      const ms = typeof timerOrMS === 'number' ? timerOrMS : timerOrMS.ms();
+      this[metric].record(Math.trunc(ms), {
+        [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+      });
+    } else {
+      const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+      this[metric].record(s, {
+        [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+      });
+    }
   }
 
   /**
@@ -116,7 +93,7 @@ export class ProverInstrumentation {
    */
   recordSize(
     metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
-    circuitName: CircuitName | 'tubeCircuit',
+    circuitName: CircuitName,
     size: number,
   ) {
     this[metric].record(Math.ceil(size), {

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,
@@ -16,7 +19,11 @@ import {
   getPrivateKernelResetArtifactName,
   updateResetCircuitSampleInputs,
 } from '@aztec/noir-protocol-circuits-types/client';
-import type { ArtifactProvider, ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import {
+  type ArtifactProvider,
+  type ClientProtocolArtifact,
+  mapProtocolArtifactNameToCircuitName,
+} from '@aztec/noir-protocol-circuits-types/types';
 import type { Abi, WitnessMap } from '@aztec/noir-types';
 import type { CircuitSimulator } from '@aztec/simulator/client';
 import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
@@ -33,17 +40,22 @@ import type {
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
 import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
-import type { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
 import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 
-import { mapProtocolArtifactNameToCircuitName } from '../../stats.js';
+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,
@@ -261,11 +273,39 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     return kernelProofOutput;
   }
 
-  public createClientIvcProof(_executionSteps: PrivateExecutionStep[]): Promise<ClientIvcProof> {
-    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,
+      executionSteps.map(step => step.functionName),
+    );
+
+    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, [_circuitName]);
+    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);
+  }
+}