@aztec/bb-prover 0.69.1 → 0.70.0

package/dest/verifier/bb_verifier.js

@@ -1,7 +1,7 @@
 import { Tx } from '@aztec/circuit-types';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
-import { ProtocolCircuitArtifacts, } from '@aztec/noir-protocol-circuits-types';
+import { ServerCircuitArtifacts } from '@aztec/noir-protocol-circuits-types/server';
 import { promises as fs } from 'fs';
 import * as path from 'path';
 import { BB_RESULT, PROOF_FILENAME, VK_FILENAME, generateContractForCircuit, generateKeyForNoirCircuit, verifyClientIvcProof, verifyProof, } from '../bb/execute.js';
@@ -25,7 +25,7 @@ export class BBCircuitVerifier {
         return new BBCircuitVerifier(config, keys, logger);
     }
     static async generateVerificationKey(circuit, bbPath, workingDirectory, logFn) {
-        return await generateKeyForNoirCircuit(bbPath, workingDirectory, circuit, ProtocolCircuitArtifacts[circuit], isProtocolArtifactRecursive(circuit), getUltraHonkFlavorForCircuit(circuit), logFn).then(result => {
+        return await generateKeyForNoirCircuit(bbPath, workingDirectory, circuit, ServerCircuitArtifacts[circuit], isProtocolArtifactRecursive(circuit), getUltraHonkFlavorForCircuit(circuit), logFn).then(result => {
             if (result.status === BB_RESULT.FAILURE) {
                 throw new Error(`Failed to created verification key for ${circuit}, ${result.reason}`);
             }
@@ -49,10 +49,7 @@ export class BBCircuitVerifier {
             this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
             await fs.writeFile(proofFileName, proof.buffer);
             await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
-            const logFunction = (message) => {
-                this.logger.debug(`${circuit} BB out - ${message}`);
-            };
-            const result = await verifyProof(this.config.bbBinaryPath, proofFileName, verificationKeyPath, getUltraHonkFlavorForCircuit(circuit), logFunction);
+            const result = await verifyProof(this.config.bbBinaryPath, proofFileName, verificationKeyPath, getUltraHonkFlavorForCircuit(circuit), this.logger);
             if (result.status === BB_RESULT.FAILURE) {
                 const errorMessage = `Failed to verify ${circuit} proof!`;
                 throw new Error(errorMessage);
@@ -67,7 +64,7 @@ export class BBCircuitVerifier {
         await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup);
     }
     async generateSolidityContract(circuit, contractName) {
-        const result = await generateContractForCircuit(this.config.bbBinaryPath, this.config.bbWorkingDirectory, circuit, ProtocolCircuitArtifacts[circuit], contractName, this.logger.debug);
+        const result = await generateContractForCircuit(this.config.bbBinaryPath, this.config.bbWorkingDirectory, circuit, ServerCircuitArtifacts[circuit], contractName, this.logger.debug);
         if (result.status === BB_RESULT.FAILURE) {
             throw new Error(`Failed to create verifier contract for ${circuit}, ${result.reason}`);
         }
@@ -110,4 +107,4 @@ export class BBCircuitVerifier {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/wasm/bb_wasm_private_kernel_prover.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { ClientIvcProof } from '@aztec/circuits.js';
+import { type ArtifactProvider } from '@aztec/noir-protocol-circuits-types/types';
+import { type SimulationProvider } from '@aztec/simulator/client';
+import { type WitnessMap } from '@noir-lang/types';
+import { BBPrivateKernelProver } from '../prover/bb_private_kernel_prover.js';
+export declare abstract class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
+    protected artifactProvider: ArtifactProvider;
+    protected simulationProvider: SimulationProvider;
+    private threads;
+    protected log: import("@aztec/foundation/log").Logger;
+    constructor(artifactProvider: ArtifactProvider, simulationProvider: SimulationProvider, threads?: number, log?: import("@aztec/foundation/log").Logger);
+    createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof>;
+}
+//# sourceMappingURL=bb_wasm_private_kernel_prover.d.ts.map

package/dest/wasm/bb_wasm_private_kernel_prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bb_wasm_private_kernel_prover.d.ts","sourceRoot":"","sources":["../../src/wasm/bb_wasm_private_kernel_prover.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAE9E,8BAAsB,yBAA0B,SAAQ,qBAAqB;cAEtD,gBAAgB,EAAE,gBAAgB;cAClC,kBAAkB,EAAE,kBAAkB;IACzD,OAAO,CAAC,OAAO;cACI,GAAG;gBAHH,gBAAgB,EAAE,gBAAgB,EAClC,kBAAkB,EAAE,kBAAkB,EACjD,OAAO,GAAE,MAAU,EACR,GAAG,yCAAiC;IAKnC,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;CAkBjH"}

package/dest/wasm/bb_wasm_private_kernel_prover.js

@@ -0,0 +1,31 @@
+import { AztecClientBackend } from '@aztec/bb.js';
+import { ClientIvcProof } from '@aztec/circuits.js';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { serializeWitness } from '@noir-lang/noirc_abi';
+import { ungzip } from 'pako';
+import { BBPrivateKernelProver } from '../prover/bb_private_kernel_prover.js';
+export class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
+    constructor(artifactProvider, simulationProvider, threads = 1, log = createLogger('bb-prover:wasm')) {
+        super(artifactProvider, simulationProvider, log);
+        this.artifactProvider = artifactProvider;
+        this.simulationProvider = simulationProvider;
+        this.threads = threads;
+        this.log = log;
+    }
+    async createClientIvcProof(acirs, witnessStack) {
+        const timer = new Timer();
+        this.log.info(`Generating ClientIVC proof...`);
+        const backend = new AztecClientBackend(acirs.map(acir => ungzip(acir)), { threads: this.threads });
+        const [proof, vk] = await backend.prove(witnessStack.map(witnessMap => ungzip(serializeWitness(witnessMap))));
+        await backend.destroy();
+        this.log.info(`Generated ClientIVC proof`, {
+            eventName: 'client-ivc-proof-generation',
+            duration: timer.ms(),
+            proofSize: proof.length,
+            vkSize: vk.length,
+        });
+        return new ClientIvcProof(Buffer.from(proof), Buffer.from(vk));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/wasm/bundle.d.ts

@@ -0,0 +1,6 @@
+import { type SimulationProvider } from '@aztec/simulator/client';
+import { BBWASMPrivateKernelProver } from './bb_wasm_private_kernel_prover.js';
+export declare class BBWASMBundlePrivateKernelProver extends BBWASMPrivateKernelProver {
+    constructor(simulationProvider: SimulationProvider, threads?: number, log?: import("@aztec/foundation/log").Logger);
+}
+//# sourceMappingURL=bundle.d.ts.map

package/dest/wasm/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/wasm/bundle.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,qBAAa,+BAAgC,SAAQ,yBAAyB;gBAChE,kBAAkB,EAAE,kBAAkB,EAAE,OAAO,SAAI,EAAE,GAAG,yCAAwC;CAG7G"}

package/dest/wasm/bundle.js

@@ -0,0 +1,9 @@
+import { createLogger } from '@aztec/foundation/log';
+import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
+import { BBWASMPrivateKernelProver } from './bb_wasm_private_kernel_prover.js';
+export class BBWASMBundlePrivateKernelProver extends BBWASMPrivateKernelProver {
+    constructor(simulationProvider, threads = 1, log = createLogger('bb-prover:wasm:bundle')) {
+        super(new BundleArtifactProvider(), simulationProvider, threads, log);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVuZGxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3dhc20vYnVuZGxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNyRCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxtREFBbUQsQ0FBQztBQUczRixPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUUvRSxNQUFNLE9BQU8sK0JBQWdDLFNBQVEseUJBQXlCO0lBQzVFLFlBQVksa0JBQXNDLEVBQUUsT0FBTyxHQUFHLENBQUMsRUFBRSxHQUFHLEdBQUcsWUFBWSxDQUFDLHVCQUF1QixDQUFDO1FBQzFHLEtBQUssQ0FBQyxJQUFJLHNCQUFzQixFQUFFLEVBQUUsa0JBQWtCLEVBQUUsT0FBTyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ3hFLENBQUM7Q0FDRiJ9

package/dest/wasm/lazy.d.ts

@@ -0,0 +1,6 @@
+import { type SimulationProvider } from '@aztec/simulator/client';
+import { BBWASMPrivateKernelProver } from './bb_wasm_private_kernel_prover.js';
+export declare class BBWASMLazyPrivateKernelProver extends BBWASMPrivateKernelProver {
+    constructor(simulationProvider: SimulationProvider, threads?: number, log?: import("@aztec/foundation/log").Logger);
+}
+//# sourceMappingURL=lazy.d.ts.map

package/dest/wasm/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/wasm/lazy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,qBAAa,6BAA8B,SAAQ,yBAAyB;gBAC9D,kBAAkB,EAAE,kBAAkB,EAAE,OAAO,SAAI,EAAE,GAAG,yCAAsC;CAG3G"}

package/dest/wasm/lazy.js

@@ -0,0 +1,9 @@
+import { createLogger } from '@aztec/foundation/log';
+import { LazyArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/lazy';
+import { BBWASMPrivateKernelProver } from './bb_wasm_private_kernel_prover.js';
+export class BBWASMLazyPrivateKernelProver extends BBWASMPrivateKernelProver {
+    constructor(simulationProvider, threads = 1, log = createLogger('bb-prover:wasm:lazy')) {
+        super(new LazyArtifactProvider(), simulationProvider, threads, log);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF6eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93YXNtL2xhenkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3JELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBR3ZGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRS9FLE1BQU0sT0FBTyw2QkFBOEIsU0FBUSx5QkFBeUI7SUFDMUUsWUFBWSxrQkFBc0MsRUFBRSxPQUFPLEdBQUcsQ0FBQyxFQUFFLEdBQUcsR0FBRyxZQUFZLENBQUMscUJBQXFCLENBQUM7UUFDeEcsS0FBSyxDQUFDLElBQUksb0JBQW9CLEVBQUUsRUFBRSxrQkFBa0IsRUFBRSxPQUFPLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDdEUsQ0FBQztDQUNGIn0=

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@aztec/bb-prover",
-  "version": "0.69.1",
+  "version": "0.70.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
-    "./wasm": "./dest/wasm/index.js",
+    "./wasm/bundle": "./dest/wasm/bundle.js",
+    "./wasm/lazy": "./dest/wasm/lazy.js",
     "./prover": "./dest/prover/index.js",
     "./verifier": "./dest/verifier/index.js",
     "./test": "./dest/test/index.js",
@@ -66,14 +67,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.69.1",
-    "@aztec/circuit-types": "0.69.1",
-    "@aztec/circuits.js": "0.69.1",
-    "@aztec/foundation": "0.69.1",
-    "@aztec/noir-protocol-circuits-types": "0.69.1",
-    "@aztec/simulator": "0.69.1",
-    "@aztec/telemetry-client": "0.69.1",
-    "@aztec/world-state": "0.69.1",
+    "@aztec/bb.js": "0.70.0",
+    "@aztec/circuit-types": "0.70.0",
+    "@aztec/circuits.js": "0.70.0",
+    "@aztec/foundation": "0.70.0",
+    "@aztec/noir-protocol-circuits-types": "0.70.0",
+    "@aztec/simulator": "0.70.0",
+    "@aztec/telemetry-client": "0.70.0",
+    "@aztec/world-state": "0.70.0",
     "@msgpack/msgpack": "^3.0.0-beta2",
     "@noir-lang/noirc_abi": "portal:../../noir/packages/noirc_abi",
     "@noir-lang/types": "portal:../../noir/packages/types",

package/src/bb/cli.ts

@@ -1,5 +1,8 @@
 import { type LogFn } from '@aztec/foundation/log';
-import { type ProtocolArtifact, ProtocolCircuitArtifacts } from '@aztec/noir-protocol-circuits-types';
+import { ClientCircuitArtifacts } from '@aztec/noir-protocol-circuits-types/client/bundle';
+import { ServerCircuitArtifacts } from '@aztec/noir-protocol-circuits-types/server';
+import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { Command } from 'commander';
 import { promises as fs } from 'fs';
@@ -8,6 +11,11 @@ import { generateContractForCircuit, generateKeyForNoirCircuit } from './execute
 
 const { BB_WORKING_DIRECTORY, BB_BINARY_PATH } = process.env;
 
+export const ProtocolCircuitArtifacts: Record<ProtocolArtifact, NoirCompiledCircuit> = {
+  ...ClientCircuitArtifacts,
+  ...ServerCircuitArtifacts,
+};
+
 /**
  * Returns commander program that defines the CLI.
  * @param log - Console logger.

package/src/bb/execute.ts

@@ -1,4 +1,4 @@
-import { type AvmCircuitInputs } from '@aztec/circuits.js';
+import { type AvmCircuitInputs, serializeWithMessagePack } from '@aztec/circuits.js';
 import { sha256 } from '@aztec/foundation/crypto';
 import { type LogFn, type Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -75,7 +75,7 @@ export function executeBB(
     // spawn the bb process
     const { HARDWARE_CONCURRENCY: _, ...envWithoutConcurrency } = process.env;
     const env = process.env.HARDWARE_CONCURRENCY ? process.env : envWithoutConcurrency;
-    logger(`Executing BB with: ${command} ${args.join(' ')}`);
+    logger(`Executing BB with: ${pathToBB} ${command} ${args.join(' ')}`);
     const bb = proc.spawn(pathToBB, [command, ...args], {
       env,
     });
@@ -497,6 +497,86 @@ export async function generateTubeProof(
  * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
  * @param pathToBB - The full path to the bb binary
  * @param workingDirectory - A working directory for use by bb
+ * @param input - The inputs for the public function to be proven
+ * @param log - A logging function
+ * @returns An object containing a result indication, the location of the proof and the duration taken
+ */
+export async function generateAvmProofV2(
+  pathToBB: string,
+  workingDirectory: string,
+  input: AvmCircuitInputs,
+  logger: Logger,
+): Promise<BBFailure | BBSuccess> {
+  // Check that the working directory exists
+  try {
+    await fs.access(workingDirectory);
+  } catch (error) {
+    return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
+  }
+
+  // The 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}` };
+  }
+
+  const inputsBuffer = input.serializeForAvm2();
+
+  try {
+    // Write the inputs to the working directory.
+    const avmInputsPath = join(workingDirectory, 'avm_inputs.bin');
+    await fs.writeFile(avmInputsPath, inputsBuffer);
+    if (!filePresent(avmInputsPath)) {
+      return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
+    }
+
+    const args = [
+      '--avm-inputs',
+      avmInputsPath,
+      '-o',
+      outputPath,
+      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '',
+    ];
+    const timer = new Timer();
+    const logFunction = (message: string) => {
+      logger.verbose(`AvmCircuit (prove) BB out - ${message}`);
+    };
+    const result = await executeBB(pathToBB, 'avm2_prove', args, logFunction);
+    const duration = timer.ms();
+
+    if (result.status == BB_RESULT.SUCCESS) {
+      return {
+        status: BB_RESULT.SUCCESS,
+        durationMs: duration,
+        proofPath: join(outputPath, PROOF_FILENAME),
+        pkPath: undefined,
+        vkPath: 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 (or doing check-circuit).
+ * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
+ * @param pathToBB - The full path to the bb binary
+ * @param workingDirectory - A working directory for use by bb
  * @param bytecode - The AVM bytecode for the public function to be proven (expected to be decompressed)
  * @param log - A logging function
  * @returns An object containing a result indication, the location of the proof and the duration taken
@@ -506,6 +586,7 @@ export async function generateAvmProof(
   workingDirectory: string,
   input: AvmCircuitInputs,
   logger: Logger,
+  checkCircuitOnly: boolean = false,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
   try {
@@ -553,12 +634,14 @@ export async function generateAvmProof(
       '-o',
       outputPath,
       logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '',
+      checkCircuitOnly ? '--check-circuit-only' : '',
     ];
     const timer = new Timer();
+    const cmd = checkCircuitOnly ? 'check_circuit' : 'prove';
     const logFunction = (message: string) => {
-      logger.verbose(`AvmCircuit (prove) BB out - ${message}`);
+      logger.verbose(`AvmCircuit (${cmd}) BB out - ${message}`);
     };
-    const result = await executeBB(pathToBB, 'avm_prove', args, logFunction);
+    const result = await executeBB(pathToBB, `avm_${cmd}`, args, logFunction);
     const duration = timer.ms();
 
     if (result.status == BB_RESULT.SUCCESS) {
@@ -594,7 +677,7 @@ export async function verifyProof(
   proofFullPath: string,
   verificationKeyPath: string,
   ultraHonkFlavor: UltraHonkFlavor,
-  log: LogFn,
+  log: Logger,
 ): Promise<BBFailure | BBSuccess> {
   return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, `verify_${ultraHonkFlavor}`, log);
 }
@@ -611,9 +694,37 @@ export async function verifyAvmProof(
   pathToBB: string,
   proofFullPath: string,
   verificationKeyPath: string,
-  log: LogFn,
+  logger: Logger,
 ): Promise<BBFailure | BBSuccess> {
-  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', log);
+  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', logger);
+}
+
+export async function verifyAvmProofV2(
+  pathToBB: string,
+  workingDirectory: string,
+  proofFullPath: string,
+  publicInputs: any,
+  verificationKeyPath: string,
+  logger: Logger,
+): Promise<BBFailure | BBSuccess> {
+  const inputsBuffer = serializeWithMessagePack(publicInputs);
+
+  // Write the inputs to the working directory.
+  const filePresent = async (file: string) =>
+    await fs
+      .access(file, fs.constants.R_OK)
+      .then(_ => true)
+      .catch(_ => false);
+  const avmInputsPath = join(workingDirectory, 'avm_public_inputs.bin');
+  await fs.writeFile(avmInputsPath, inputsBuffer);
+  if (!filePresent(avmInputsPath)) {
+    return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
+  }
+
+  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm2_verify', logger, [
+    '--avm-public-inputs',
+    avmInputsPath,
+  ]);
 }
 
 /**
@@ -670,8 +781,9 @@ async function verifyProofInternal(
   pathToBB: string,
   proofFullPath: string,
   verificationKeyPath: string,
-  command: 'verify_ultra_honk' | 'verify_ultra_rollup_honk' | 'verify_ultra_keccak_honk' | 'avm_verify',
-  log: LogFn,
+  command: 'verify_ultra_honk' | 'verify_ultra_rollup_honk' | 'verify_ultra_keccak_honk' | 'avm_verify' | 'avm2_verify',
+  logger: Logger,
+  extraArgs: string[] = [],
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
     .access(pathToBB, fs.constants.R_OK)
@@ -681,10 +793,21 @@ async function verifyProofInternal(
     return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
   }
 
+  const logFunction = (message: string) => {
+    logger.verbose(`AvmCircuit (verify) BB out - ${message}`);
+  };
+
   try {
-    const args = ['-p', proofFullPath, '-k', verificationKeyPath];
+    const args = [
+      '-p',
+      proofFullPath,
+      '-k',
+      verificationKeyPath,
+      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '',
+      ...extraArgs,
+    ];
     const timer = new Timer();
-    const result = await executeBB(pathToBB, command, args, log);
+    const result = await executeBB(pathToBB, command, args, logFunction);
     const duration = timer.ms();
     if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, durationMs: duration };

package/src/honk.ts

@@ -1,35 +1,30 @@
-import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
+import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
 
 export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_rollup_honk';
 
-const UltraKeccakHonkCircuits = ['RootRollupArtifact'] as const satisfies ProtocolArtifact[];
-const UltraHonkCircuits = [
-  // 'EmptyNestedArtifact',
-  // 'PrivateKernelEmptyArtifact',
-  'BaseParityArtifact',
-  'RootParityArtifact',
-] as const satisfies ProtocolArtifact[];
+const UltraKeccakHonkCircuits = ['RootRollupArtifact'] as const satisfies ServerProtocolArtifact[];
+const UltraHonkCircuits = ['BaseParityArtifact', 'RootParityArtifact'] as const satisfies ServerProtocolArtifact[];
 
-export type UltraKeccakHonkProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number];
-export type UltraHonkProtocolArtifact = (typeof UltraHonkCircuits)[number];
-export type UltraRollupHonkProtocolArtifact = Exclude<
-  Exclude<ProtocolArtifact, UltraKeccakHonkProtocolArtifact>,
-  UltraHonkProtocolArtifact
+export type UltraKeccakHonkServerProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number];
+export type UltraHonkServerProtocolArtifact = (typeof UltraHonkCircuits)[number];
+export type UltraRollupHonkServerProtocolArtifact = Exclude<
+  Exclude<ServerProtocolArtifact, UltraKeccakHonkServerProtocolArtifact>,
+  UltraHonkServerProtocolArtifact
 >;
 
-export function getUltraHonkFlavorForCircuit(artifact: UltraKeccakHonkProtocolArtifact): 'ultra_keccak_honk';
-export function getUltraHonkFlavorForCircuit(artifact: UltraHonkProtocolArtifact): 'ultra_honk';
-export function getUltraHonkFlavorForCircuit(artifact: UltraRollupHonkProtocolArtifact): 'ultra_rollup_honk';
-export function getUltraHonkFlavorForCircuit(artifact: ProtocolArtifact): UltraHonkFlavor;
-export function getUltraHonkFlavorForCircuit(artifact: ProtocolArtifact): UltraHonkFlavor {
+export function getUltraHonkFlavorForCircuit(artifact: UltraKeccakHonkServerProtocolArtifact): 'ultra_keccak_honk';
+export function getUltraHonkFlavorForCircuit(artifact: UltraHonkServerProtocolArtifact): 'ultra_honk';
+export function getUltraHonkFlavorForCircuit(artifact: UltraRollupHonkServerProtocolArtifact): 'ultra_rollup_honk';
+export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor;
+export function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor {
   if (isUltraKeccakHonkCircuit(artifact)) {
     return 'ultra_keccak_honk';
-  } else if (UltraHonkCircuits.includes(artifact as UltraHonkProtocolArtifact)) {
+  } else if (UltraHonkCircuits.includes(artifact as UltraHonkServerProtocolArtifact)) {
     return 'ultra_honk';
   }
   return 'ultra_rollup_honk';
 }
 
-function isUltraKeccakHonkCircuit(artifact: ProtocolArtifact): artifact is UltraKeccakHonkProtocolArtifact {
-  return UltraKeccakHonkCircuits.includes(artifact as UltraKeccakHonkProtocolArtifact);
+function isUltraKeccakHonkCircuit(artifact: ServerProtocolArtifact): artifact is UltraKeccakHonkServerProtocolArtifact {
+  return UltraKeccakHonkCircuits.includes(artifact as UltraKeccakHonkServerProtocolArtifact);
 }

package/src/prover/bb_native_private_kernel_prover.ts

@@ -0,0 +1,118 @@
+import { type ClientIvcProof } from '@aztec/circuits.js';
+import { runInDirectory } from '@aztec/foundation/fs';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { BundleArtifactProvider } from '@aztec/noir-protocol-circuits-types/client/bundle';
+import { type SimulationProvider } from '@aztec/simulator/server';
+
+import { encode } from '@msgpack/msgpack';
+import { serializeWitness } from '@noir-lang/noirc_abi';
+import { type WitnessMap } from '@noir-lang/types';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+import { BB_RESULT, computeGateCountForCircuit, executeBbClientIvcProof } from '../bb/execute.js';
+import { type BBConfig } from '../config.js';
+import { 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 {
+  private constructor(
+    private bbBinaryPath: string,
+    private bbWorkingDirectory: string,
+    private skipCleanup: boolean,
+    protected override simulationProvider: SimulationProvider,
+    protected override log = createLogger('bb-prover:native'),
+  ) {
+    super(new BundleArtifactProvider(), simulationProvider, log);
+  }
+
+  public static async new(config: BBConfig, simulationProvider: SimulationProvider, log?: Logger) {
+    await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
+    return new BBNativePrivateKernelProver(
+      config.bbBinaryPath,
+      config.bbWorkingDirectory,
+      !!config.bbSkipCleanup,
+      simulationProvider,
+      log,
+    );
+  }
+
+  private async _createClientIvcProof(
+    directory: string,
+    acirs: Buffer[],
+    witnessStack: WitnessMap[],
+  ): Promise<ClientIvcProof> {
+    // 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;
+  }
+
+  public override async createClientIvcProof(acirs: Buffer[], witnessStack: WitnessMap[]): Promise<ClientIvcProof> {
+    this.log.info(`Generating Client IVC proof`);
+    const operation = async (directory: string) => {
+      return await this._createClientIvcProof(directory, acirs, witnessStack);
+    };
+    return await this.runInDirectory(operation);
+  }
+
+  public override async computeGateCountForCircuit(bytecode: Buffer, circuitName: string): Promise<number> {
+    const logFunction = (message: string) => {
+      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 as number;
+  }
+
+  private runInDirectory<T>(fn: (dir: string) => Promise<T>) {
+    const log = this.log;
+    return runInDirectory(
+      this.bbWorkingDirectory,
+      (dir: string) =>
+        fn(dir).catch(err => {
+          log.error(`Error running operation at ${dir}: ${err}`);
+          throw err;
+        }),
+      this.skipCleanup,
+    );
+  }
+}