@aztec/bb-prover 0.0.0-test.0

package/src/prover/client_ivc_proof_utils.ts

@@ -0,0 +1,42 @@
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+
+export const CLIENT_IVC_VK_FILE_NAME = 'vk';
+export const CLIENT_IVC_PROOF_FILE_NAME = 'proof';
+
+/**
+ * TODO(#7371): eventually remove client_ivc_prove_output_all_msgpack and properly handle these accumulators and VKs
+ * Create a ClientIvcProof from the result of client_ivc_prove_output_all or client_ivc_prove_output_all_msgpack
+ * @param directory the directory of results
+ * @returns the encapsulated client ivc proof
+ */
+export async function readFromOutputDirectory(directory: string) {
+  const [clientIvcVkBuffer, clientIvcProofBuffer] = await Promise.all(
+    [CLIENT_IVC_VK_FILE_NAME, CLIENT_IVC_PROOF_FILE_NAME].map(fileName => fs.readFile(join(directory, fileName))),
+  );
+  return new ClientIvcProof(clientIvcProofBuffer, clientIvcVkBuffer);
+}
+
+/**
+ * TODO(#7371): eventually remove client_ivc_prove_output_all_msgpack and properly handle these accumulators and VKs
+ * Serialize a ClientIvcProof to the files expected by prove_tube
+ *
+ * Example usage:
+ *  await runInDirectory(bbWorkingDirectory, async (dir: string) => {
+ *    await privateTx.clientIvcProof!.writeToOutputDirectory(bbWorkingDirectory);
+ *    const result = await generateTubeProof(bbPath, dir, logger.info)
+ *    expect(result.status).toBe(BB_RESULT.SUCCESS)
+ *  });
+ * @param proof the ClientIvcProof from readFromOutputDirectory
+ * @param directory the directory of results
+ */
+export async function writeToOutputDirectory(clientIvcProof: ClientIvcProof, directory: string) {
+  const { clientIvcProofBuffer, clientIvcVkBuffer } = clientIvcProof;
+  const fileData = [
+    [CLIENT_IVC_PROOF_FILE_NAME, clientIvcProofBuffer],
+    [CLIENT_IVC_VK_FILE_NAME, clientIvcVkBuffer],
+  ] as const;
+  await Promise.all(fileData.map(([fileName, buffer]) => fs.writeFile(join(directory, fileName), buffer)));
+}

package/src/prover/index.ts

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

package/src/stats.ts

