@aztec/bb-prover 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/honk.ts

@@ -1,9 +1,9 @@
 import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
 
-export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_rollup_honk';
+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];
@@ -17,6 +17,7 @@ export function getUltraHonkFlavorForCircuit(artifact: UltraHonkServerProtocolAr
 export function getUltraHonkFlavorForCircuit(artifact: UltraRollupHonkServerProtocolArtifact): 'ultra_rollup_honk';
 export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor;
 export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor {
+  // STARKNET: how to allow for the distinction between keccak/starknet? ultra_keccak_honk is returned in both cases
   if (isUltraKeccakHonkCircuit(artifact)) {
     return 'ultra_keccak_honk';
   } else if (UltraHonkCircuits.includes(artifact as UltraHonkServerProtocolArtifact)) {

package/src/index.ts

@@ -2,7 +2,9 @@ export * from './prover/index.js';
 export * from './test/index.js';
 export * from './verifier/index.js';
 export * from './config.js';
-export * from './bb/execute.js';
+export * from './bb/file_names.js';
+export * from './bb/bb_js_backend.js';
 export * from './honk.js';
+export * from './verification_key/verification_key_data.js';
 
 export { type ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';

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,14 +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,
-      [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-    });
+    // 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,
+      });
+    }
   }
 
   /**
@@ -117,12 +93,11 @@ export class ProverInstrumentation {
    */
   recordSize(
     metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
-    circuitName: CircuitName | 'tubeCircuit',
+    circuitName: CircuitName,
     size: number,
   ) {
     this[metric].record(Math.ceil(size), {
       [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
-      [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
     });
   }
 

package/src/prover/client/bb_private_kernel_prover.ts

@@ -0,0 +1,423 @@
+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,
+  convertPrivateKernelInit2InputsToWitnessMapWithAbi,
+  convertPrivateKernelInit2OutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInit3InputsToWitnessMapWithAbi,
+  convertPrivateKernelInit3OutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInitInputsToWitnessMapWithAbi,
+  convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInner2InputsToWitnessMapWithAbi,
+  convertPrivateKernelInner2OutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInner3InputsToWitnessMapWithAbi,
+  convertPrivateKernelInner3OutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+  convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelResetInputsToWitnessMapWithAbi,
+  convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailInputsToWitnessMapWithAbi,
+  convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+  foreignCallHandler,
+  getPrivateKernelResetArtifactName,
+  updateResetCircuitSampleInputs,
+} from '@aztec/noir-protocol-circuits-types/client';
+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';
+import type {
+  HidingKernelToPublicPrivateInputs,
+  HidingKernelToRollupPrivateInputs,
+  PrivateExecutionStep,
+  PrivateKernelCircuitPublicInputs,
+  PrivateKernelInit2CircuitPrivateInputs,
+  PrivateKernelInit3CircuitPrivateInputs,
+  PrivateKernelInitCircuitPrivateInputs,
+  PrivateKernelInner2CircuitPrivateInputs,
+  PrivateKernelInner3CircuitPrivateInputs,
+  PrivateKernelInnerCircuitPrivateInputs,
+  PrivateKernelResetCircuitPrivateInputs,
+  PrivateKernelSimulateOutput,
+  PrivateKernelTailCircuitPrivateInputs,
+  PrivateKernelTailCircuitPublicInputs,
+} from '@aztec/stdlib/kernel';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
+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 options: BBPrivateKernelProverOptions = {},
+  ) {
+    this.log = options.logger || createLogger('bb-prover:private-kernel');
+  }
+
+  public async generateInitOutput(
+    inputs: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInitArtifact',
+      convertPrivateKernelInitInputsToWitnessMapWithAbi,
+      convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateInit(
+    inputs: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelInitArtifact',
+      convertPrivateKernelInitInputsToWitnessMapWithAbi,
+      convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateInit2Output(
+    inputs: PrivateKernelInit2CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInit2Artifact',
+      convertPrivateKernelInit2InputsToWitnessMapWithAbi,
+      convertPrivateKernelInit2OutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateInit2(
+    inputs: PrivateKernelInit2CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelInit2Artifact',
+      convertPrivateKernelInit2InputsToWitnessMapWithAbi,
+      convertPrivateKernelInit2OutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateInit3Output(
+    inputs: PrivateKernelInit3CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInit3Artifact',
+      convertPrivateKernelInit3InputsToWitnessMapWithAbi,
+      convertPrivateKernelInit3OutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateInit3(
+    inputs: PrivateKernelInit3CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelInit3Artifact',
+      convertPrivateKernelInit3InputsToWitnessMapWithAbi,
+      convertPrivateKernelInit3OutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateInnerOutput(
+    inputs: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInnerArtifact',
+      convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+      convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateInner(
+    inputs: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelInnerArtifact',
+      convertPrivateKernelInnerInputsToWitnessMapWithAbi,
+      convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateInner2Output(
+    inputs: PrivateKernelInner2CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInner2Artifact',
+      convertPrivateKernelInner2InputsToWitnessMapWithAbi,
+      convertPrivateKernelInner2OutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateInner2(
+    inputs: PrivateKernelInner2CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelInner2Artifact',
+      convertPrivateKernelInner2InputsToWitnessMapWithAbi,
+      convertPrivateKernelInner2OutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateInner3Output(
+    inputs: PrivateKernelInner3CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelInner3Artifact',
+      convertPrivateKernelInner3InputsToWitnessMapWithAbi,
+      convertPrivateKernelInner3OutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateInner3(
+    inputs: PrivateKernelInner3CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelInner3Artifact',
+      convertPrivateKernelInner3InputsToWitnessMapWithAbi,
+      convertPrivateKernelInner3OutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateResetOutput(
+    inputs: PrivateKernelResetCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    const variantInputs = inputs.trimToSizes();
+    const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
+    return await this.generateCircuitOutput(
+      variantInputs,
+      artifactName,
+      convertPrivateKernelResetInputsToWitnessMapWithAbi,
+      convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateReset(
+    inputs: PrivateKernelResetCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    updateResetCircuitSampleInputs(inputs);
+    const variantInputs = inputs.trimToSizes();
+    const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
+    return await this.simulateCircuitOutput(
+      variantInputs,
+      artifactName,
+      convertPrivateKernelResetInputsToWitnessMapWithAbi,
+      convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateTailOutput(
+    inputs: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (!inputs.isForPublic()) {
+      return await this.generateCircuitOutput(
+        inputs,
+        'PrivateKernelTailArtifact',
+        convertPrivateKernelTailInputsToWitnessMapWithAbi,
+        convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+      );
+    }
+    return await this.generateCircuitOutput(
+      inputs,
+      'PrivateKernelTailToPublicArtifact',
+      convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateTail(
+    inputs: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (!inputs.isForPublic()) {
+      return await this.simulateCircuitOutput(
+        inputs,
+        'PrivateKernelTailArtifact',
+        convertPrivateKernelTailInputsToWitnessMapWithAbi,
+        convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+      );
+    }
+    return await this.simulateCircuitOutput(
+      inputs,
+      'PrivateKernelTailToPublicArtifact',
+      convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateHidingToRollupOutput(
+    inputs: HidingKernelToRollupPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'HidingKernelToRollup',
+      convertHidingKernelToRollupInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async generateHidingToPublicOutput(
+    inputs: HidingKernelToPublicPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    return await this.generateCircuitOutput(
+      inputs,
+      'HidingKernelToPublic',
+      convertHidingKernelPublicInputsToWitnessMapWithAbi,
+      convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
+    );
+  }
+
+  public async simulateCircuitOutput<
+    I extends { toBuffer: () => Buffer },
+    O extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
+  >(
+    inputs: I,
+    circuitType: ClientProtocolArtifact,
+    convertInputs: (inputs: I, abi: Abi) => WitnessMap,
+    convertOutputs: (outputs: WitnessMap, abi: Abi) => O,
+  ): Promise<PrivateKernelSimulateOutput<O>> {
+    const compiledCircuit: NoirCompiledCircuitWithName =
+      await this.artifactProvider.getSimulatedClientCircuitArtifactByName(circuitType);
+
+    const witnessMap = convertInputs(inputs, compiledCircuit.abi);
+
+    const outputWitness = await this.simulator
+      .executeProtocolCircuit(witnessMap, compiledCircuit, foreignCallHandler)
+      .catch((err: Error) => {
+        this.log.debug(`Failed to simulate ${circuitType}`, {
+          circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+          error: err,
+        });
+        throw err;
+      });
+    const output = convertOutputs(outputWitness.witness, compiledCircuit.abi);
+
+    this.log.debug(`Simulated ${circuitType}`, {
+      eventName: 'circuit-simulation',
+      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+      duration: outputWitness.duration,
+      inputSize: inputs.toBuffer().length,
+      outputSize: output.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+
+    return this.makeEmptyKernelSimulateOutput<O>(output, circuitType);
+  }
+
+  public async generateCircuitOutput<
+    I extends { toBuffer: () => Buffer },
+    O extends PrivateKernelCircuitPublicInputs | PrivateKernelTailCircuitPublicInputs,
+  >(
+    inputs: I,
+    circuitType: ClientProtocolArtifact,
+    convertInputs: (inputs: I, abi: Abi) => WitnessMap,
+    convertOutputs: (outputs: WitnessMap, abi: Abi) => O,
+  ): Promise<PrivateKernelSimulateOutput<O>> {
+    this.log.debug(`Generating witness for ${circuitType}`);
+    const compiledCircuit: NoirCompiledCircuitWithName =
+      await this.artifactProvider.getClientCircuitArtifactByName(circuitType);
+
+    const witnessMap = convertInputs(inputs, compiledCircuit.abi);
+    const outputWitness = await this.simulator.executeProtocolCircuit(witnessMap, compiledCircuit, foreignCallHandler);
+    const output = convertOutputs(outputWitness.witness, compiledCircuit.abi);
+
+    this.log.debug(`Generated witness for ${circuitType}`, {
+      eventName: 'circuit-witness-generation',
+      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+      duration: outputWitness.duration,
+      inputSize: inputs.toBuffer().length,
+      outputSize: output.toBuffer().length,
+    } satisfies CircuitWitnessGenerationStats);
+
+    const verificationKey = await this.artifactProvider.getCircuitVkByName(circuitType);
+    const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+
+    const kernelOutput: PrivateKernelSimulateOutput<O> = {
+      publicInputs: output,
+      verificationKey,
+      outputWitness: outputWitness.witness,
+      bytecode,
+    };
+    return kernelOutput;
+  }
+
+  public async makeEmptyKernelSimulateOutput<
+    PublicInputsType extends PrivateKernelTailCircuitPublicInputs | PrivateKernelCircuitPublicInputs,
+  >(publicInputs: PublicInputsType, circuitType: ClientProtocolArtifact) {
+    const kernelProofOutput: PrivateKernelSimulateOutput<PublicInputsType> = {
+      publicInputs,
+      verificationKey: await this.artifactProvider.getCircuitVkByName(circuitType),
+      outputWitness: new Map(),
+      bytecode: Buffer.from([]),
+    };
+    return kernelProofOutput;
+  }
+
+  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?.verbose,
+    });
+    const backend = new AztecClientBackend(
+      executionSteps.map(step => ungzip(step.bytecode)),
+      barretenberg,
+      executionSteps.map(step => step.functionName),
+    );
+
+    // Use compressed prove path to get both proof fields and compressed proof bytes
+    const result = await backend.prove(
+      executionSteps.map(step => ungzip(serializeWitness(step.witness))),
+      executionSteps.map(step => step.vk),
+      { compress: true },
+    );
+    this.log.info(`Generated ClientIVC proof`, {
+      eventName: 'client-ivc-proof-generation',
+      duration: timer.ms(),
+      proofSize: result.proofFields.length,
+      compressedSize: result.compressedProof?.length,
+    });
+
+    // Create ChonkProofWithPublicInputs from the flat field elements
+    const proofWithPubInputs = ChonkProofWithPublicInputs.fromBufferArray(result.proofFields);
+
+    // Attach compressed proof bytes to the ChonkProof (without public inputs).
+    // The compressed bytes are for the full proof WITH public inputs from bb;
+    // when deserializing, the decompressor will strip them to match CHONK_PROOF_LENGTH.
+    proofWithPubInputs.compressedProof = result.compressedProof ? Buffer.from(result.compressedProof) : undefined;
+
+    return proofWithPubInputs;
+  }
+
+  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);
+  }
+}

package/src/prover/index.ts

@@ -1,3 +1,2 @@
-export * from './bb_prover.js';
-export * from './bb_native_private_kernel_prover.js';
-export * from './client_ivc_proof_utils.js';
+export * from './server/bb_prover.js';
+export * from './proof_utils.js';