@aztec/bb-prover 0.0.1-commit.03f7ef2 → 0.0.1-commit.04d373f

package/src/index.ts

@@ -2,7 +2,8 @@ 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';
 

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);
   }
 
   /**
@@ -89,10 +58,18 @@ export class ProverInstrumentation {
     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,
+      });
+    }
   }
 
   /**

package/src/prover/client/bb_private_kernel_prover.ts

@@ -1,12 +1,20 @@
-import { AztecClientBackend, Barretenberg } from '@aztec/bb.js';
-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,
+  convertPrivateKernelInit2InputsToWitnessMapWithAbi,
+  convertPrivateKernelInit2OutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInit3InputsToWitnessMapWithAbi,
+  convertPrivateKernelInit3OutputsFromWitnessMapWithAbi,
   convertPrivateKernelInitInputsToWitnessMapWithAbi,
   convertPrivateKernelInitOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInner2InputsToWitnessMapWithAbi,
+  convertPrivateKernelInner2OutputsFromWitnessMapWithAbi,
+  convertPrivateKernelInner3InputsToWitnessMapWithAbi,
+  convertPrivateKernelInner3OutputsFromWitnessMapWithAbi,
   convertPrivateKernelInnerInputsToWitnessMapWithAbi,
   convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
   convertPrivateKernelResetInputsToWitnessMapWithAbi,
@@ -32,7 +40,11 @@ import type {
   HidingKernelToRollupPrivateInputs,
   PrivateExecutionStep,
   PrivateKernelCircuitPublicInputs,
+  PrivateKernelInit2CircuitPrivateInputs,
+  PrivateKernelInit3CircuitPrivateInputs,
   PrivateKernelInitCircuitPrivateInputs,
+  PrivateKernelInner2CircuitPrivateInputs,
+  PrivateKernelInner3CircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
   PrivateKernelResetCircuitPrivateInputs,
   PrivateKernelSimulateOutput,
@@ -45,12 +57,17 @@ import type { CircuitSimulationStats, CircuitWitnessGenerationStats } from '@azt
 
 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,
@@ -74,6 +91,50 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     );
   }
 
+  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>> {
@@ -96,6 +157,50 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     );
   }
 
+  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>> {
@@ -271,26 +376,47 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
   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)),
-      await Barretenberg.initSingleton(),
+      barretenberg,
+      executionSteps.map(step => step.functionName),
     );
 
-    const [proof] = await backend.prove(
+    // 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: proof.length,
+      proofSize: result.proofFields.length,
+      compressedSize: result.compressedProof?.length,
     });
-    return ChonkProofWithPublicInputs.fromBufferArray(proof);
+
+    // 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 backend = new AztecClientBackend([ungzip(_bytecode)], await Barretenberg.initSingleton());
+    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

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

package/src/prover/client/lazy.ts

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

package/src/prover/proof_utils.ts

@@ -16,7 +16,7 @@ import assert from 'assert';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 
-import { PROOF_FILENAME, PUBLIC_INPUTS_FILENAME } from '../bb/execute.js';
+import { PROOF_FILENAME, PUBLIC_INPUTS_FILENAME } from '../bb/file_names.js';
 
 /**
  * Create a ChonkProof proof file.
@@ -113,3 +113,43 @@ export async function readProofsFromOutputDirectory<PROOF_LENGTH extends number>
     proofLength,
   );
 }
+
+/**
+ * Construct a RecursiveProof from in-memory proof and public input field arrays
+ * returned by the bb.js circuitProve API, without reading from files.
+ *
+ * @param proofFields - Proof fields as 32-byte Uint8Arrays from circuitProve.
+ * @param publicInputFields - Public input fields as 32-byte Uint8Arrays from circuitProve.
+ * @param vkData - Verification key data for the circuit.
+ * @param proofLength - Expected proof field count.
+ */
+export function constructRecursiveProofFromBuffers<PROOF_LENGTH extends number>(
+  proofFields: Uint8Array[],
+  publicInputFields: Uint8Array[],
+  vkData: VerificationKeyData,
+  proofLength: PROOF_LENGTH,
+): RecursiveProof<PROOF_LENGTH> {
+  assert(
+    proofLength == NESTED_RECURSIVE_PROOF_LENGTH ||
+      proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH ||
+      proofLength == ULTRA_KECCAK_PROOF_LENGTH,
+    `Proof length must be one of the expected proof lengths, received ${proofLength}`,
+  );
+
+  // Convert Uint8Array fields to Fr instances
+  const proofFieldsFr = proofFields.map(f => Fr.fromBuffer(Buffer.from(f)));
+
+  assert(
+    proofFieldsFr.length == proofLength,
+    `Proof fields length mismatch: ${proofFieldsFr.length} != ${proofLength}`,
+  );
+
+  // Reconstruct the binary proof with public inputs prepended (same format as file-based path)
+  const binaryPublicInputs = Buffer.concat(publicInputFields.map(f => Buffer.from(f)));
+  const binaryProof = Buffer.concat(proofFields.map(f => Buffer.from(f)));
+  const binaryProofWithPublicInputs = Buffer.concat([binaryPublicInputs, binaryProof]);
+
+  const numPublicInputs = getNumCustomPublicInputs(proofLength, vkData);
+
+  return new RecursiveProof(proofFieldsFr, new Proof(binaryProofWithPublicInputs, numPublicInputs), true, proofLength);
+}