@@ -0,0 +1,64 @@
+import type { ProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import type { CircuitName } from '@aztec/stdlib/stats';
+
+export function mapProtocolArtifactNameToCircuitName(artifact: ProtocolArtifact): CircuitName {
+  switch (artifact) {
+    case 'BaseParityArtifact':
+      return 'base-parity';
+    case 'RootParityArtifact':
+      return 'root-parity';
+    case 'PrivateBaseRollupArtifact':
+      return 'private-base-rollup';
+    case 'PublicBaseRollupArtifact':
+      return 'public-base-rollup';
+    case 'MergeRollupArtifact':
+      return 'merge-rollup';
+    case 'BlockRootRollupArtifact':
+      return 'block-root-rollup';
+    case 'SingleTxBlockRootRollupArtifact':
+      return 'single-tx-block-root-rollup';
+    case 'EmptyBlockRootRollupArtifact':
+      return 'empty-block-root-rollup';
+    case 'BlockMergeRollupArtifact':
+      return 'block-merge-rollup';
+    case 'RootRollupArtifact':
+      return 'root-rollup';
+    case 'PrivateKernelInitArtifact':
+      return 'private-kernel-init';
+    case 'PrivateKernelInnerArtifact':
+      return 'private-kernel-inner';
+    case 'PrivateKernelTailArtifact':
+      return 'private-kernel-tail';
+    case 'PrivateKernelTailToPublicArtifact':
+      return 'private-kernel-tail-to-public';
+    default: {
+      if (artifact.startsWith('PrivateKernelReset')) {
+        return 'private-kernel-reset';
+      }
+      throw new Error(`Unknown circuit type: ${artifact}`);
+    }
+  }
+}
+
+export function isProtocolArtifactRecursive(artifact: ProtocolArtifact): boolean {
+  switch (artifact) {
+    case 'BaseParityArtifact':
+    case 'RootParityArtifact':
+    case 'PrivateBaseRollupArtifact':
+    case 'PublicBaseRollupArtifact':
+    case 'MergeRollupArtifact':
+    case 'BlockRootRollupArtifact':
+    case 'SingleTxBlockRootRollupArtifact':
+    case 'EmptyBlockRootRollupArtifact':
+    case 'BlockMergeRollupArtifact':
+    case 'RootRollupArtifact':
+      return true;
+    default: {
+      if (artifact.startsWith('PrivateKernel')) {
+        // The kernel prover, where these are used, eventually calls `createClientIvcProof`, which is recursive.
+        return true;
+      }
+      throw new Error(`Unknown circuit type: ${artifact}`);
+    }
+  }
+}

package/src/test/delay_values.ts

@@ -0,0 +1,31 @@
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+
+export const WITGEN_DELAY_MS: Record<ProvingRequestType, number> = {
+  [ProvingRequestType.BASE_PARITY]: 60,
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 650,
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 60_000,
+  [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: 0,
+  [ProvingRequestType.MERGE_ROLLUP]: 0,
+  [ProvingRequestType.PRIVATE_BASE_ROLLUP]: 400_000,
+  [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: 0, // TBD
+  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: 470_000,
+  [ProvingRequestType.ROOT_PARITY]: 100,
+  [ProvingRequestType.ROOT_ROLLUP]: 650,
+  [ProvingRequestType.TUBE_PROOF]: 0,
+  [ProvingRequestType.PUBLIC_VM]: 0,
+};
+
+export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
+  [ProvingRequestType.BASE_PARITY]: 3_000,
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: 15_000,
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: 55_000,
+  [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: 0,
+  [ProvingRequestType.MERGE_ROLLUP]: 0,
+  [ProvingRequestType.PRIVATE_BASE_ROLLUP]: 145_000,
+  [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: 0, // TBD
+  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: 160_000,
+  [ProvingRequestType.ROOT_PARITY]: 30_000,
+  [ProvingRequestType.ROOT_ROLLUP]: 15_000,
+  [ProvingRequestType.TUBE_PROOF]: 30_000,
+  [ProvingRequestType.PUBLIC_VM]: 0,
+};

package/src/test/index.ts

@@ -0,0 +1,2 @@
+export * from './test_circuit_prover.js';
+export * from './test_verifier.js';

package/src/test/test_circuit_prover.ts

@@ -0,0 +1,368 @@
+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 {
+  type ServerProtocolArtifact,
+  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 { type SimulationProvider, WASMSimulatorWithBlobs, emitCircuitSimulationStats } from '@aztec/simulator/server';
+import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import {
+  type ProofAndVerificationKey,
+  type PublicInputsAndRecursiveProof,
+  type ServerCircuitProver,
+  makeProofAndVerificationKey,
+  makePublicInputsAndRecursiveProof,
+} from '@aztec/stdlib/interfaces/server';
+import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import { type Proof, ProvingRequestType, makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
+import type {
+  BaseOrMergeRollupPublicInputs,
+  BlockMergeRollupInputs,
+  BlockRootOrBlockMergePublicInputs,
+  BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
+  MergeRollupInputs,
+  PrivateBaseRollupInputs,
+  PublicBaseRollupInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+  SingleTxBlockRootRollupInputs,
+  TubeInputs,
+} from '@aztec/stdlib/rollup';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
+import { type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+
+import type { WitnessMap } from '@noir-lang/types';
+
+import { ProverInstrumentation } from '../instrumentation.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+import { PROOF_DELAY_MS, WITGEN_DELAY_MS } from './delay_values.js';
+
+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 class TestCircuitProver implements ServerCircuitProver {
+  private wasmSimulator = new WASMSimulatorWithBlobs();
+  private instrumentation: ProverInstrumentation;
+  private logger = createLogger('bb-prover:test-prover');
+
+  constructor(
+    private simulationProvider?: SimulationProvider,
+    private opts: TestDelay = { proverTestDelayType: 'fixed', proverTestDelayMs: 0 },
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ) {
+    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.
+   */
+  @trackSpan('TestCircuitProver.getBaseParityProof')
+  public getBaseParityProof(
+    inputs: BaseParityInputs,
+  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    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.
+   */
+  @trackSpan('TestCircuitProver.getRootParityProof')
+  public getRootParityProof(
+    inputs: RootParityInputs,
+  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
+    return this.applyDelay(ProvingRequestType.ROOT_PARITY, () =>
+      this.simulate(
+        inputs,
+        'RootParityArtifact',
+        NESTED_RECURSIVE_PROOF_LENGTH,
+        convertRootParityInputsToWitnessMap,
+        convertRootParityOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  public getTubeProof(_tubeInput: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
+    return this.applyDelay(ProvingRequestType.TUBE_PROOF, () =>
+      makeProofAndVerificationKey(makeEmptyRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getPrivateBaseRollupProof')
+  public getPrivateBaseRollupProof(
+    inputs: PrivateBaseRollupInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return this.applyDelay(ProvingRequestType.PRIVATE_BASE_ROLLUP, () =>
+      this.simulate(
+        inputs,
+        'PrivateBaseRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertSimulatedPrivateBaseRollupInputsToWitnessMap,
+        convertSimulatedPrivateBaseRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getPublicBaseRollupProof')
+  public getPublicBaseRollupProof(
+    inputs: PublicBaseRollupInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    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.
+   */
+  @trackSpan('TestCircuitProver.getMergeRollupProof')
+  public getMergeRollupProof(
+    input: MergeRollupInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    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.
+   */
+  @trackSpan('TestCircuitProver.getBlockRootRollupProof')
+  public getBlockRootRollupProof(
+    input: BlockRootRollupInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return this.applyDelay(ProvingRequestType.BLOCK_ROOT_ROLLUP, () =>
+      this.simulate(
+        input,
+        'BlockRootRollupArtifact',
+        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+        convertSimulatedBlockRootRollupInputsToWitnessMap,
+        convertSimulatedBlockRootRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  @trackSpan('TestCircuitProver.getSingleTxBlockRootRollupProof')
+  public async getSingleTxBlockRootRollupProof(
+    input: SingleTxBlockRootRollupInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    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.
+   */
+  @trackSpan('TestCircuitProver.getEmptyBlockRootRollupProof')
+  public getEmptyBlockRootRollupProof(
+    input: EmptyBlockRootRollupInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    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.
+   */
+  @trackSpan('TestCircuitProver.getBlockMergeRollupProof')
+  public getBlockMergeRollupProof(
+    input: BlockMergeRollupInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    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.
+   */
+  @trackSpan('TestCircuitProver.getRootRollupProof')
+  public getRootRollupProof(input: RootRollupInputs): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
+    return this.applyDelay(ProvingRequestType.ROOT_ROLLUP, () =>
+      this.simulate(
+        input,
+        'RootRollupArtifact',
+        NESTED_RECURSIVE_PROOF_LENGTH,
+        convertRootRollupInputsToWitnessMap,
+        convertRootRollupOutputsFromWitnessMap,
+      ),
+    );
+  }
+
+  public getAvmProof(_inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>> {
+    // 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),
+      ),
+    );
+  }
+
+  private async applyDelay<F extends () => any>(type: ProvingRequestType, fn: F): Promise<Awaited<ReturnType<F>>> {
+    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
+  public verifyProof(_1: ServerProtocolArtifact, _2: Proof): Promise<void> {
+    return Promise.reject(new Error('Method not implemented.'));
+  }
+
+  private async simulate<
+    PROOF_LENGTH extends number,
+    CircuitInputType extends { toBuffer: () => Buffer },
+    CircuitOutputType extends { toBuffer: () => Buffer },
+  >(
+    input: CircuitInputType,
+    artifactName: ServerProtocolArtifact,
+    proofLength: PROOF_LENGTH,
+    convertInput: (input: CircuitInputType) => WitnessMap,
+    convertOutput: (outputWitness: WitnessMap) => CircuitOutputType,
+  ) {
+    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]);
+  }
+}

package/src/test/test_verifier.ts

@@ -0,0 +1,8 @@
+import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import type { Tx } from '@aztec/stdlib/tx';
+
+export class TestCircuitVerifier implements ClientProtocolCircuitVerifier {
+  verifyProof(_tx: Tx): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+}

package/src/verification_key/verification_key_data.ts

@@ -0,0 +1,45 @@
+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: string): Promise<VerificationKeyData> {
+  const [rawFields, rawBinary] = await Promise.all([
+    fs.readFile(path.join(vkDirectoryPath, VK_FIELDS_FILENAME), { encoding: 'utf-8' }),
+    fs.readFile(path.join(vkDirectoryPath, VK_FILENAME)),
+  ]);
+  const fieldsJson = JSON.parse(rawFields);
+  const fields = fieldsJson.map(Fr.fromHexString);
+  // The hash is not included in the BB response
+  const vkHash = await hashVK(fields);
+  const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+  return new VerificationKeyData(vkAsFields, rawBinary);
+}
+
+// TODO: This was adapted from the above function. A refactor might be needed.
+export async function extractAvmVkData(vkDirectoryPath: string): Promise<VerificationKeyData> {
+  const [rawFields, rawBinary] = await Promise.all([
+    fs.readFile(path.join(vkDirectoryPath, VK_FIELDS_FILENAME), { encoding: 'utf-8' }),
+    fs.readFile(path.join(vkDirectoryPath, VK_FILENAME)),
+  ]);
+  const fieldsJson = JSON.parse(rawFields);
+  const fields = fieldsJson.map(Fr.fromHexString);
+  // The first item is the hash, this is not part of the actual VK
+  // TODO: is the above actually the case?
+  const vkHash = fields[0];
+  assert(fields.length === AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, 'Invalid AVM verification key length');
+  const vkAsFields = new VerificationKeyAsFields(fields, vkHash);
+  const vk = new VerificationKeyData(vkAsFields, rawBinary);
+  return vk;
+}

package/src/verifier/bb_verifier.ts

@@ -0,0 +1,114 @@
+import { runInDirectory } from '@aztec/foundation/fs';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import type { ClientProtocolArtifact, ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import type { Proof } from '@aztec/stdlib/proofs';
+import type { CircuitVerificationStats } from '@aztec/stdlib/stats';
+import { Tx } from '@aztec/stdlib/tx';
+import type { VerificationKeyData } from '@aztec/stdlib/vks';
+
+import { promises as fs } from 'fs';
+import * as path from 'path';
+
+import { BB_RESULT, PROOF_FILENAME, VK_FILENAME, verifyClientIvcProof, verifyProof } from '../bb/execute.js';
+import type { BBConfig } from '../config.js';
+import { getUltraHonkFlavorForCircuit } from '../honk.js';
+import { writeToOutputDirectory } from '../prover/client_ivc_proof_utils.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
+
+export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
+  private constructor(private config: BBConfig, private logger: Logger) {}
+
+  public static async new(config: BBConfig, logger = createLogger('bb-prover:verifier')) {
+    await fs.mkdir(config.bbWorkingDirectory, { recursive: true });
+    return new BBCircuitVerifier(config, logger);
+  }
+
+  public getVerificationKeyData(circuitType: ServerProtocolArtifact): VerificationKeyData {
+    const vk = ServerCircuitVks[circuitType];
+    if (vk === undefined) {
+      throw new Error('Could not find VK for server artifact ' + circuitType);
+    }
+    return vk;
+  }
+
+  public async verifyProofForCircuit(circuit: ServerProtocolArtifact, proof: Proof) {
+    const operation = async (bbWorkingDirectory: string) => {
+      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',
+      } satisfies CircuitVerificationStats);
+    };
+    await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
+  }
+
+  public async verifyProof(tx: Tx): Promise<boolean> {
+    try {
+      // TODO(#7370) The verification keys should be supplied separately and based on the expectedCircuit
+      // rather than read from the tx object itself. We also need the vks for the translator and ecc, which
+      // are not being saved along the other vks yet. Reuse the 'verifyProofForCircuit' method above once
+      // we have all the verification keys available.
+      const expectedCircuit: ClientProtocolArtifact = tx.data.forPublic
+        ? 'PrivateKernelTailToPublicArtifact'
+        : 'PrivateKernelTailArtifact';
+      const circuit = 'ClientIVC';
+
+      // Block below is almost copy-pasted from verifyProofForCircuit
+      const operation = async (bbWorkingDirectory: string) => {
+        const logFunction = (message: string) => {
+          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',
+        } satisfies CircuitVerificationStats);
+      };
+      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;
+    }
+  }
+}