@aztec/bb-prover 0.0.0-test.1 → 0.0.1-commit.21caa21

package/src/verification_key/verification_key_data.ts

@@ -1,13 +1,13 @@
-import { AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/constants';
+import { AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { hashVK } from '@aztec/stdlib/hash';
+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';
 
-import { VK_FIELDS_FILENAME, VK_FILENAME } from '../bb/execute.js';
+import { VK_FILENAME } from '../bb/execute.js';
 
 /**
  * Reads the verification key data stored at the specified location and parses into a VerificationKeyData
@@ -15,31 +15,36 @@ import { VK_FIELDS_FILENAME, VK_FILENAME } from '../bb/execute.js';
  * @returns The verification key data
  */
 export async function extractVkData(vkDirectoryPath: string): Promise<VerificationKeyData> {
-  const [rawFields, rawBinary] = await Promise.all([
-    fs.readFile(path.join(vkDirectoryPath, VK_FIELDS_FILENAME), { encoding: 'utf-8' }),
-    fs.readFile(path.join(vkDirectoryPath, VK_FILENAME)),
-  ]);
-  const fieldsJson = JSON.parse(rawFields);
-  const fields = fieldsJson.map(Fr.fromHexString);
-  // The hash is not included in the BB response
-  const vkHash = await hashVK(fields);
-  const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+  const rawBinary = await fs.readFile(path.join(vkDirectoryPath, VK_FILENAME));
+
+  // Convert binary to field elements (32 bytes per field)
+  const numFields = rawBinary.length / Fr.SIZE_IN_BYTES;
+  const reader = BufferReader.asReader(rawBinary);
+  const fields = reader.readArray(numFields, Fr);
+
+  const vkAsFields = await VerificationKeyAsFields.fromKey(fields);
   return new VerificationKeyData(vkAsFields, rawBinary);
 }
 
-// TODO: This was adapted from the above function. A refactor might be needed.
+/**
+ * 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 [rawFields, rawBinary] = await Promise.all([
-    fs.readFile(path.join(vkDirectoryPath, VK_FIELDS_FILENAME), { encoding: 'utf-8' }),
-    fs.readFile(path.join(vkDirectoryPath, VK_FILENAME)),
-  ]);
-  const fieldsJson = JSON.parse(rawFields);
-  const fields = fieldsJson.map(Fr.fromHexString);
-  // The first item is the hash, this is not part of the actual VK
-  // TODO: is the above actually the case?
-  const vkHash = fields[0];
-  assert(fields.length === AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, 'Invalid AVM verification key length');
-  const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+  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

@@ -1,8 +1,14 @@
 import { runInDirectory } from '@aztec/foundation/fs';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
-import type { ClientProtocolArtifact, ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
-import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import { Timer } from '@aztec/foundation/timer';
+import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import {
+  type ClientProtocolArtifact,
+  type ProtocolArtifact,
+  type ServerProtocolArtifact,
+  mapProtocolArtifactNameToCircuitName,
+} from '@aztec/noir-protocol-circuits-types/types';
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
 import type { CircuitVerificationStats } from '@aztec/stdlib/stats';
 import { Tx } from '@aztec/stdlib/tx';
@@ -11,37 +17,56 @@ import type { VerificationKeyData } from '@aztec/stdlib/vks';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 
-import { BB_RESULT, PROOF_FILENAME, VK_FILENAME, verifyClientIvcProof, verifyProof } from '../bb/execute.js';
+import {
+  BB_RESULT,
+  PROOF_FILENAME,
+  PUBLIC_INPUTS_FILENAME,
+  VK_FILENAME,
+  verifyChonkProof,
+  verifyProof,
+} from '../bb/execute.js';
 import type { BBConfig } from '../config.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
-import { writeToOutputDirectory } from '../prover/client_ivc_proof_utils.js';
-import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+import { writeChonkProofToPath } from '../prover/proof_utils.js';
 
 export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
-  private constructor(private config: BBConfig, private logger: Logger) {}
+  private constructor(
+    private config: BBConfig,
+    private logger: Logger,
+  ) {}
+
+  public stop(): Promise<void> {
+    return Promise.resolve();
+  }
 
   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);
   }
 
-  public getVerificationKeyData(circuitType: ServerProtocolArtifact): VerificationKeyData {
-    const vk = ServerCircuitVks[circuitType];
+  public getVerificationKeyData(circuit: ProtocolArtifact): VerificationKeyData {
+    const vk = ProtocolCircuitVks[circuit];
     if (vk === undefined) {
-      throw new Error('Could not find VK for server artifact ' + circuitType);
+      throw new Error(`Could not find VK for artifact ${circuit}`);
     }
     return vk;
   }
 
   public async verifyProofForCircuit(circuit: ServerProtocolArtifact, proof: Proof) {
     const operation = async (bbWorkingDirectory: string) => {
+      const publicInputsFileName = path.join(bbWorkingDirectory, PUBLIC_INPUTS_FILENAME);
       const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
       const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
       const verificationKey = this.getVerificationKeyData(circuit);
 
       this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
 
-      await fs.writeFile(proofFileName, proof.buffer);
+      // 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);
 
       const result = await verifyProof(
@@ -67,48 +92,54 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
     await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
   }
 
-  public async verifyProof(tx: Tx): Promise<boolean> {
+  public async verifyProof(tx: Tx): Promise<IVCProofVerificationResult> {
+    const proofType = 'Chonk';
     try {
-      // TODO(#7370) The verification keys should be supplied separately and based on the expectedCircuit
-      // rather than read from the tx object itself. We also need the vks for the translator and ecc, which
-      // are not being saved along the other vks yet. Reuse the 'verifyProofForCircuit' method above once
-      // we have all the verification keys available.
-      const expectedCircuit: ClientProtocolArtifact = tx.data.forPublic
-        ? 'PrivateKernelTailToPublicArtifact'
-        : 'PrivateKernelTailArtifact';
-      const circuit = 'ClientIVC';
+      const totalTimer = new Timer();
+      let verificationDuration = 0;
+
+      const circuit: ClientProtocolArtifact = tx.data.forPublic ? 'HidingKernelToPublic' : 'HidingKernelToRollup';
 
       // Block below is almost copy-pasted from verifyProofForCircuit
       const operation = async (bbWorkingDirectory: string) => {
         const logFunction = (message: string) => {
-          this.logger.debug(`${circuit} BB out - ${message}`);
+          this.logger.debug(`${proofType} BB out - ${message}`);
         };
 
-        await writeToOutputDirectory(tx.clientIvcProof, bbWorkingDirectory);
-        const result = await verifyClientIvcProof(
+        const proofPath = path.join(bbWorkingDirectory, PROOF_FILENAME);
+        await writeChonkProofToPath(tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields()), proofPath);
+
+        const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
+        const verificationKey = this.getVerificationKeyData(circuit);
+        await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+
+        const timer = new Timer();
+        const result = await verifyChonkProof(
           this.config.bbBinaryPath,
-          bbWorkingDirectory.concat('/proof'),
-          bbWorkingDirectory.concat('/vk'),
+          proofPath,
+          verificationKeyPath,
           logFunction,
+          this.config.bbIVCConcurrency,
         );
+        verificationDuration = timer.ms();
 
         if (result.status === BB_RESULT.FAILURE) {
-          const errorMessage = `Failed to verify ${circuit} proof!`;
+          const errorMessage = `Failed to verify ${proofType} proof for ${circuit}!`;
           throw new Error(errorMessage);
         }
 
-        this.logger.debug(`${circuit} verification successful`, {
-          circuitName: mapProtocolArtifactNameToCircuitName(expectedCircuit),
+        this.logger.debug(`${proofType} verification successful`, {
+          circuitName: mapProtocolArtifactNameToCircuitName(circuit),
           duration: result.durationMs,
           eventName: 'circuit-verification',
-          proofType: 'client-ivc',
+          proofType: 'chonk',
         } satisfies CircuitVerificationStats);
       };
       await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
-      return true;
+      return { valid: true, durationMs: verificationDuration, totalDurationMs: totalTimer.ms() };
     } catch (err) {
-      this.logger.warn(`Failed to verify ClientIVC proof for tx ${Tx.getHash(tx)}: ${String(err)}`);
-      return false;
+      this.logger.warn(`Failed to verify ${proofType} proof for tx ${tx.getTxHash().toString()}: ${String(err)}`);
+      return { valid: false, durationMs: 0, totalDurationMs: 0 };
     }
   }
 }

package/src/verifier/index.ts

@@ -1 +1,2 @@
 export * from './bb_verifier.js';
+export * from './queued_chonk_verifier.js';

package/src/verifier/queued_chonk_verifier.ts

@@ -0,0 +1,140 @@
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
+import type { Tx } from '@aztec/stdlib/tx';
+import {
+  Attributes,
+  type BatchObservableResult,
+  type Histogram,
+  Metrics,
+  type ObservableGauge,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+  getTelemetryClient,
+} from '@aztec/telemetry-client';
+
+import { createHistogram } from 'node:perf_hooks';
+
+import type { BBConfig } from '../config.js';
+
+class IVCVerifierMetrics {
+  private ivcVerificationHistogram: Histogram;
+  private ivcTotalVerificationHistogram: Histogram;
+  private ivcFailureCount: UpDownCounter;
+  private localHistogramOk = createHistogram({
+    min: 1,
+    max: 5 * 60 * 1000, // 5 min
+  });
+  private localHistogramFails = createHistogram({
+    min: 1,
+    max: 5 * 60 * 1000, // 5 min
+  });
+
+  private aggDurationMetrics: Record<'min' | 'max' | 'p50' | 'p90' | 'avg', ObservableGauge>;
+
+  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.ivcTotalVerificationHistogram = meter.createHistogram(Metrics.IVC_VERIFIER_TOTAL_TIME, {
+      unit: 'ms',
+      description: 'Total duration to verify chonk proofs, including serde',
+      valueType: ValueType.INT,
+    });
+
+    this.ivcFailureCount = meter.createUpDownCounter(Metrics.IVC_VERIFIER_FAILURE_COUNT, {
+      description: 'Count of failed IVC proof verifications',
+      valueType: ValueType.INT,
+    });
+
+    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',
+      }),
+    };
+
+    meter.addBatchObservableCallback(this.aggregate, Object.values(this.aggDurationMetrics));
+  }
+
+  recordIVCVerification(result: IVCProofVerificationResult) {
+    this.ivcVerificationHistogram.record(Math.ceil(result.durationMs), { [Attributes.OK]: result.valid });
+    this.ivcTotalVerificationHistogram.record(Math.ceil(result.totalDurationMs), { [Attributes.OK]: result.valid });
+    if (!result.valid) {
+      this.ivcFailureCount.add(1);
+      this.localHistogramFails.record(Math.max(Math.ceil(result.durationMs), 1));
+    } else {
+      this.localHistogramOk.record(Math.max(Math.ceil(result.durationMs), 1));
+    }
+  }
+
+  private aggregate = (res: BatchObservableResult) => {
+    for (const [histogram, ok] of [
+      [this.localHistogramOk, true],
+      [this.localHistogramFails, false],
+    ] as const) {
+      if (histogram.count === 0) {
+        continue;
+      }
+      res.observe(this.aggDurationMetrics.avg, histogram.mean, { [Attributes.OK]: ok });
+      res.observe(this.aggDurationMetrics.max, histogram.max, { [Attributes.OK]: ok });
+      res.observe(this.aggDurationMetrics.min, histogram.min, { [Attributes.OK]: ok });
+      res.observe(this.aggDurationMetrics.p50, histogram.percentile(50), { [Attributes.OK]: ok });
+      res.observe(this.aggDurationMetrics.p90, histogram.percentile(90), { [Attributes.OK]: ok });
+    }
+  };
+}
+
+export class QueuedIVCVerifier implements ClientProtocolCircuitVerifier {
+  private queue: SerialQueue;
+  private metrics: IVCVerifierMetrics;
+
+  public constructor(
+    config: BBConfig,
+    private verifier: ClientProtocolCircuitVerifier,
+    private telemetry: TelemetryClient = getTelemetryClient(),
+    private logger = createLogger('bb-prover:queued_chonk_verifier'),
+  ) {
+    this.metrics = new IVCVerifierMetrics(this.telemetry, 'QueuedIVCVerifier');
+    this.queue = new SerialQueue();
+    this.logger.info(`Starting QueuedIVCVerifier with ${config.numConcurrentIVCVerifiers} concurrent verifiers`);
+    this.queue.start(config.numConcurrentIVCVerifiers);
+  }
+
+  public async verifyProof(tx: Tx): Promise<IVCProofVerificationResult> {
+    const result = await this.queue.put(() => this.verifier.verifyProof(tx));
+    this.metrics.recordIVCVerification(result);
+    return result;
+  }
+
+  stop(): Promise<void> {
+    return this.queue.end();
+  }
+}

package/dest/prover/bb_native_private_kernel_prover.d.ts

@@ -1,25 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import { type Logger } from '@aztec/foundation/log';
-import type { SimulationProvider } from '@aztec/simulator/server';
-import type { ClientIvcProof } from '@aztec/stdlib/proofs';
-import type { WitnessMap } from '@noir-lang/types';
-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 simulationProvider: SimulationProvider;
-    protected log: Logger;
-    private constructor();
-    static new(config: BBConfig, simulationProvider: SimulationProvider, log?: Logger): Promise<BBNativePrivateKernelProver>;
-    private _createClientIvcProof;
-    createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof>;
-    computeGateCountForCircuit(bytecode: Buffer, circuitName: string): Promise<number>;
-    private runInDirectory;
-}
-//# sourceMappingURL=bb_native_private_kernel_prover.d.ts.map

package/dest/prover/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/bb_native_private_kernel_prover.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAI3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAGtE;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,qBAAqB;IAElE,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,WAAW;cACA,kBAAkB,EAAE,kBAAkB;cACtC,GAAG;IALxB,OAAO;WAUa,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,GAAG,CAAC,EAAE,MAAM;YAWhF,qBAAqB;IAmCb,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAQ1F,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBxG,OAAO,CAAC,cAAc;CAavB"}

package/dest/prover/bb_native_private_kernel_prover.js

@@ -1,69 +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 { encode } from '@msgpack/msgpack';
-import { serializeWitness } from '@noir-lang/noirc_abi';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { BB_RESULT, computeGateCountForCircuit, executeBbClientIvcProof } from '../bb/execute.js';
-import { BBPrivateKernelProver } from './bb_private_kernel_prover.js';
-import { readFromOutputDirectory } from './client_ivc_proof_utils.js';
-/**
- * This proof creator implementation uses the native bb binary.
- */ export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
-    bbBinaryPath;
-    bbWorkingDirectory;
-    skipCleanup;
-    simulationProvider;
-    log;
-    constructor(bbBinaryPath, bbWorkingDirectory, skipCleanup, simulationProvider, log = createLogger('bb-prover:native')){
-        super(new BundleArtifactProvider(), simulationProvider, log), this.bbBinaryPath = bbBinaryPath, this.bbWorkingDirectory = bbWorkingDirectory, this.skipCleanup = skipCleanup, this.simulationProvider = simulationProvider, this.log = log;
-    }
-    static async new(config, simulationProvider, log) {
-        await fs.mkdir(config.bbWorkingDirectory, {
-            recursive: true
-        });
-        return new BBNativePrivateKernelProver(config.bbBinaryPath, config.bbWorkingDirectory, !!config.bbSkipCleanup, simulationProvider, log);
-    }
-    async _createClientIvcProof(directory, acirs, witnessStack) {
-        // TODO(#7371): Longer term we won't use this hacked together msgpack format
-        // and instead properly create the bincode serialization from rust
-        await fs.writeFile(path.join(directory, 'acir.msgpack'), encode(acirs));
-        await fs.writeFile(path.join(directory, 'witnesses.msgpack'), encode(witnessStack.map((map)=>serializeWitness(map))));
-        const provingResult = await executeBbClientIvcProof(this.bbBinaryPath, directory, path.join(directory, 'acir.msgpack'), path.join(directory, 'witnesses.msgpack'), this.log.info);
-        if (provingResult.status === BB_RESULT.FAILURE) {
-            this.log.error(`Failed to generate client ivc proof`);
-            throw new Error(provingResult.reason);
-        }
-        const proof = await readFromOutputDirectory(directory);
-        this.log.info(`Generated IVC proof`, {
-            duration: provingResult.durationMs,
-            eventName: 'circuit-proving'
-        });
-        return proof;
-    }
-    async createClientIvcProof(acirs, witnessStack) {
-        this.log.info(`Generating Client IVC proof`);
-        const operation = async (directory)=>{
-            return await this._createClientIvcProof(directory, acirs, witnessStack);
-        };
-        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/bb_private_kernel_prover.d.ts

@@ -1,32 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-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 { ClientIvcProof } from '@aztec/stdlib/proofs';
-import type { Abi, WitnessMap } from '@noir-lang/types';
-export declare abstract class BBPrivateKernelProver implements PrivateKernelProver {
-    protected artifactProvider: ArtifactProvider;
-    protected simulationProvider: SimulationProvider;
-    protected log: import("@aztec/foundation/log").Logger;
-    constructor(artifactProvider: ArtifactProvider, simulationProvider: SimulationProvider, log?: import("@aztec/foundation/log").Logger);
-    generateInitOutput(inputs: PrivateKernelInitCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    simulateInit(inputs: PrivateKernelInitCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    generateInnerOutput(inputs: PrivateKernelInnerCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    simulateInner(inputs: PrivateKernelInnerCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    generateResetOutput(inputs: PrivateKernelResetCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    simulateReset(inputs: PrivateKernelResetCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
-    generateTailOutput(inputs: PrivateKernelTailCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
-    simulateTail(inputs: PrivateKernelTailCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
-    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>>;
-    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>>;
-    makeEmptyKernelSimulateOutput<PublicInputsType extends PrivateKernelTailCircuitPublicInputs | PrivateKernelCircuitPublicInputs>(publicInputs: PublicInputsType, circuitType: ClientProtocolArtifact): Promise<PrivateKernelSimulateOutput<PublicInputsType>>;
-    createClientIvcProof(_acirs: Buffer[], _witnessStack: WitnessMap[]): Promise<ClientIvcProof>;
-    computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number>;
-}
-//# sourceMappingURL=bb_private_kernel_prover.d.ts.map

package/dest/prover/bb_private_kernel_prover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bb_private_kernel_prover.d.ts","sourceRoot":"","sources":["../../src/prover/bb_private_kernel_prover.ts"],"names":[],"mappings":"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"}

package/dest/prover/bb_prover.d.ts

@@ -1,120 +0,0 @@
-import { AVM_PROOF_LENGTH_IN_FIELDS, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
-import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
-import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
-import { type ProofAndVerificationKey, type PublicInputsAndRecursiveProof, type ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
-import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
-import { Proof } from '@aztec/stdlib/proofs';
-import type { BaseOrMergeRollupPublicInputs, BlockMergeRollupInputs, BlockRootOrBlockMergePublicInputs, BlockRootRollupInputs, EmptyBlockRootRollupInputs, MergeRollupInputs, PrivateBaseRollupInputs, PublicBaseRollupInputs, RootRollupInputs, RootRollupPublicInputs, SingleTxBlockRootRollupInputs, TubeInputs } from '@aztec/stdlib/rollup';
-import type { VerificationKeyData } from '@aztec/stdlib/vks';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-import type { ACVMConfig, BBConfig } from '../config.js';
-import { type UltraHonkFlavor } from '../honk.js';
-export interface BBProverConfig extends BBConfig, ACVMConfig {
-    circuitFilter?: ServerProtocolArtifact[];
-}
-/**
- * Prover implementation that uses barretenberg native proving
- */
-export declare class BBNativeRollupProver implements ServerCircuitProver {
-    private config;
-    private instrumentation;
-    constructor(config: BBProverConfig, telemetry: TelemetryClient);
-    get tracer(): import("@aztec/telemetry-client").Tracer;
-    static new(config: BBProverConfig, telemetry?: TelemetryClient): Promise<BBNativeRollupProver>;
-    /**
-     * Simulates the base parity circuit from its inputs.
-     * @param inputs - Inputs to the circuit.
-     * @returns The public inputs of the parity circuit.
-     */
-    getBaseParityProof(inputs: BaseParityInputs): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>>;
-    /**
-     * Simulates the root parity circuit from its inputs.
-     * @param inputs - Inputs to the circuit.
-     * @returns The public inputs of the parity circuit.
-     */
-    getRootParityProof(inputs: RootParityInputs): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
-    /**
-     * Creates an AVM proof and verifies it.
-     * @param inputs - The inputs to the AVM circuit.
-     * @returns The proof.
-     */
-    getAvmProof(inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>>;
-    /**
-     * Simulates the base rollup circuit from its inputs.
-     * @param inputs - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getPrivateBaseRollupProof(inputs: PrivateBaseRollupInputs): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Requests that the public kernel tail circuit be executed and the proof generated
-     * @param kernelRequest - The object encapsulating the request for a proof
-     * @returns The requested circuit's public inputs and proof
-     */
-    getPublicBaseRollupProof(inputs: PublicBaseRollupInputs): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Simulates the merge rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getMergeRollupProof(input: MergeRollupInputs): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Simulates the block root rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getBlockRootRollupProof(input: BlockRootRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    getSingleTxBlockRootRollupProof(input: SingleTxBlockRootRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Simulates the empty block root rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getEmptyBlockRootRollupProof(input: EmptyBlockRootRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Simulates the block merge rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getBlockMergeRollupProof(input: BlockMergeRollupInputs): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    /**
-     * Simulates the root rollup circuit from its inputs.
-     * @param input - Inputs to the circuit.
-     * @returns The public inputs as outputs of the simulation.
-     */
-    getRootRollupProof(input: RootRollupInputs): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>>;
-    private generateProofWithBB;
-    private createProof;
-    private generateAvmProofWithBB;
-    private generateTubeProofWithBB;
-    private createAvmProof;
-    getTubeProof(input: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>;
-    /**
-     * Executes a circuit and returns its outputs and corresponding proof with embedded aggregation object
-     * @param witnessMap - The input witness
-     * @param circuitType - The type of circuit to be executed
-     * @param proofLength - The length of the proof to be generated. This is a dummy parameter to aid in type checking
-     * @param convertInput - Function for mapping the input object to a witness map.
-     * @param convertOutput - Function for parsing the output witness to it's corresponding object
-     * @returns The circuits output object and it's proof
-     */
-    private createRecursiveProof;
-    /**
-     * Verifies a proof, will generate the verification key if one is not cached internally
-     * @param circuitType - The type of circuit whose proof is to be verified
-     * @param proof - The proof to be verified
-     */
-    verifyProof(circuitType: ServerProtocolArtifact, proof: Proof): Promise<void>;
-    verifyAvmProof(proof: Proof, verificationKey: VerificationKeyData): Promise<void>;
-    verifyWithKey(flavor: UltraHonkFlavor, verificationKey: VerificationKeyData, proof: Proof): Promise<void>;
-    private verifyWithKeyInternal;
-    /**
-     * Returns the verification key data for a circuit.
-     * @param circuitType - The type of circuit for which the verification key is required
-     * @returns The verification key data
-     */
-    private getVerificationKeyDataForCircuit;
-    private readProofAsFields;
-    private readAvmProofAsFields;
-    private runInDirectory;
-}
-//# sourceMappingURL=bb_prover.d.ts.map