@aztec/bb-prover 0.0.0-test.0

package/dest/bb/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --no-warnings
+import 'source-map-support/register.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/bb/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bb/index.ts"],"names":[],"mappings":";AAGA,OAAO,gCAAgC,CAAC"}

package/dest/bb/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env -S node --no-warnings
+import { createConsoleLogger } from '@aztec/foundation/log';
+import 'source-map-support/register.js';
+import { getProgram } from './cli.js';
+const log = createConsoleLogger();
+/** CLI main entrypoint */ async function main() {
+    process.once('SIGINT', ()=>process.exit(0));
+    process.once('SIGTERM', ()=>process.exit(0));
+    const program = getProgram(log);
+    await program.parseAsync(process.argv);
+}
+main().catch((err)=>{
+    log(`Error in command execution`);
+    log(err);
+    process.exit(1);
+});

package/dest/config.d.ts

@@ -0,0 +1,13 @@
+export interface BBConfig {
+    bbBinaryPath: string;
+    bbWorkingDirectory: string;
+    /** Whether to skip tmp dir cleanup for debugging purposes */
+    bbSkipCleanup: boolean;
+}
+export interface ACVMConfig {
+    /** The path to the ACVM binary */
+    acvmBinaryPath: string;
+    /** The working directory to use for simulation/proving */
+    acvmWorkingDirectory: string;
+}
+//# sourceMappingURL=config.d.ts.map

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,6DAA6D;IAC7D,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,kCAAkC;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,oBAAoB,EAAE,MAAM,CAAC;CAC9B"}

package/dest/config.js

@@ -0,0 +1 @@
+export { };

package/dest/honk.d.ts

@@ -0,0 +1,13 @@
+import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
+export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_rollup_honk';
+declare const UltraKeccakHonkCircuits: ["RootRollupArtifact"];
+declare const UltraHonkCircuits: ["BaseParityArtifact", "RootParityArtifact"];
+export type UltraKeccakHonkServerProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number];
+export type UltraHonkServerProtocolArtifact = (typeof UltraHonkCircuits)[number];
+export type UltraRollupHonkServerProtocolArtifact = Exclude<Exclude<ServerProtocolArtifact, UltraKeccakHonkServerProtocolArtifact>, UltraHonkServerProtocolArtifact>;
+export declare function getUltraHonkFlavorForCircuit(artifact: UltraKeccakHonkServerProtocolArtifact): 'ultra_keccak_honk';
+export declare function getUltraHonkFlavorForCircuit(artifact: UltraHonkServerProtocolArtifact): 'ultra_honk';
+export declare function getUltraHonkFlavorForCircuit(artifact: UltraRollupHonkServerProtocolArtifact): 'ultra_rollup_honk';
+export declare function getUltraHonkFlavorForCircuit(artifact: ServerProtocolArtifact): UltraHonkFlavor;
+export {};
+//# sourceMappingURL=honk.d.ts.map

package/dest/honk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"honk.d.ts","sourceRoot":"","sources":["../src/honk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAEzF,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,mBAAmB,GAAG,mBAAmB,CAAC;AAEvF,QAAA,MAAM,uBAAuB,wBAAqE,CAAC;AACnG,QAAA,MAAM,iBAAiB,8CAA2F,CAAC;AAEnH,MAAM,MAAM,qCAAqC,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAC7F,MAAM,MAAM,+BAA+B,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AACjF,MAAM,MAAM,qCAAqC,GAAG,OAAO,CACzD,OAAO,CAAC,sBAAsB,EAAE,qCAAqC,CAAC,EACtE,+BAA+B,CAChC,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qCAAqC,GAAG,mBAAmB,CAAC;AACnH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,+BAA+B,GAAG,YAAY,CAAC;AACtG,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qCAAqC,GAAG,mBAAmB,CAAC;AACnH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,eAAe,CAAC"}

package/dest/honk.js

@@ -0,0 +1,18 @@
+const UltraKeccakHonkCircuits = [
+    'RootRollupArtifact'
+];
+const UltraHonkCircuits = [
+    'BaseParityArtifact',
+    'RootParityArtifact'
+];
+export function getUltraHonkFlavorForCircuit(artifact) {
+    if (isUltraKeccakHonkCircuit(artifact)) {
+        return 'ultra_keccak_honk';
+    } else if (UltraHonkCircuits.includes(artifact)) {
+        return 'ultra_honk';
+    }
+    return 'ultra_rollup_honk';
+}
+function isUltraKeccakHonkCircuit(artifact) {
+    return UltraKeccakHonkCircuits.includes(artifact);
+}

