@aztec/bb-prover 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/dest/instrumentation.js

@@ -61,8 +61,7 @@ import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
    */ 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'
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName
         });
     }
     /**
@@ -83,8 +82,7 @@ import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
    * @param size - The size
    */ recordSize(metric, circuitName, size) {
         this[metric].record(Math.ceil(size), {
-            [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
-            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server'
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName
         });
     }
     /**

package/dest/prover/{bb_private_kernel_prover.d.ts → client/bb_private_kernel_prover.d.ts}

@@ -1,16 +1,14 @@
-/// <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 ArtifactProvider, type ClientProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import type { Abi, WitnessMap } from '@aztec/noir-types';
+import type { CircuitSimulator } from '@aztec/simulator/client';
 import type { PrivateKernelProver } from '@aztec/stdlib/interfaces/client';
-import type { 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';
+import type { HidingKernelToPublicPrivateInputs, HidingKernelToRollupPrivateInputs, PrivateExecutionStep, PrivateKernelCircuitPublicInputs, PrivateKernelInitCircuitPrivateInputs, PrivateKernelInnerCircuitPrivateInputs, PrivateKernelResetCircuitPrivateInputs, PrivateKernelSimulateOutput, PrivateKernelTailCircuitPrivateInputs, PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import type { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
 export declare abstract class BBPrivateKernelProver implements PrivateKernelProver {
     protected artifactProvider: ArtifactProvider;
-    protected simulationProvider: SimulationProvider;
+    protected simulator: CircuitSimulator;
     protected log: import("@aztec/foundation/log").Logger;
-    constructor(artifactProvider: ArtifactProvider, simulationProvider: SimulationProvider, log?: import("@aztec/foundation/log").Logger);
+    constructor(artifactProvider: ArtifactProvider, simulator: CircuitSimulator, log?: import("@aztec/foundation/log").Logger);
     generateInitOutput(inputs: PrivateKernelInitCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
     simulateInit(inputs: PrivateKernelInitCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
     generateInnerOutput(inputs: PrivateKernelInnerCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
@@ -19,6 +17,8 @@ export declare abstract class BBPrivateKernelProver implements PrivateKernelProv
     simulateReset(inputs: PrivateKernelResetCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
     generateTailOutput(inputs: PrivateKernelTailCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
     simulateTail(inputs: PrivateKernelTailCircuitPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
+    generateHidingToRollupOutput(inputs: HidingKernelToRollupPrivateInputs): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
+    generateHidingToPublicOutput(inputs: HidingKernelToPublicPrivateInputs): 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>>;
@@ -26,7 +26,7 @@ export declare abstract class BBPrivateKernelProver implements PrivateKernelProv
         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>;
+    createChonkProof(_executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs>;
     computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number>;
 }
 //# sourceMappingURL=bb_private_kernel_prover.d.ts.map

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

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

package/dest/prover/{bb_private_kernel_prover.js → client/bb_private_kernel_prover.js}

@@ -1,14 +1,13 @@
 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';
+import { convertHidingKernelPublicInputsToWitnessMapWithAbi, convertHidingKernelToRollupInputsToWitnessMapWithAbi, convertPrivateKernelInitInputsToWitnessMapWithAbi, convertPrivateKernelInitOutputsFromWitnessMapWithAbi, convertPrivateKernelInnerInputsToWitnessMapWithAbi, convertPrivateKernelInnerOutputsFromWitnessMapWithAbi, convertPrivateKernelResetInputsToWitnessMapWithAbi, convertPrivateKernelResetOutputsFromWitnessMapWithAbi, convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi, convertPrivateKernelTailInputsToWitnessMapWithAbi, convertPrivateKernelTailOutputsFromWitnessMapWithAbi, convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi, foreignCallHandler, getPrivateKernelResetArtifactName, updateResetCircuitSampleInputs } from '@aztec/noir-protocol-circuits-types/client';
+import { mapProtocolArtifactNameToCircuitName } from '@aztec/noir-protocol-circuits-types/types';
 export class BBPrivateKernelProver {
     artifactProvider;
-    simulationProvider;
+    simulator;
     log;
-    constructor(artifactProvider, simulationProvider, log = createLogger('bb-prover')){
+    constructor(artifactProvider, simulator, log = createLogger('bb-prover')){
         this.artifactProvider = artifactProvider;
-        this.simulationProvider = simulationProvider;
+        this.simulator = simulator;
         this.log = log;
     }
     async generateInitOutput(inputs) {
@@ -46,22 +45,27 @@ export class BBPrivateKernelProver {
         }
         return await this.simulateCircuitOutput(inputs, 'PrivateKernelTailToPublicArtifact', convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi, convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi);
     }
+    async generateHidingToRollupOutput(inputs) {
+        return await this.generateCircuitOutput(inputs, 'HidingKernelToRollup', convertHidingKernelToRollupInputsToWitnessMapWithAbi, convertPrivateKernelTailOutputsFromWitnessMapWithAbi);
+    }
+    async generateHidingToPublicOutput(inputs) {
+        return await this.generateCircuitOutput(inputs, 'HidingKernelToPublic', convertHidingKernelPublicInputsToWitnessMapWithAbi, 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)=>{
+        const outputWitness = await this.simulator.executeProtocolCircuit(witnessMap, compiledCircuit, foreignCallHandler).catch((err)=>{
             this.log.debug(`Failed to simulate ${circuitType}`, {
                 circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
                 error: err
             });
             throw err;
         });
-        const output = convertOutputs(outputWitness, compiledCircuit.abi);
+        const output = convertOutputs(outputWitness.witness, compiledCircuit.abi);
         this.log.debug(`Simulated ${circuitType}`, {
             eventName: 'circuit-simulation',
             circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-            duration: timer.ms(),
+            duration: outputWitness.duration,
             inputSize: inputs.toBuffer().length,
             outputSize: output.toBuffer().length
         });
@@ -71,22 +75,21 @@ export class BBPrivateKernelProver {
         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);
+        const outputWitness = await this.simulator.executeProtocolCircuit(witnessMap, compiledCircuit, foreignCallHandler);
+        const output = convertOutputs(outputWitness.witness, compiledCircuit.abi);
         this.log.debug(`Generated witness for ${circuitType}`, {
             eventName: 'circuit-witness-generation',
             circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-            duration: timer.ms(),
+            duration: outputWitness.duration,
             inputSize: inputs.toBuffer().length,
             outputSize: output.toBuffer().length
         });
-        const verificationKey = (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields;
+        const verificationKey = await this.artifactProvider.getCircuitVkByName(circuitType);
         const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
         const kernelOutput = {
             publicInputs: output,
             verificationKey,
-            outputWitness,
+            outputWitness: outputWitness.witness,
             bytecode
         };
         return kernelOutput;
@@ -94,13 +97,13 @@ export class BBPrivateKernelProver {
     async makeEmptyKernelSimulateOutput(publicInputs, circuitType) {
         const kernelProofOutput = {
             publicInputs,
-            verificationKey: (await this.artifactProvider.getCircuitVkByName(circuitType)).keyAsFields,
+            verificationKey: await this.artifactProvider.getCircuitVkByName(circuitType),
             outputWitness: new Map(),
             bytecode: Buffer.from([])
         };
         return kernelProofOutput;
     }
-    createClientIvcProof(_acirs, _witnessStack) {
+    createChonkProof(_executionSteps) {
         throw new Error('Not implemented');
     }
     computeGateCountForCircuit(_bytecode, _circuitName) {

package/dest/prover/client/native/bb_native_private_kernel_prover.d.ts

@@ -0,0 +1,23 @@
+import { type Logger } from '@aztec/foundation/log';
+import type { CircuitSimulator } from '@aztec/simulator/server';
+import { type PrivateExecutionStep } from '@aztec/stdlib/kernel';
+import type { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
+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 simulator: CircuitSimulator;
+    protected log: Logger;
+    private constructor();
+    static new(config: BBConfig, simulator: CircuitSimulator, log?: Logger): Promise<BBNativePrivateKernelProver>;
+    private _createChonkProof;
+    createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs>;
+    computeGateCountForCircuit(bytecode: Buffer, circuitName: string): Promise<number>;
+    private runInDirectory;
+}
+//# sourceMappingURL=bb_native_private_kernel_prover.d.ts.map

package/dest/prover/client/native/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/client/native/bb_native_private_kernel_prover.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,KAAK,oBAAoB,EAAkC,MAAM,sBAAsB,CAAC;AACjG,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAMvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,qBAAqB;IAElE,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,WAAW;cACA,SAAS,EAAE,gBAAgB;cAC3B,GAAG;IALxB,OAAO;WAUa,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,CAAC,EAAE,MAAM;YAWrE,iBAAiB;IAuBT,gBAAgB,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAQ7F,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 → client/native/bb_native_private_kernel_prover.js}

@@ -1,51 +1,48 @@
 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 { serializePrivateExecutionSteps } from '@aztec/stdlib/kernel';
 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';
+import { BB_RESULT, computeGateCountForCircuit, executeBbChonkProof } from '../../../bb/execute.js';
+import { readChonkProofFromOutputDirectory } from '../../proof_utils.js';
+import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
 /**
  * This proof creator implementation uses the native bb binary.
  */ export class BBNativePrivateKernelProver extends BBPrivateKernelProver {
     bbBinaryPath;
     bbWorkingDirectory;
     skipCleanup;
-    simulationProvider;
+    simulator;
     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;
+    constructor(bbBinaryPath, bbWorkingDirectory, skipCleanup, simulator, log = createLogger('bb-prover:native')){
+        super(new BundleArtifactProvider(), simulator, log), this.bbBinaryPath = bbBinaryPath, this.bbWorkingDirectory = bbWorkingDirectory, this.skipCleanup = skipCleanup, this.simulator = simulator, this.log = log;
     }
-    static async new(config, simulationProvider, log) {
+    static async new(config, simulator, log) {
         await fs.mkdir(config.bbWorkingDirectory, {
             recursive: true
         });
-        return new BBNativePrivateKernelProver(config.bbBinaryPath, config.bbWorkingDirectory, !!config.bbSkipCleanup, simulationProvider, log);
+        return new BBNativePrivateKernelProver(config.bbBinaryPath, config.bbWorkingDirectory, !!config.bbSkipCleanup, simulator, 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);
+    async _createChonkProof(directory, executionSteps) {
+        const inputsPath = path.join(directory, 'ivc-inputs.msgpack');
+        await fs.writeFile(inputsPath, serializePrivateExecutionSteps(executionSteps));
+        const provingResult = await executeBbChonkProof(this.bbBinaryPath, directory, inputsPath, this.log.info);
         if (provingResult.status === BB_RESULT.FAILURE) {
-            this.log.error(`Failed to generate client ivc proof`);
+            this.log.error(`Failed to generate chonk proof`);
             throw new Error(provingResult.reason);
         }
-        const proof = await readFromOutputDirectory(directory);
-        this.log.info(`Generated IVC proof`, {
+        const proof = await readChonkProofFromOutputDirectory(directory);
+        this.log.info(`Generated Chonk proof`, {
             duration: provingResult.durationMs,
             eventName: 'circuit-proving'
         });
         return proof;
     }
-    async createClientIvcProof(acirs, witnessStack) {
-        this.log.info(`Generating Client IVC proof`);
+    async createChonkProof(executionSteps) {
+        this.log.info(`Generating Chonk proof`);
         const operation = async (directory)=>{
-            return await this._createClientIvcProof(directory, acirs, witnessStack);
+            return await this._createChonkProof(directory, executionSteps);
         };
         return await this.runInDirectory(operation);
     }

package/dest/prover/client/wasm/bb_wasm_private_kernel_prover.d.ts

@@ -0,0 +1,15 @@
+import type { ArtifactProvider } from '@aztec/noir-protocol-circuits-types/types';
+import type { CircuitSimulator } from '@aztec/simulator/client';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
+import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
+import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
+export declare abstract class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
+    protected artifactProvider: ArtifactProvider;
+    protected simulator: CircuitSimulator;
+    private threads;
+    protected log: import("@aztec/foundation/log").Logger;
+    constructor(artifactProvider: ArtifactProvider, simulator: CircuitSimulator, threads?: number, log?: import("@aztec/foundation/log").Logger);
+    createChonkProof(executionSteps: PrivateExecutionStep[]): Promise<ChonkProofWithPublicInputs>;
+    computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number>;
+}
+//# sourceMappingURL=bb_wasm_private_kernel_prover.d.ts.map

package/dest/prover/client/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/prover/client/wasm/bb_wasm_private_kernel_prover.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAIlE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,8BAAsB,yBAA0B,SAAQ,qBAAqB;cAEtD,gBAAgB,EAAE,gBAAgB;cAClC,SAAS,EAAE,gBAAgB;IAC9C,OAAO,CAAC,OAAO;cACI,GAAG;gBAHH,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,gBAAgB,EACtC,OAAO,GAAE,MAAU,EACR,GAAG,yCAAiC;IAKnC,gBAAgB,CAAC,cAAc,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,0BAA0B,CAAC;IAqB7F,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAa3G"}

package/dest/prover/client/wasm/bb_wasm_private_kernel_prover.js

@@ -0,0 +1,46 @@
+import { AztecClientBackend } from '@aztec/bb.js';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { serializeWitness } from '@aztec/noir-noirc_abi';
+import { ChonkProofWithPublicInputs } from '@aztec/stdlib/proofs';
+import { ungzip } from 'pako';
+import { BBPrivateKernelProver } from '../bb_private_kernel_prover.js';
+export class BBWASMPrivateKernelProver extends BBPrivateKernelProver {
+    artifactProvider;
+    simulator;
+    threads;
+    log;
+    constructor(artifactProvider, simulator, threads = 1, log = createLogger('bb-prover:wasm')){
+        super(artifactProvider, simulator, log), this.artifactProvider = artifactProvider, this.simulator = simulator, this.threads = threads, this.log = log;
+    }
+    async createChonkProof(executionSteps) {
+        const timer = new Timer();
+        this.log.info(`Generating Chonk proof...`);
+        const backend = new AztecClientBackend(executionSteps.map((step)=>ungzip(step.bytecode)), {
+            threads: this.threads,
+            logger: this.log.verbose,
+            wasmPath: process.env.BB_WASM_PATH
+        });
+        const [proof] = await backend.prove(executionSteps.map((step)=>ungzip(serializeWitness(step.witness))), executionSteps.map((step)=>step.vk));
+        await backend.destroy();
+        this.log.info(`Generated Chonk proof`, {
+            eventName: 'chonk-proof-generation',
+            duration: timer.ms(),
+            proofSize: proof.length
+        });
+        return ChonkProofWithPublicInputs.fromBufferArray(proof);
+    }
+    async computeGateCountForCircuit(_bytecode, _circuitName) {
+        // Note we do not pass the vk to the backend. This is unneeded for gate counts.
+        const backend = new AztecClientBackend([
+            ungzip(_bytecode)
+        ], {
+            threads: this.threads,
+            logger: this.log.verbose,
+            wasmPath: process.env.BB_WASM_PATH
+        });
+        const gateCount = await backend.gates();
+        await backend.destroy();
+        return gateCount[0];
+    }
+}

package/dest/prover/client/wasm/bundle.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../../src/prover/client/wasm/bundle.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,qBAAa,+BAAgC,SAAQ,yBAAyB;gBAChE,SAAS,EAAE,gBAAgB,EAAE,OAAO,SAAK,EAAE,GAAG,yCAAwC;CAGnG"}

package/dest/{wasm → prover/client/wasm}/bundle.js

@@ -2,7 +2,7 @@ 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);
+    constructor(simulator, threads = 16, log = createLogger('bb-prover:wasm:bundle')){
+        super(new BundleArtifactProvider(), simulator, threads, log);
     }
 }

package/dest/prover/client/wasm/lazy.d.ts

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

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

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

package/dest/{wasm → prover/client/wasm}/lazy.js

@@ -2,7 +2,7 @@ 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);
+    constructor(simulator, threads = 16, log = createLogger('bb-prover:wasm:lazy')){
+        super(new LazyArtifactProvider(), simulator, threads, log);
     }
 }

package/dest/prover/index.d.ts

@@ -1,4 +1,3 @@
-export * from './bb_prover.js';
-export * from './bb_native_private_kernel_prover.js';
-export * from './client_ivc_proof_utils.js';
+export * from './server/bb_prover.js';
+export * from './proof_utils.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prover/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prover/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC"}

package/dest/prover/index.js

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

package/dest/prover/proof_utils.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '@aztec/foundation/log';
+import { ChonkProofWithPublicInputs, RecursiveProof } from '@aztec/stdlib/proofs';
+import type { VerificationKeyData } from '@aztec/stdlib/vks';
+/**
+ * Create a ChonkProof proof file.
+ *
+ * @param directory the directory to read the proof from.
+ * @returns the encapsulated chonk proof
+ */
+export declare function readChonkProofFromOutputDirectory(directory: string): Promise<ChonkProofWithPublicInputs>;
+/**
+ * Serialize a ChonkProof to a proof file.
+ *
+ * @param proof the ChonkProof from object
+ * @param directory the directory to write in
+ */
+export declare function writeChonkProofToPath(chonkProof: ChonkProofWithPublicInputs, outputPath: string): Promise<void>;
+export declare function readProofsFromOutputDirectory<PROOF_LENGTH extends number>(directory: string, vkData: VerificationKeyData, proofLength: PROOF_LENGTH, logger: Logger): Promise<RecursiveProof<PROOF_LENGTH>>;
+//# sourceMappingURL=proof_utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proof_utils.d.ts","sourceRoot":"","sources":["../../src/prover/proof_utils.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,0BAA0B,EAAS,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAQ7D;;;;;GAKG;AACH,wBAAsB,iCAAiC,CAAC,SAAS,EAAE,MAAM,uCAKxE;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,UAAU,EAAE,0BAA0B,EAAE,UAAU,EAAE,MAAM,iBAIrG;AAuBD,wBAAsB,6BAA6B,CAAC,YAAY,SAAS,MAAM,EAC7E,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,mBAAmB,EAC3B,WAAW,EAAE,YAAY,EACzB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CA2CvC"}

package/dest/prover/proof_utils.js

@@ -0,0 +1,72 @@
+import { CHONK_PROOF_LENGTH, HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE, IPA_CLAIM_SIZE, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, PAIRING_POINTS_SIZE, ULTRA_KECCAK_PROOF_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { ChonkProofWithPublicInputs, Proof, RecursiveProof } from '@aztec/stdlib/proofs';
+import assert from 'assert';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { PROOF_FILENAME, PUBLIC_INPUTS_FILENAME } from '../bb/execute.js';
+/**
+ * Create a ChonkProof proof file.
+ *
+ * @param directory the directory to read the proof from.
+ * @returns the encapsulated chonk proof
+ */ export async function readChonkProofFromOutputDirectory(directory) {
+    const proofFilename = path.join(directory, PROOF_FILENAME);
+    const binaryProof = await fs.readFile(proofFilename);
+    const proofFields = splitBufferIntoFields(binaryProof);
+    return new ChonkProofWithPublicInputs(proofFields);
+}
+/**
+ * Serialize a ChonkProof to a proof file.
+ *
+ * @param proof the ChonkProof from object
+ * @param directory the directory to write in
+ */ export async function writeChonkProofToPath(chonkProof, outputPath) {
+    // NB: Don't use chonkProof.toBuffer here because it will include the proof length.
+    const fieldsBuf = Buffer.concat(chonkProof.fieldsWithPublicInputs.map((field)=>field.toBuffer()));
+    await fs.writeFile(outputPath, fieldsBuf);
+}
+function getNumCustomPublicInputs(proofLength, vkData) {
+    let numPublicInputs = vkData.numPublicInputs;
+    if (proofLength == CHONK_PROOF_LENGTH) {
+        numPublicInputs -= HIDING_KERNEL_IO_PUBLIC_INPUTS_SIZE;
+    } else {
+        numPublicInputs -= PAIRING_POINTS_SIZE;
+        if (proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH) {
+            numPublicInputs -= IPA_CLAIM_SIZE;
+        }
+    }
+    return numPublicInputs;
+}
+function splitBufferIntoFields(buffer) {
+    const fields = [];
+    for(let i = 0; i < buffer.length / Fr.SIZE_IN_BYTES; i++){
+        fields.push(Fr.fromBuffer(buffer.subarray(i * Fr.SIZE_IN_BYTES, (i + 1) * Fr.SIZE_IN_BYTES)));
+    }
+    return fields;
+}
+export async function readProofsFromOutputDirectory(directory, vkData, proofLength, logger) {
+    assert(proofLength == CHONK_PROOF_LENGTH || proofLength == NESTED_RECURSIVE_PROOF_LENGTH || proofLength == NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH || proofLength == ULTRA_KECCAK_PROOF_LENGTH, `Proof length must be one of the expected proof lengths, received ${proofLength}`);
+    const publicInputsFilename = path.join(directory, PUBLIC_INPUTS_FILENAME);
+    const proofFilename = path.join(directory, PROOF_FILENAME);
+    // Handle CHONK separately because bb outputs the proof fields with public inputs for CHONK.
+    const isChonk = proofLength == CHONK_PROOF_LENGTH;
+    const [binaryPublicInputs, binaryProof] = await Promise.all([
+        isChonk ? Buffer.alloc(0) : fs.readFile(publicInputsFilename),
+        fs.readFile(proofFilename)
+    ]);
+    const numPublicInputs = getNumCustomPublicInputs(proofLength, vkData);
+    let fieldsWithoutPublicInputs = splitBufferIntoFields(binaryProof);
+    if (isChonk) {
+        fieldsWithoutPublicInputs = fieldsWithoutPublicInputs.slice(numPublicInputs);
+    }
+    assert(fieldsWithoutPublicInputs.length == proofLength, `Proof fields length mismatch: ${fieldsWithoutPublicInputs.length} != ${proofLength}`);
+    // Concat binary public inputs and binary proof
+    // This buffer will have the form: [binary public inputs, binary proof]
+    const binaryProofWithPublicInputs = Buffer.concat([
+        binaryPublicInputs,
+        binaryProof
+    ]);
+    logger.debug(`Circuit path: ${directory}, proof fields length: ${fieldsWithoutPublicInputs.length}, num public inputs: ${numPublicInputs}, circuit size: ${vkData.circuitSize}`);
+    return new RecursiveProof(fieldsWithoutPublicInputs, new Proof(binaryProofWithPublicInputs, numPublicInputs), true, proofLength);
+}

package/dest/prover/server/bb_prover.d.ts

@@ -0,0 +1,109 @@
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
+import { type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server';
+import type { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
+import { type ProofAndVerificationKey, type PublicInputsAndRecursiveProof, type ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
+import { Proof } from '@aztec/stdlib/proofs';
+import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, CheckpointRollupPublicInputs, CheckpointRootRollupPrivateInputs, CheckpointRootSingleBlockRollupPrivateInputs, type PrivateTxBaseRollupPrivateInputs, PublicChonkVerifierPrivateInputs, PublicChonkVerifierPublicInputs, PublicTxBaseRollupPrivateInputs, type RootRollupPrivateInputs, type RootRollupPublicInputs, type TxMergeRollupPrivateInputs, type TxRollupPublicInputs } 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: ParityBasePrivateInputs): 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: ParityRootPrivateInputs): 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, skipPublicInputsValidation?: boolean): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;
+    getPublicChonkVerifierProof(inputs: PublicChonkVerifierPrivateInputs): Promise<PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    /**
+     * Simulates the base rollup circuit from its inputs.
+     * @param inputs - Inputs to the circuit.
+     * @returns The public inputs as outputs of the simulation.
+     */
+    getPrivateTxBaseRollupProof(inputs: PrivateTxBaseRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, 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
+     */
+    getPublicTxBaseRollupProof(inputs: PublicTxBaseRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, 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.
+     */
+    getTxMergeRollupProof(input: TxMergeRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootFirstRollupProof(input: BlockRootFirstRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootSingleTxFirstRollupProof(input: BlockRootSingleTxFirstRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootEmptyTxFirstRollupProof(input: BlockRootEmptyTxFirstRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootRollupProof(input: BlockRootRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockRootSingleTxRollupProof(input: BlockRootSingleTxRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getBlockMergeRollupProof(input: BlockMergeRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getCheckpointRootRollupProof(input: CheckpointRootRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getCheckpointRootSingleBlockRollupProof(input: CheckpointRootSingleBlockRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getCheckpointPaddingRollupProof(input: CheckpointPaddingRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    getCheckpointMergeRollupProof(input: CheckpointMergeRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, 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: RootRollupPrivateInputs): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
+    private createRecursiveProofAndVerify;
+    private generateProofWithBB;
+    private generateAvmProofWithBB;
+    private createAvmProof;
+    /**
+     * 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, publicInputs: AvmCircuitPublicInputs): 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 readAvmProofAsFields;
+    private runInDirectory;
+}
+//# sourceMappingURL=bb_prover.d.ts.map