@aztec/prover-client 0.65.0 → 0.65.2

package/src/proving_broker/proving_broker_database/persisted.ts

@@ -0,0 +1,45 @@
+import { type ProofUri, ProvingJob, type ProvingJobId, ProvingJobSettledResult } from '@aztec/circuit-types';
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+
+import { type ProvingBrokerDatabase } from '../proving_broker_database.js';
+
+export class KVBrokerDatabase implements ProvingBrokerDatabase {
+  private jobs: AztecMap<ProvingJobId, string>;
+  private jobResults: AztecMap<ProvingJobId, string>;
+
+  constructor(private store: AztecKVStore) {
+    this.jobs = store.openMap('proving_jobs');
+    this.jobResults = store.openMap('proving_job_results');
+  }
+
+  async addProvingJob(job: ProvingJob): Promise<void> {
+    await this.jobs.set(job.id, jsonStringify(job));
+  }
+
+  *allProvingJobs(): Iterable<[ProvingJob, ProvingJobSettledResult | undefined]> {
+    for (const jobStr of this.jobs.values()) {
+      const job = jsonParseWithSchema(jobStr, ProvingJob);
+      const resultStr = this.jobResults.get(job.id);
+      const result = resultStr ? jsonParseWithSchema(resultStr, ProvingJobSettledResult) : undefined;
+      yield [job, result];
+    }
+  }
+
+  deleteProvingJobAndResult(id: ProvingJobId): Promise<void> {
+    return this.store.transaction(() => {
+      void this.jobs.delete(id);
+      void this.jobResults.delete(id);
+    });
+  }
+
+  async setProvingJobError(id: ProvingJobId, reason: string): Promise<void> {
+    const result: ProvingJobSettledResult = { status: 'rejected', reason };
+    await this.jobResults.set(id, jsonStringify(result));
+  }
+
+  async setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void> {
+    const result: ProvingJobSettledResult = { status: 'fulfilled', value };
+    await this.jobResults.set(id, jsonStringify(result));
+  }
+}

package/src/proving_broker/{proving_job_database.ts → proving_broker_database.ts}

@@ -1,30 +1,25 @@
-import {
-  type V2ProofOutput,
-  type V2ProvingJob,
-  type V2ProvingJobId,
-  type V2ProvingJobResult,
-} from '@aztec/circuit-types';
+import { type ProofUri, type ProvingJob, type ProvingJobId, type ProvingJobSettledResult } from '@aztec/circuit-types';
 
 /**
  * A database for storing proof requests and their results
  */
