@aztec/bb-prover 0.0.0-test.0

package/dest/test/test_circuit_prover.d.ts

@@ -0,0 +1,81 @@
+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 SimulationProvider } from '@aztec/simulator/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 { type 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 TelemetryClient } from '@aztec/telemetry-client';
+type TestDelay = {
+    proverTestDelayType: 'fixed';
+    proverTestDelayMs?: number;
+} | {
+    proverTestDelayType: 'realistic';
+    proverTestDelayFactor?: number;
+};
+/**
+ * A class for use in testing situations (e2e, unit test, etc) and temporarily for assembling a block in the sequencer.
+ * Simulates circuits using the most efficient method and performs no proving.
+ */
+export declare class TestCircuitProver implements ServerCircuitProver {
+    private simulationProvider?;
+    private opts;
+    private wasmSimulator;
+    private instrumentation;
+    private logger;
+    constructor(simulationProvider?: SimulationProvider | undefined, opts?: TestDelay, telemetry?: TelemetryClient);
+    get tracer(): import("@aztec/telemetry-client").Tracer;
+    /**
+     * 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>>;
+    getTubeProof(_tubeInput: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>;
+    getPrivateBaseRollupProof(inputs: PrivateBaseRollupInputs): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+    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>>;
+    getAvmProof(_inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>>;
+    private applyDelay;
+    verifyProof(_1: ServerProtocolArtifact, _2: Proof): Promise<void>;
+    private simulate;
+}
+export {};
+//# sourceMappingURL=test_circuit_prover.d.ts.map

package/dest/test/test_circuit_prover.d.ts.map

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

package/dest/test/test_circuit_prover.js

@@ -0,0 +1,175 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { AVM_PROOF_LENGTH_IN_FIELDS, AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { Timer } from '@aztec/foundation/timer';
+import { SimulatedServerCircuitArtifacts, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap, convertSimulatedBlockRootRollupInputsToWitnessMap, convertSimulatedBlockRootRollupOutputsFromWitnessMap, convertSimulatedPrivateBaseRollupInputsToWitnessMap, convertSimulatedPrivateBaseRollupOutputsFromWitnessMap, convertSimulatedPublicBaseRollupInputsToWitnessMap, convertSimulatedPublicBaseRollupOutputsFromWitnessMap, convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap, convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap } from '@aztec/noir-protocol-circuits-types/server';
+import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import { WASMSimulatorWithBlobs, emitCircuitSimulationStats } from '@aztec/simulator/server';
+import { makeProofAndVerificationKey, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType, makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
+import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { ProverInstrumentation } from '../instrumentation.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+import { PROOF_DELAY_MS, WITGEN_DELAY_MS } from './delay_values.js';
+/**
+ * A class for use in testing situations (e2e, unit test, etc) and temporarily for assembling a block in the sequencer.
+ * Simulates circuits using the most efficient method and performs no proving.
+ */ export class TestCircuitProver {
+    simulationProvider;
+    opts;
+    wasmSimulator;
+    instrumentation;
+    logger;
+    constructor(simulationProvider, opts = {
+        proverTestDelayType: 'fixed',
+        proverTestDelayMs: 0
+    }, telemetry = getTelemetryClient()){
+        this.simulationProvider = simulationProvider;
+        this.opts = opts;
+        this.wasmSimulator = new WASMSimulatorWithBlobs();
+        this.logger = createLogger('bb-prover:test-prover');
+        this.instrumentation = new ProverInstrumentation(telemetry, 'TestCircuitProver');
+    }
+    get tracer() {
+        return this.instrumentation.tracer;
+    }
+    /**
+   * Simulates the base parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */ getBaseParityProof(inputs) {
+        return this.applyDelay(ProvingRequestType.BASE_PARITY, ()=>this.simulate(inputs, 'BaseParityArtifact', RECURSIVE_PROOF_LENGTH, convertBaseParityInputsToWitnessMap, convertBaseParityOutputsFromWitnessMap));
+    }
+    /**
+   * Simulates the root parity circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs of the parity circuit.
+   */ getRootParityProof(inputs) {
+        return this.applyDelay(ProvingRequestType.ROOT_PARITY, ()=>this.simulate(inputs, 'RootParityArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootParityInputsToWitnessMap, convertRootParityOutputsFromWitnessMap));
+    }
+    getTubeProof(_tubeInput) {
+        return this.applyDelay(ProvingRequestType.TUBE_PROOF, ()=>makeProofAndVerificationKey(makeEmptyRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
+    getPrivateBaseRollupProof(inputs) {
+        return this.applyDelay(ProvingRequestType.PRIVATE_BASE_ROLLUP, ()=>this.simulate(inputs, 'PrivateBaseRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSimulatedPrivateBaseRollupInputsToWitnessMap, convertSimulatedPrivateBaseRollupOutputsFromWitnessMap));
+    }
+    getPublicBaseRollupProof(inputs) {
+        return this.applyDelay(ProvingRequestType.PUBLIC_BASE_ROLLUP, ()=>this.simulate(inputs, 'PublicBaseRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSimulatedPublicBaseRollupInputsToWitnessMap, convertSimulatedPublicBaseRollupOutputsFromWitnessMap));
+    }
+    /**
+   * 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) {
+        return this.applyDelay(ProvingRequestType.MERGE_ROLLUP, ()=>this.simulate(input, 'MergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertMergeRollupInputsToWitnessMap, convertMergeRollupOutputsFromWitnessMap));
+    }
+    /**
+   * 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) {
+        return this.applyDelay(ProvingRequestType.BLOCK_ROOT_ROLLUP, ()=>this.simulate(input, 'BlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSimulatedBlockRootRollupInputsToWitnessMap, convertSimulatedBlockRootRollupOutputsFromWitnessMap));
+    }
+    async getSingleTxBlockRootRollupProof(input) {
+        return await this.applyDelay(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP, ()=>this.simulate(input, 'SingleTxBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertSimulatedSingleTxBlockRootRollupInputsToWitnessMap, convertSimulatedSingleTxBlockRootRollupOutputsFromWitnessMap));
+    }
+    /**
+   * 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) {
+        return this.applyDelay(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, ()=>this.simulate(input, 'EmptyBlockRootRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertEmptyBlockRootRollupInputsToWitnessMap, convertEmptyBlockRootRollupOutputsFromWitnessMap));
+    }
+    /**
+   * 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) {
+        return this.applyDelay(ProvingRequestType.BLOCK_MERGE_ROLLUP, ()=>this.simulate(input, 'BlockMergeRollupArtifact', NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, convertBlockMergeRollupInputsToWitnessMap, convertBlockMergeRollupOutputsFromWitnessMap));
+    }
+    /**
+   * 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) {
+        return this.applyDelay(ProvingRequestType.ROOT_ROLLUP, ()=>this.simulate(input, 'RootRollupArtifact', NESTED_RECURSIVE_PROOF_LENGTH, convertRootRollupInputsToWitnessMap, convertRootRollupOutputsFromWitnessMap));
+    }
+    getAvmProof(_inputs) {
+        // We can't simulate the AVM because we don't have enough context to do so (e.g., DBs).
+        // We just return an empty proof and VK data.
+        this.logger.debug('Skipping AVM simulation in TestCircuitProver.');
+        return this.applyDelay(ProvingRequestType.PUBLIC_VM, ()=>makeProofAndVerificationKey(makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS), VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS)));
+    }
+    async applyDelay(type, fn) {
+        const timer = new Timer();
+        const res = await fn();
+        const duration = timer.ms();
+        if (this.opts.proverTestDelayType === 'fixed') {
+            await sleep(Math.max(0, (this.opts.proverTestDelayMs ?? 0) - duration));
+        } else if (this.opts.proverTestDelayType === 'realistic') {
+            const delay = WITGEN_DELAY_MS[type] + PROOF_DELAY_MS[type];
+            await sleep(Math.max(0, delay * (this.opts.proverTestDelayFactor ?? 1) - duration));
+        }
+        return res;
+    }
+    // Not implemented for test circuits
+    verifyProof(_1, _2) {
+        return Promise.reject(new Error('Method not implemented.'));
+    }
+    async simulate(input, artifactName, proofLength, convertInput, convertOutput) {
+        const timer = new Timer();
+        const witnessMap = convertInput(input);
+        const circuitName = mapProtocolArtifactNameToCircuitName(artifactName);
+        let simulationProvider = this.simulationProvider ?? this.wasmSimulator;
+        if ([
+            'BlockRootRollupArtifact',
+            'SingleTxBlockRootRollupArtifact'
+        ].includes(artifactName)) {
+            // TODO(#10323): temporarily force block root to use wasm while we simulate
+            // the blob operations with an oracle. Appears to be no way to provide nativeACVM with a foreign call hander.
+            simulationProvider = this.wasmSimulator;
+        }
+        const witness = await simulationProvider.executeProtocolCircuit(witnessMap, SimulatedServerCircuitArtifacts[artifactName]);
+        const result = convertOutput(witness);
+        this.instrumentation.recordDuration('simulationDuration', circuitName, timer);
+        emitCircuitSimulationStats(circuitName, timer.ms(), input.toBuffer().length, result.toBuffer().length, this.logger);
+        return makePublicInputsAndRecursiveProof(result, makeRecursiveProof(proofLength), ProtocolCircuitVks[artifactName]);
+    }
+}
+_ts_decorate([
+    trackSpan('TestCircuitProver.getBaseParityProof')
+], TestCircuitProver.prototype, "getBaseParityProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getRootParityProof')
+], TestCircuitProver.prototype, "getRootParityProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getPrivateBaseRollupProof')
+], TestCircuitProver.prototype, "getPrivateBaseRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getPublicBaseRollupProof')
+], TestCircuitProver.prototype, "getPublicBaseRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getMergeRollupProof')
+], TestCircuitProver.prototype, "getMergeRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getBlockRootRollupProof')
+], TestCircuitProver.prototype, "getBlockRootRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getSingleTxBlockRootRollupProof')
+], TestCircuitProver.prototype, "getSingleTxBlockRootRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getEmptyBlockRootRollupProof')
+], TestCircuitProver.prototype, "getEmptyBlockRootRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getBlockMergeRollupProof')
+], TestCircuitProver.prototype, "getBlockMergeRollupProof", null);
+_ts_decorate([
+    trackSpan('TestCircuitProver.getRootRollupProof')
+], TestCircuitProver.prototype, "getRootRollupProof", null);

package/dest/test/test_verifier.d.ts

@@ -0,0 +1,6 @@
+import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import type { Tx } from '@aztec/stdlib/tx';
+export declare class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
+    verifyProof(_tx: Tx): Promise<boolean>;
+}
+//# sourceMappingURL=test_verifier.d.ts.map

package/dest/test/test_verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_verifier.d.ts","sourceRoot":"","sources":["../../src/test/test_verifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,mBAAoB,YAAW,6BAA6B;IACvE,WAAW,CAAC,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAGvC"}

package/dest/test/test_verifier.js

@@ -0,0 +1,5 @@
+export class TestCircuitVerifier {
+    verifyProof(_tx) {
+        return Promise.resolve(true);
+    }
+}

package/dest/verification_key/verification_key_data.d.ts

@@ -0,0 +1,9 @@
+import { VerificationKeyData } from '@aztec/stdlib/vks';
+/**
+ * Reads the verification key data stored at the specified location and parses into a VerificationKeyData
+ * @param vkDirectoryPath - The directory containing the verification key data files
+ * @returns The verification key data
+ */
+export declare function extractVkData(vkDirectoryPath: string): Promise<VerificationKeyData>;
+export declare function extractAvmVkData(vkDirectoryPath: string): Promise<VerificationKeyData>;
+//# sourceMappingURL=verification_key_data.d.ts.map

package/dest/verification_key/verification_key_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification_key_data.d.ts","sourceRoot":"","sources":["../../src/verification_key/verification_key_data.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAQjF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAWzF;AAGD,wBAAsB,gBAAgB,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAc5F"}

package/dest/verification_key/verification_key_data.js

@@ -0,0 +1,44 @@
+import { AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { hashVK } from '@aztec/stdlib/hash';
+import { VerificationKeyAsFields, VerificationKeyData } from '@aztec/stdlib/vks';
+import { strict as assert } from 'assert';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { VK_FIELDS_FILENAME, VK_FILENAME } from '../bb/execute.js';
+/**
+ * Reads the verification key data stored at the specified location and parses into a VerificationKeyData
+ * @param vkDirectoryPath - The directory containing the verification key data files
+ * @returns The verification key data
+ */ export async function extractVkData(vkDirectoryPath) {
+    const [rawFields, rawBinary] = await Promise.all([
+        fs.readFile(path.join(vkDirectoryPath, VK_FIELDS_FILENAME), {
+            encoding: 'utf-8'
+        }),
+        fs.readFile(path.join(vkDirectoryPath, VK_FILENAME))
+    ]);
+    const fieldsJson = JSON.parse(rawFields);
+    const fields = fieldsJson.map(Fr.fromHexString);
+    // The hash is not included in the BB response
+    const vkHash = await hashVK(fields);
+    const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+    return new VerificationKeyData(vkAsFields, rawBinary);
+}
+// TODO: This was adapted from the above function. A refactor might be needed.
+export async function extractAvmVkData(vkDirectoryPath) {
+    const [rawFields, rawBinary] = await Promise.all([
+        fs.readFile(path.join(vkDirectoryPath, VK_FIELDS_FILENAME), {
+            encoding: 'utf-8'
+        }),
+        fs.readFile(path.join(vkDirectoryPath, VK_FILENAME))
+    ]);
+    const fieldsJson = JSON.parse(rawFields);
+    const fields = fieldsJson.map(Fr.fromHexString);
+    // The first item is the hash, this is not part of the actual VK
+    // TODO: is the above actually the case?
+    const vkHash = fields[0];
+    assert(fields.length === AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, 'Invalid AVM verification key length');
+    const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+    const vk = new VerificationKeyData(vkAsFields, rawBinary);
+    return vk;
+}

package/dest/verifier/bb_verifier.d.ts

@@ -0,0 +1,17 @@
+import { type Logger } from '@aztec/foundation/log';
+import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import type { Proof } from '@aztec/stdlib/proofs';
+import { Tx } from '@aztec/stdlib/tx';
+import type { VerificationKeyData } from '@aztec/stdlib/vks';
+import type { BBConfig } from '../config.js';
+export declare class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
+    private config;
+    private logger;
+    private constructor();
+    static new(config: BBConfig, logger?: Logger): Promise<BBCircuitVerifier>;
+    getVerificationKeyData(circuitType: ServerProtocolArtifact): VerificationKeyData;
+    verifyProofForCircuit(circuit: ServerProtocolArtifact, proof: Proof): Promise<void>;
+    verifyProof(tx: Tx): Promise<boolean>;
+}
+//# sourceMappingURL=bb_verifier.d.ts.map

package/dest/verifier/bb_verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bb_verifier.d.ts","sourceRoot":"","sources":["../../src/verifier/bb_verifier.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAA0B,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAChH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAM7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAK7C,qBAAa,iBAAkB,YAAW,6BAA6B;IACjD,OAAO,CAAC,MAAM;IAAY,OAAO,CAAC,MAAM;IAA5D,OAAO;WAEa,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAqC;IAK9E,sBAAsB,CAAC,WAAW,EAAE,sBAAsB,GAAG,mBAAmB;IAQ1E,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK;IAkCnE,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CA4CnD"}

package/dest/verifier/bb_verifier.js

@@ -0,0 +1,86 @@
+import { runInDirectory } from '@aztec/foundation/fs';
+import { createLogger } from '@aztec/foundation/log';
+import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import { Tx } from '@aztec/stdlib/tx';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { BB_RESULT, PROOF_FILENAME, VK_FILENAME, verifyClientIvcProof, verifyProof } from '../bb/execute.js';
+import { getUltraHonkFlavorForCircuit } from '../honk.js';
+import { writeToOutputDirectory } from '../prover/client_ivc_proof_utils.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+export class BBCircuitVerifier {
+    config;
+    logger;
+    constructor(config, logger){
+        this.config = config;
+        this.logger = logger;
+    }
+    static async new(config, logger = createLogger('bb-prover:verifier')) {
+        await fs.mkdir(config.bbWorkingDirectory, {
+            recursive: true
+        });
+        return new BBCircuitVerifier(config, logger);
+    }
+    getVerificationKeyData(circuitType) {
+        const vk = ServerCircuitVks[circuitType];
+        if (vk === undefined) {
+            throw new Error('Could not find VK for server artifact ' + circuitType);
+        }
+        return vk;
+    }
+    async verifyProofForCircuit(circuit, proof) {
+        const operation = async (bbWorkingDirectory)=>{
+            const proofFileName = path.join(bbWorkingDirectory, PROOF_FILENAME);
+            const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
+            const verificationKey = this.getVerificationKeyData(circuit);
+            this.logger.debug(`${circuit} Verifying with key: ${verificationKey.keyAsFields.hash.toString()}`);
+            await fs.writeFile(proofFileName, proof.buffer);
+            await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+            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);
+            }
+            this.logger.debug(`${circuit} verification successful`, {
+                circuitName: mapProtocolArtifactNameToCircuitName(circuit),
+                duration: result.durationMs,
+                eventName: 'circuit-verification',
+                proofType: 'ultra-honk'
+            });
+        };
+        await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
+    }
+    async verifyProof(tx) {
+        try {
+            // TODO(#7370) The verification keys should be supplied separately and based on the expectedCircuit
+            // rather than read from the tx object itself. We also need the vks for the translator and ecc, which
+            // are not being saved along the other vks yet. Reuse the 'verifyProofForCircuit' method above once
+            // we have all the verification keys available.
+            const expectedCircuit = tx.data.forPublic ? 'PrivateKernelTailToPublicArtifact' : 'PrivateKernelTailArtifact';
+            const circuit = 'ClientIVC';
+            // Block below is almost copy-pasted from verifyProofForCircuit
+            const operation = async (bbWorkingDirectory)=>{
+                const logFunction = (message)=>{
+                    this.logger.debug(`${circuit} BB out - ${message}`);
+                };
+                await writeToOutputDirectory(tx.clientIvcProof, bbWorkingDirectory);
+                const result = await verifyClientIvcProof(this.config.bbBinaryPath, bbWorkingDirectory.concat('/proof'), bbWorkingDirectory.concat('/vk'), logFunction);
+                if (result.status === BB_RESULT.FAILURE) {
+                    const errorMessage = `Failed to verify ${circuit} proof!`;
+                    throw new Error(errorMessage);
+                }
+                this.logger.debug(`${circuit} verification successful`, {
+                    circuitName: mapProtocolArtifactNameToCircuitName(expectedCircuit),
+                    duration: result.durationMs,
+                    eventName: 'circuit-verification',
+                    proofType: 'client-ivc'
+                });
+            };
+            await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
+            return true;
+        } catch (err) {
+            this.logger.warn(`Failed to verify ClientIVC proof for tx ${Tx.getHash(tx)}: ${String(err)}`);
+            return false;
+        }
+    }
+}

package/dest/verifier/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bb_verifier.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/verifier/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dest/verifier/index.js

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

package/dest/wasm/bb_wasm_private_kernel_prover.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { ArtifactProvider } from '@aztec/noir-protocol-circuits-types/types';
+import type { SimulationProvider } from '@aztec/simulator/client';
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
+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>;
+    computeGateCountForCircuit(_bytecode: Buffer, _circuitName: string): Promise<number>;
+}
+//# 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":";;AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,KAAK,EAAE,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;IAmB1F,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAY3G"}

package/dest/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 { ClientIvcProof } from '@aztec/stdlib/proofs';
+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 {
+    artifactProvider;
+    simulationProvider;
+    threads;
+    log;
+    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,
+            logger: this.log.verbose,
+            wasmPath: process.env.BB_WASM_PATH
+        });
+        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));
+    }
+    async computeGateCountForCircuit(_bytecode, _circuitName) {
+        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/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,KAAK,EAAE,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,8 @@
+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);
+    }
+}

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,KAAK,EAAE,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,8 @@
+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);
+    }
+}