package/dest/index.d.ts

@@ -0,0 +1,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 './honk.js';
+export { type ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+//# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAE1B,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/index.js

@@ -0,0 +1,6 @@
+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 './honk.js';

package/dest/instrumentation.d.ts

@@ -0,0 +1,47 @@
+import type { Timer } from '@aztec/foundation/timer';
+import type { CircuitName } from '@aztec/stdlib/stats';
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+/**
+ * Instrumentation class for Prover implementations.
+ */
+export declare class ProverInstrumentation {
+    private simulationDuration;
+    private witGenDuration;
+    private provingDuration;
+    private witGenInputSize;
+    private witGenOutputSize;
+    private proofSize;
+    private circuitSize;
+    private circuitPublicInputCount;
+    readonly tracer: Tracer;
+    constructor(telemetry: TelemetryClient, name: string);
+    /**
+     * Records the duration of a circuit operation.
+     * @param metric - The metric to record
+     * @param circuitName - The name of the circuit
+     * @param timerOrMS - The duration
+     */
+    recordDuration(metric: 'simulationDuration' | 'witGenDuration' | 'provingDuration', circuitName: CircuitName | 'tubeCircuit', timerOrMS: Timer | number): void;
+    /**
+     * Records the duration of an AVM circuit operation.
+     * @param metric - The metric to record
+     * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+     * @param timerOrMS - The duration
+     */
+    recordAvmDuration(metric: 'witGenDuration' | 'provingDuration', appCircuitName: string, timerOrMS: Timer | number): void;
+    /**
+     * Records the size of a circuit operation.
+     * @param metric - Records the size of a circuit operation.
+     * @param circuitName - The name of the circuit
+     * @param size - The size
+     */
+    recordSize(metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount', circuitName: CircuitName | 'tubeCircuit', size: number): void;
+    /**
+     * Records the size of an AVM circuit operation.
+     * @param metric - The metric to record
+     * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+     * @param size - The size
+     */
+    recordAvmSize(metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount', appCircuitName: string, size: number): void;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

package/dest/instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../src/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,MAAM,EAEZ,MAAM,yBAAyB,CAAC;AAEjC;;GAEG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,kBAAkB,CAAY;IACtC,OAAO,CAAC,cAAc,CAAY;IAClC,OAAO,CAAC,eAAe,CAAY;IAEnC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,gBAAgB,CAAQ;IAEhC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,uBAAuB,CAAQ;IAEvC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,SAAS,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM;IAmDpD;;;;;OAKG;IACH,cAAc,CACZ,MAAM,EAAE,oBAAoB,GAAG,gBAAgB,GAAG,iBAAiB,EACnE,WAAW,EAAE,WAAW,GAAG,aAAa,EACxC,SAAS,EAAE,KAAK,GAAG,MAAM;IAS3B;;;;;OAKG;IACH,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,GAAG,iBAAiB,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM;IAOjH;;;;;OAKG;IACH,UAAU,CACR,MAAM,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,WAAW,GAAG,aAAa,GAAG,yBAAyB,EACxG,WAAW,EAAE,WAAW,GAAG,aAAa,EACxC,IAAI,EAAE,MAAM;IAQd;;;;;OAKG;IACH,aAAa,CACX,MAAM,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,WAAW,GAAG,aAAa,GAAG,yBAAyB,EACxG,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,MAAM;CAMf"}

package/dest/instrumentation.js

@@ -0,0 +1,100 @@
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+/**
+ * Instrumentation class for Prover implementations.
+ */ export class ProverInstrumentation {
+    simulationDuration;
+    witGenDuration;
+    provingDuration;
+    witGenInputSize;
+    witGenOutputSize;
+    proofSize;
+    circuitSize;
+    circuitPublicInputCount;
+    tracer;
+    constructor(telemetry, name){
+        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.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.provingDuration = meter.createHistogram(Metrics.CIRCUIT_PROVING_DURATION, {
+            unit: 's',
+            description: 'Records how long it takes to prove a circuit',
+            valueType: ValueType.DOUBLE
+        });
+        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.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.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.circuitPublicInputCount = meter.createGauge(Metrics.CIRCUIT_PUBLIC_INPUTS_COUNT, {
+            description: 'Records the number of public inputs in a circuit',
+            valueType: ValueType.INT
+        });
+        this.circuitSize = meter.createGauge(Metrics.CIRCUIT_SIZE, {
+            description: 'Records the size of the circuit in gates',
+            valueType: ValueType.INT
+        });
+    }
+    /**
+   * Records the duration of a circuit operation.
+   * @param metric - The metric to record
+   * @param circuitName - The name of the circuit
+   * @param timerOrMS - The duration
+   */ recordDuration(metric, circuitName, timerOrMS) {
+        const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+        this[metric].record(s, {
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server'
+        });
+    }
+    /**
+   * Records the duration of an AVM circuit operation.
+   * @param metric - The metric to record
+   * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+   * @param timerOrMS - The duration
+   */ recordAvmDuration(metric, appCircuitName, timerOrMS) {
+        const s = typeof timerOrMS === 'number' ? timerOrMS / 1000 : timerOrMS.s();
+        this[metric].record(s, {
+            [Attributes.APP_CIRCUIT_NAME]: appCircuitName
+        });
+    }
+    /**
+   * Records the size of a circuit operation.
+   * @param metric - Records the size of a circuit operation.
+   * @param circuitName - The name of the circuit
+   * @param size - The size
+   */ recordSize(metric, circuitName, size) {
+        this[metric].record(Math.ceil(size), {
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server'
+        });
+    }
+    /**
+   * Records the size of an AVM circuit operation.
+   * @param metric - The metric to record
+   * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+   * @param size - The size
+   */ recordAvmSize(metric, appCircuitName, size) {
+        this[metric].record(Math.ceil(size), {
+            [Attributes.APP_CIRCUIT_NAME]: appCircuitName
+        });
+    }
+}

package/dest/prover/bb_native_private_kernel_prover.d.ts

@@ -0,0 +1,25 @@
+/// <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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,32 @@
+/// <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

@@ -0,0 +1 @@
+{"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_private_kernel_prover.js

@@ -0,0 +1,109 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { convertPrivateKernelInitInputsToWitnessMapWithAbi, convertPrivateKernelInitOutputsFromWitnessMapWithAbi, convertPrivateKernelInnerInputsToWitnessMapWithAbi, convertPrivateKernelInnerOutputsFromWitnessMapWithAbi, convertPrivateKernelResetInputsToWitnessMapWithAbi, convertPrivateKernelResetOutputsFromWitnessMapWithAbi, convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi, convertPrivateKernelTailInputsToWitnessMapWithAbi, convertPrivateKernelTailOutputsFromWitnessMapWithAbi, convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi, getPrivateKernelResetArtifactName, updateResetCircuitSampleInputs } from '@aztec/noir-protocol-circuits-types/client';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+export class BBPrivateKernelProver {
+    artifactProvider;
+    simulationProvider;
+    log;
+    constructor(artifactProvider, simulationProvider, log = createLogger('bb-prover')){
+        this.artifactProvider = artifactProvider;
+        this.simulationProvider = simulationProvider;
+        this.log = log;
+    }
+    async generateInitOutput(inputs) {
+        return await this.generateCircuitOutput(inputs, 'PrivateKernelInitArtifact', convertPrivateKernelInitInputsToWitnessMapWithAbi, convertPrivateKernelInitOutputsFromWitnessMapWithAbi);
+    }
+    async simulateInit(inputs) {
+        return await this.simulateCircuitOutput(inputs, 'PrivateKernelInitArtifact', convertPrivateKernelInitInputsToWitnessMapWithAbi, convertPrivateKernelInitOutputsFromWitnessMapWithAbi);
+    }
+    async generateInnerOutput(inputs) {
+        return await this.generateCircuitOutput(inputs, 'PrivateKernelInnerArtifact', convertPrivateKernelInnerInputsToWitnessMapWithAbi, convertPrivateKernelInnerOutputsFromWitnessMapWithAbi);
+    }
+    async simulateInner(inputs) {
+        return await this.simulateCircuitOutput(inputs, 'PrivateKernelInnerArtifact', convertPrivateKernelInnerInputsToWitnessMapWithAbi, convertPrivateKernelInnerOutputsFromWitnessMapWithAbi);
+    }
+    async generateResetOutput(inputs) {
+        const variantInputs = inputs.trimToSizes();
+        const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
+        return await this.generateCircuitOutput(variantInputs, artifactName, convertPrivateKernelResetInputsToWitnessMapWithAbi, convertPrivateKernelResetOutputsFromWitnessMapWithAbi);
+    }
+    async simulateReset(inputs) {
+        updateResetCircuitSampleInputs(inputs);
+        const variantInputs = inputs.trimToSizes();
+        const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
+        return await this.simulateCircuitOutput(variantInputs, artifactName, convertPrivateKernelResetInputsToWitnessMapWithAbi, convertPrivateKernelResetOutputsFromWitnessMapWithAbi);
+    }
+    async generateTailOutput(inputs) {
+        if (!inputs.isForPublic()) {
+            return await this.generateCircuitOutput(inputs, 'PrivateKernelTailArtifact', convertPrivateKernelTailInputsToWitnessMapWithAbi, convertPrivateKernelTailOutputsFromWitnessMapWithAbi);
+        }
+        return await this.generateCircuitOutput(inputs, 'PrivateKernelTailToPublicArtifact', convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi, convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi);
+    }
+    async simulateTail(inputs) {
+        if (!inputs.isForPublic()) {
+            return await this.simulateCircuitOutput(inputs, 'PrivateKernelTailArtifact', convertPrivateKernelTailInputsToWitnessMapWithAbi, convertPrivateKernelTailOutputsFromWitnessMapWithAbi);
+        }
+        return await this.simulateCircuitOutput(inputs, 'PrivateKernelTailToPublicArtifact', convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi, convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi);
+    }
+    async simulateCircuitOutput(inputs, circuitType, convertInputs, convertOutputs) {
+        const compiledCircuit = await this.artifactProvider.getSimulatedClientCircuitArtifactByName(circuitType);
+        const witnessMap = convertInputs(inputs, compiledCircuit.abi);
+        const timer = new Timer();
+        const outputWitness = await this.simulationProvider.executeProtocolCircuit(witnessMap, compiledCircuit).catch((err)=>{
+            this.log.debug(`Failed to simulate ${circuitType}`, {
+                circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+                error: err
+            });
+            throw err;
+        });
+        const output = convertOutputs(outputWitness, compiledCircuit.abi);
+        this.log.debug(`Simulated ${circuitType}`, {
+            eventName: 'circuit-simulation',
+            circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+            duration: timer.ms(),
+            inputSize: inputs.toBuffer().length,
+            outputSize: output.toBuffer().length
+        });
+        return this.makeEmptyKernelSimulateOutput(output, circuitType);
+    }
+    async generateCircuitOutput(inputs, circuitType, convertInputs, convertOutputs) {
+        this.log.debug(`Generating witness for ${circuitType}`);
+        const compiledCircuit = await this.artifactProvider.getClientCircuitArtifactByName(circuitType);
+        const witnessMap = convertInputs(inputs, compiledCircuit.abi);
+        const timer = new Timer();
+        const outputWitness = await this.simulationProvider.executeProtocolCircuit(witnessMap, compiledCircuit);
+        const output = convertOutputs(outputWitness, compiledCircuit.abi);
+        this.log.debug(`Generated witness for ${circuitType}`, {
+            eventName: 'circuit-witness-generation',
+            circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+            duration: timer.ms(),
+            inputSize: inputs.toBuffer().length,
+            outputSize: output.toBuffer().length
+        });
+        const verificationKey = (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields;
+        const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+        const kernelOutput = {
+            publicInputs: output,
+            verificationKey,
+            outputWitness,
+            bytecode
+        };
+        return kernelOutput;
+    }
+    async makeEmptyKernelSimulateOutput(publicInputs, circuitType) {
+        const kernelProofOutput = {
+            publicInputs,
+            verificationKey: (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields,
+            outputWitness: new Map(),
+            bytecode: Buffer.from([])
+        };
+        return kernelProofOutput;
+    }
+    createClientIvcProof(_acirs, _witnessStack) {
+        throw new Error('Not implemented');
+    }
+    computeGateCountForCircuit(_bytecode, _circuitName) {
+        throw new Error('Not implemented');
+    }
+}

package/dest/prover/bb_prover.d.ts

@@ -0,0 +1,120 @@
+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