-export interface ProvingJobDatabase {
+export interface ProvingBrokerDatabase {
   /**
    * Saves a proof request so it can be retrieved later
    * @param request - The proof request to save
    */
-  addProvingJob(request: V2ProvingJob): Promise<void>;
+  addProvingJob(request: ProvingJob): Promise<void>;
 
   /**
    * Removes a proof request from the backend
    * @param id - The ID of the proof request to remove
    */
-  deleteProvingJobAndResult(id: V2ProvingJobId): Promise<void>;
+  deleteProvingJobAndResult(id: ProvingJobId): Promise<void>;
 
   /**
    * Returns an iterator over all saved proving jobs
    */
-  allProvingJobs(): Iterable<[V2ProvingJob, V2ProvingJobResult | undefined]>;
+  allProvingJobs(): Iterable<[ProvingJob, ProvingJobSettledResult | undefined]>;
 
   /**
    * Saves the result of a proof request
@@ -32,7 +27,7 @@ export interface ProvingJobDatabase {
    * @param ProvingRequestType - The type of proof that was requested
    * @param value - The result of the proof request
    */
-  setProvingJobResult(id: V2ProvingJobId, value: V2ProofOutput): Promise<void>;
+  setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void>;
 
   /**
    * Saves an error that occurred while processing a proof request
@@ -40,5 +35,5 @@ export interface ProvingJobDatabase {
    * @param ProvingRequestType - The type of proof that was requested
    * @param err - The error that occurred while processing the proof request
    */
-  setProvingJobError(id: V2ProvingJobId, err: Error): Promise<void>;
+  setProvingJobError(id: ProvingJobId, err: string): Promise<void>;
 }

package/src/proving_broker/proving_job_controller.ts

@@ -1,53 +1,68 @@
 import {
+  type ProvingJobId,
+  type ProvingJobInputs,
+  type ProvingJobResultsMap,
   ProvingRequestType,
   type ServerCircuitProver,
-  type V2ProofOutput,
-  type V2ProvingJob,
-  type V2ProvingJobId,
 } from '@aztec/circuit-types';
 
-export enum ProvingJobStatus {
+export enum ProvingJobControllerStatus {
   IDLE = 'idle',
   PROVING = 'proving',
   DONE = 'done',
+  ABORTED = 'aborted',
 }
 
-type ProvingJobCompletionCallback = (
-  error: Error | undefined,
-  result: V2ProofOutput | undefined,
-) => void | Promise<void>;
+interface ProvingJobCompletionCallback<T extends ProvingRequestType = ProvingRequestType> {
+  (
+    jobId: ProvingJobId,
+    type: T,
+    error: Error | undefined,
+    result: ProvingJobResultsMap[T] | undefined,
+  ): void | Promise<void>;
+}
 
 export class ProvingJobController {
-  private status: ProvingJobStatus = ProvingJobStatus.IDLE;
+  private status: ProvingJobControllerStatus = ProvingJobControllerStatus.IDLE;
   private promise?: Promise<void>;
   private abortController = new AbortController();
 
   constructor(
-    private job: V2ProvingJob,
+    private jobId: ProvingJobId,
+    private inputs: ProvingJobInputs,
     private startedAt: number,
     private circuitProver: ServerCircuitProver,
     private onComplete: ProvingJobCompletionCallback,
   ) {}
 
   public start(): void {
-    if (this.status !== ProvingJobStatus.IDLE) {
+    if (this.status !== ProvingJobControllerStatus.IDLE) {
       return;
     }
 
-    this.status = ProvingJobStatus.PROVING;
+    this.status = ProvingJobControllerStatus.PROVING;
     this.promise = this.generateProof()
       .then(
         result => {
-          this.status = ProvingJobStatus.DONE;
-          return this.onComplete(undefined, result);
+          if (this.status === ProvingJobControllerStatus.ABORTED) {
+            return;
+          }
+
+          this.status = ProvingJobControllerStatus.DONE;
+          return this.onComplete(this.jobId, this.inputs.type, undefined, result);
         },
         error => {
-          this.status = ProvingJobStatus.DONE;
+          if (this.status === ProvingJobControllerStatus.ABORTED) {
+            return;
+          }
+
           if (error.name === 'AbortError') {
             // Ignore abort errors
             return;
           }
-          return this.onComplete(error, undefined);
+
+          this.status = ProvingJobControllerStatus.DONE;
+          return this.onComplete(this.jobId, this.inputs.type, error, undefined);
         },
       )
       .catch(_ => {
@@ -55,88 +70,81 @@ export class ProvingJobController {
       });
   }
 
-  public getStatus(): ProvingJobStatus {
+  public getStatus(): ProvingJobControllerStatus {
     return this.status;
   }
 
   public abort(): void {
-    if (this.status !== ProvingJobStatus.PROVING) {
+    if (this.status !== ProvingJobControllerStatus.PROVING) {
       return;
     }
 
+    this.status = ProvingJobControllerStatus.ABORTED;
     this.abortController.abort();
   }
 
-  public getJobId(): V2ProvingJobId {
-    return this.job.id;
+  public getJobId(): ProvingJobId {
+    return this.jobId;
   }
 
   public getStartedAt(): number {
     return this.startedAt;
   }
 
-  private async generateProof(): Promise<V2ProofOutput> {
-    const { type, inputs } = this.job;
+  public getProofTypeName(): string {
+    return ProvingRequestType[this.inputs.type];
+  }
+
+  private async generateProof(): Promise<ProvingJobResultsMap[ProvingRequestType]> {
+    const { type, inputs } = this.inputs;
     const signal = this.abortController.signal;
     switch (type) {
       case ProvingRequestType.PUBLIC_VM: {
-        const value = await this.circuitProver.getAvmProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getAvmProof(inputs, signal);
       }
 
       case ProvingRequestType.PRIVATE_BASE_ROLLUP: {
-        const value = await this.circuitProver.getPrivateBaseRollupProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getPrivateBaseRollupProof(inputs, signal);
       }
 
       case ProvingRequestType.PUBLIC_BASE_ROLLUP: {
-        const value = await this.circuitProver.getPublicBaseRollupProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getPublicBaseRollupProof(inputs, signal);
       }
 
       case ProvingRequestType.MERGE_ROLLUP: {
-        const value = await this.circuitProver.getMergeRollupProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getMergeRollupProof(inputs, signal);
       }
 
       case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP: {
-        const value = await this.circuitProver.getEmptyBlockRootRollupProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getEmptyBlockRootRollupProof(inputs, signal);
       }
 
       case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
-        const value = await this.circuitProver.getBlockRootRollupProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getBlockRootRollupProof(inputs, signal);
       }
 
       case ProvingRequestType.BLOCK_MERGE_ROLLUP: {
-        const value = await this.circuitProver.getBlockMergeRollupProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getBlockMergeRollupProof(inputs, signal);
       }
 
       case ProvingRequestType.ROOT_ROLLUP: {
-        const value = await this.circuitProver.getRootRollupProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getRootRollupProof(inputs, signal);
       }
 
       case ProvingRequestType.BASE_PARITY: {
-        const value = await this.circuitProver.getBaseParityProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getBaseParityProof(inputs, signal);
       }
 
       case ProvingRequestType.ROOT_PARITY: {
-        const value = await this.circuitProver.getRootParityProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getRootParityProof(inputs, signal);
       }
 
       case ProvingRequestType.PRIVATE_KERNEL_EMPTY: {
-        const value = await this.circuitProver.getEmptyPrivateKernelProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getEmptyPrivateKernelProof(inputs, signal);
       }
 
       case ProvingRequestType.TUBE_PROOF: {
-        const value = await this.circuitProver.getTubeProof(inputs, signal);
-        return { type, value };
+        return await this.circuitProver.getTubeProof(inputs, signal);
       }
 
       default: {

package/src/proving_broker/rpc.ts

@@ -0,0 +1,64 @@
+import {
+  type GetProvingJobResponse,
+  ProofUri,
+  ProvingJob,
+  type ProvingJobBroker,
+  type ProvingJobConsumer,
+  ProvingJobId,
+  type ProvingJobProducer,
+  ProvingJobSettledResult,
+  ProvingJobStatus,
+  ProvingRequestType,
+} from '@aztec/circuit-types';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import { type SafeJsonRpcServer, createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { type ApiSchemaFor, optional } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+const ProvingJobFilterSchema = z.object({
+  allowList: z.array(z.nativeEnum(ProvingRequestType)),
+});
+
+const GetProvingJobResponse = z.object({
+  job: ProvingJob,
+  time: z.number(),
+});
+
+export const ProvingJobProducerSchema: ApiSchemaFor<ProvingJobProducer> = {
+  enqueueProvingJob: z.function().args(ProvingJob).returns(z.void()),
+  getProvingJobStatus: z.function().args(ProvingJobId).returns(ProvingJobStatus),
+  removeAndCancelProvingJob: z.function().args(ProvingJobId).returns(z.void()),
+  waitForJobToSettle: z.function().args(ProvingJobId).returns(ProvingJobSettledResult),
+};
+
+export const ProvingJobConsumerSchema: ApiSchemaFor<ProvingJobConsumer> = {
+  getProvingJob: z.function().args(optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional()),
+  reportProvingJobError: z.function().args(ProvingJobId, z.string(), optional(z.boolean())).returns(z.void()),
+  reportProvingJobProgress: z
+    .function()
+    .args(ProvingJobId, z.number(), optional(ProvingJobFilterSchema))
+    .returns(GetProvingJobResponse.optional()),
+  reportProvingJobSuccess: z.function().args(ProvingJobId, ProofUri).returns(z.void()),
+};
+
+export const ProvingJobBrokerSchema: ApiSchemaFor<ProvingJobBroker> = {
+  ...ProvingJobConsumerSchema,
+  ...ProvingJobProducerSchema,
+};
+
+export function createProvingBrokerServer(broker: ProvingJobBroker): SafeJsonRpcServer {
+  return createSafeJsonRpcServer(broker, ProvingJobBrokerSchema);
+}
+
+export function createProvingJobBrokerClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobBroker {
+  return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, false, 'proverBroker', fetch);
+}
+
+export function createProvingJobProducerClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobProducer {
+  return createSafeJsonRpcClient(url, ProvingJobProducerSchema, false, 'provingJobProducer', fetch);
+}
+
+export function createProvingJobConsumerClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobConsumer {
+  return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, false, 'provingJobConsumer', fetch);
+}

package/src/test/mock_prover.ts

@@ -1,5 +1,10 @@
 import {
   type ProofAndVerificationKey,
+  type ProvingJob,
+  type ProvingJobId,
+  type ProvingJobProducer,
+  type ProvingJobSettledResult,
+  type ProvingJobStatus,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
   makeProofAndVerificationKey,
@@ -37,6 +42,52 @@ import {
   makeParityPublicInputs,
   makeRootRollupPublicInputs,
 } from '@aztec/circuits.js/testing';
+import { times } from '@aztec/foundation/collection';
+
+import { InlineProofStore, type ProofStore } from '../proving_broker/proof_store.js';
+import { ProvingAgent } from '../proving_broker/proving_agent.js';
+import { ProvingBroker } from '../proving_broker/proving_broker.js';
+import { InMemoryBrokerDatabase } from '../proving_broker/proving_broker_database/memory.js';
+
+export class TestBroker implements ProvingJobProducer {
+  private broker = new ProvingBroker(new InMemoryBrokerDatabase());
+  private agents: ProvingAgent[];
+
+  constructor(
+    agentCount: number,
+    prover: ServerCircuitProver,
+    private proofStore: ProofStore = new InlineProofStore(),
+  ) {
+    this.agents = times(agentCount, () => new ProvingAgent(this.broker, proofStore, prover));
+  }
+
+  public async start() {
+    await this.broker.start();
+    this.agents.forEach(agent => agent.start());
+  }
+
+  public async stop() {
+    await Promise.all(this.agents.map(agent => agent.stop()));
+    await this.broker.stop();
+  }
+
+  public getProofStore(): ProofStore {
+    return this.proofStore;
+  }
+
+  enqueueProvingJob(job: ProvingJob): Promise<void> {
+    return this.broker.enqueueProvingJob(job);
+  }
+  getProvingJobStatus(id: ProvingJobId): Promise<ProvingJobStatus> {
+    return this.broker.getProvingJobStatus(id);
+  }
+  removeAndCancelProvingJob(id: ProvingJobId): Promise<void> {
+    return this.broker.removeAndCancelProvingJob(id);
+  }
+  waitForJobToSettle(id: ProvingJobId): Promise<ProvingJobSettledResult> {
+    return this.broker.waitForJobToSettle(id);
+  }
+}
 
 export class MockProver implements ServerCircuitProver {
   constructor() {}

package/src/tx-prover/factory.ts

@@ -1,9 +1,14 @@
+import { type ProvingJobBroker } from '@aztec/circuit-types';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
 import { type ProverClientConfig } from '../config.js';
 import { TxProver } from './tx-prover.js';
 
-export function createProverClient(config: ProverClientConfig, telemetry: TelemetryClient = new NoopTelemetryClient()) {
-  return TxProver.new(config, telemetry);
+export function createProverClient(
+  config: ProverClientConfig,
+  broker: ProvingJobBroker,
+  telemetry: TelemetryClient = new NoopTelemetryClient(),
+) {
+  return TxProver.new(config, broker, telemetry);
 }

package/src/tx-prover/tx-prover.ts

@@ -1,40 +1,59 @@
-import { BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
+import { type ACVMConfig, type BBConfig, BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
 import {
+  type ActualProverConfig,
   type EpochProver,
   type EpochProverManager,
   type MerkleTreeWriteOperations,
-  type ProvingJobSource,
+  type ProverCache,
+  type ProvingJobBroker,
+  type ProvingJobConsumer,
+  type ProvingJobProducer,
   type ServerCircuitProver,
 } from '@aztec/circuit-types/interfaces';
 import { Fr } from '@aztec/circuits.js';
+import { times } from '@aztec/foundation/collection';
+import { createDebugLogger } from '@aztec/foundation/log';
 import { NativeACVMSimulator } from '@aztec/simulator';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
+import { join } from 'path';
+
 import { type ProverClientConfig } from '../config.js';
 import { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
-import { MemoryProvingQueue } from '../prover-agent/memory-proving-queue.js';
-import { ProverAgent } from '../prover-agent/prover-agent.js';
+import { CachingBrokerFacade } from '../proving_broker/caching_broker_facade.js';
+import { InlineProofStore } from '../proving_broker/proof_store.js';
+import { InMemoryProverCache } from '../proving_broker/prover_cache/memory.js';
+import { ProvingAgent } from '../proving_broker/proving_agent.js';
 
 /**
  * A prover factory.
  * TODO(palla/prover-node): Rename this class
  */
 export class TxProver implements EpochProverManager {
-  private queue: MemoryProvingQueue;
   private running = false;
+  private agents: ProvingAgent[] = [];
+
+  private cacheDir?: string;
 
   private constructor(
     private config: ProverClientConfig,
     private telemetry: TelemetryClient,
-    private agent?: ProverAgent,
+    private orchestratorClient: ProvingJobProducer,
+    private agentClient?: ProvingJobConsumer,
+    private log = createDebugLogger('aztec:prover-client:tx-prover'),
   ) {
     // TODO(palla/prover-node): Cache the paddingTx here, and not in each proving orchestrator,
     // so it can be reused across multiple ones and not recomputed every time.
-    this.queue = new MemoryProvingQueue(telemetry, config.proverJobTimeoutMs, config.proverJobPollIntervalMs);
+    this.cacheDir = this.config.cacheDir ? join(this.config.cacheDir, `tx_prover_${this.config.proverId}`) : undefined;
   }
 
-  public createEpochProver(db: MerkleTreeWriteOperations): EpochProver {
-    return new ProvingOrchestrator(db, this.queue, this.telemetry, this.config.proverId);
+  public createEpochProver(db: MerkleTreeWriteOperations, cache: ProverCache = new InMemoryProverCache()): EpochProver {
+    return new ProvingOrchestrator(
+      db,
+      new CachingBrokerFacade(this.orchestratorClient, cache),
+      this.telemetry,
+      this.config.proverId,
+    );
   }
 
   public getProverId(): Fr {
@@ -44,13 +63,12 @@ export class TxProver implements EpochProverManager {
   async updateProverConfig(config: Partial<ProverClientConfig>): Promise<void> {
     const newConfig = { ...this.config, ...config };
 
-    if (newConfig.realProofs !== this.config.realProofs && this.agent) {
-      const circuitProver = await TxProver.buildCircuitProver(newConfig, this.telemetry);
-      this.agent.setCircuitProver(circuitProver);
-    }
-
-    if (this.config.proverAgentConcurrency !== newConfig.proverAgentConcurrency) {
-      await this.agent?.setMaxConcurrency(newConfig.proverAgentConcurrency);
+    if (
+      newConfig.realProofs !== this.config.realProofs ||
+      newConfig.proverAgentCount !== this.config.proverAgentCount
+    ) {
+      await this.stopAgents();
+      await this.createAndStartAgents();
     }
 
     if (!this.config.realProofs && newConfig.realProofs) {
@@ -63,15 +81,13 @@ export class TxProver implements EpochProverManager {
   /**
    * Starts the prover instance
    */
-  public start() {
+  public async start(): Promise<void> {
     if (this.running) {
       return Promise.resolve();
     }
 
     this.running = true;
-    this.queue.start();
-    this.agent?.start(this.queue);
-    return Promise.resolve();
+    await this.createAndStartAgents();
   }
 
   /**
@@ -82,10 +98,7 @@ export class TxProver implements EpochProverManager {
       return;
     }
     this.running = false;
-
-    // TODO(palla/prover-node): Keep a reference to all proving orchestrators that are alive and stop them?
-    await this.agent?.stop();
-    await this.queue.stop();
+    await this.stopAgents();
   }
 
   /**
@@ -95,36 +108,55 @@ export class TxProver implements EpochProverManager {
    * @param worldStateSynchronizer - An instance of the world state
    * @returns An instance of the prover, constructed and started.
    */
-  public static async new(config: ProverClientConfig, telemetry: TelemetryClient) {
-    const agent = config.proverAgentEnabled
-      ? new ProverAgent(
-          await TxProver.buildCircuitProver(config, telemetry),
-          config.proverAgentConcurrency,
-          config.proverAgentPollInterval,
-        )
-      : undefined;
-
-    const prover = new TxProver(config, telemetry, agent);
+  public static async new(config: ProverClientConfig, broker: ProvingJobBroker, telemetry: TelemetryClient) {
+    const prover = new TxProver(config, telemetry, broker, broker);
     await prover.start();
     return prover;
   }
 
-  private static async buildCircuitProver(
-    config: ProverClientConfig,
-    telemetry: TelemetryClient,
-  ): Promise<ServerCircuitProver> {
-    if (config.realProofs) {
-      return await BBNativeRollupProver.new(config, telemetry);
+  public getProvingJobSource(): ProvingJobConsumer {
+    if (!this.agentClient) {
+      throw new Error('Agent client not provided');
+    }
+
+    return this.agentClient;
+  }
+
+  private async createAndStartAgents(): Promise<void> {
+    if (this.agents.length > 0) {
+      throw new Error('Agents already started');
+    }
+
+    if (!this.agentClient) {
+      throw new Error('Agent client not provided');
     }
 
-    const simulationProvider = config.acvmBinaryPath
-      ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath)
-      : undefined;
+    const proofStore = new InlineProofStore();
+    const prover = await buildServerCircuitProver(this.config, this.telemetry);
+    this.agents = times(
+      this.config.proverAgentCount,
+      () => new ProvingAgent(this.agentClient!, proofStore, prover, [], this.config.proverAgentPollIntervalMs),
+    );
+
+    await Promise.all(this.agents.map(agent => agent.start()));
+  }
 
-    return new TestCircuitProver(telemetry, simulationProvider, config);
+  private async stopAgents() {
+    await Promise.all(this.agents.map(agent => agent.stop()));
   }
+}
 
-  public getProvingJobSource(): ProvingJobSource {
-    return this.queue;
+export function buildServerCircuitProver(
+  config: ActualProverConfig & ACVMConfig & BBConfig,
+  telemetry: TelemetryClient,
+): Promise<ServerCircuitProver> {
+  if (config.realProofs) {
+    return BBNativeRollupProver.new(config, telemetry);
   }
+
+  const simulationProvider = config.acvmBinaryPath
+    ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath)
+    : undefined;
+
+  return Promise.resolve(new TestCircuitProver(telemetry, simulationProvider, config));
 }