@aztec/prover-client 0.65.1 → 0.66.0

package/src/prover-agent/memory-proving-queue.ts

@@ -1,8 +1,8 @@
 import {
   type ProofAndVerificationKey,
   type ProvingJob,
+  type ProvingJobInputsMap,
   type ProvingJobSource,
-  type ProvingRequest,
   type ProvingRequestResultFor,
   ProvingRequestType,
   type PublicInputsAndRecursiveProof,
@@ -35,13 +35,13 @@ import { AbortError, TimeoutError } from '@aztec/foundation/error';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
 import { PriorityMemoryQueue } from '@aztec/foundation/queue';
-import { serializeToBuffer } from '@aztec/foundation/serialize';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
+import { InlineProofStore, type ProofStore } from '../proving_broker/proof_store.js';
 import { ProvingQueueMetrics } from './queue_metrics.js';
 
-type ProvingJobWithResolvers<T extends ProvingRequest = ProvingRequest> = ProvingJob<T> &
-  PromiseWithResolvers<ProvingRequestResultFor<T['type']>> & {
+type ProvingJobWithResolvers<T extends ProvingRequestType = ProvingRequestType> = ProvingJob &
+  PromiseWithResolvers<ProvingRequestResultFor<T>> & {
     signal?: AbortSignal;
     epochNumber?: number;
     attempts: number;
@@ -62,9 +62,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     (a, b) => (a.epochNumber ?? 0) - (b.epochNumber ?? 0),
   );
   private jobsInProgress = new Map<string, ProvingJobWithResolvers>();
-
   private runningPromise: RunningPromise;
-
   private metrics: ProvingQueueMetrics;
 
   constructor(
@@ -75,6 +73,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     pollingIntervalMs = 1000,
     private generateId = defaultIdGenerator,
     private timeSource = defaultTimeSource,
+    private proofStore: ProofStore = new InlineProofStore(),
   ) {
     this.metrics = new ProvingQueueMetrics(client, 'MemoryProvingQueue');
     this.runningPromise = new RunningPromise(this.poll, pollingIntervalMs);
@@ -100,7 +99,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     this.log.info('Proving queue stopped');
   }
 
-  public async getProvingJob({ timeoutSec = 1 } = {}): Promise<ProvingJob<ProvingRequest> | undefined> {
+  public async getProvingJob({ timeoutSec = 1 } = {}): Promise<ProvingJob | undefined> {
     if (!this.runningPromise.isRunning()) {
       throw new Error('Proving queue is not running. Start the queue before getting jobs.');
     }
@@ -119,7 +118,8 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
       this.jobsInProgress.set(job.id, job);
       return {
         id: job.id,
-        request: job.request,
+        type: job.type,
+        inputsUri: job.inputsUri,
       };
     } catch (err) {
       if (err instanceof TimeoutError) {
@@ -167,20 +167,18 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     }
 
     // every job should be retried with the exception of the public VM since its in development and can fail
-    if (job.attempts < MAX_RETRIES && job.request.type !== ProvingRequestType.PUBLIC_VM) {
+    if (job.attempts < MAX_RETRIES && job.type !== ProvingRequestType.PUBLIC_VM) {
       job.attempts++;
       this.log.warn(
-        `Job id=${job.id} type=${ProvingRequestType[job.request.type]} failed with error: ${reason}. Retry ${
+        `Job id=${job.id} type=${ProvingRequestType[job.type]} failed with error: ${reason}. Retry ${
           job.attempts
         }/${MAX_RETRIES}`,
       );
       this.queue.put(job);
     } else {
       const logFn =
-        job.request.type === ProvingRequestType.PUBLIC_VM && !process.env.AVM_PROVING_STRICT
-          ? this.log.warn
-          : this.log.error;
-      logFn(`Job id=${job.id} type=${ProvingRequestType[job.request.type]} failed with error: ${reason}`);
+        job.type === ProvingRequestType.PUBLIC_VM && !process.env.AVM_PROVING_STRICT ? this.log.warn : this.log.error;
+      logFn(`Job id=${job.id} type=${ProvingRequestType[job.type]} failed with error: ${reason}`);
       job.reject(new Error(reason));
     }
     return Promise.resolve();
@@ -214,7 +212,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
       }
 
       if (job.heartbeat + this.jobTimeoutMs < now) {
-        this.log.warn(`Job ${job.id} type=${ProvingRequestType[job.request.type]} has timed out`);
+        this.log.warn(`Job ${job.id} type=${ProvingRequestType[job.type]} has timed out`);
 
         this.jobsInProgress.delete(job.id);
         job.heartbeat = 0;
@@ -223,19 +221,23 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     }
   };
 
-  private enqueue<T extends ProvingRequest>(
-    request: T,
+  private async enqueue<T extends ProvingRequestType>(
+    type: T,
+    inputs: ProvingJobInputsMap[T],
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProvingRequestResultFor<T['type']>['result']> {
+  ): Promise<ProvingRequestResultFor<T>['result']> {
     if (!this.runningPromise.isRunning()) {
       return Promise.reject(new Error('Proving queue is not running.'));
     }
 
-    const { promise, resolve, reject } = promiseWithResolvers<ProvingRequestResultFor<T['type']>>();
+    const { promise, resolve, reject } = promiseWithResolvers<ProvingRequestResultFor<T>>();
+    const id = this.generateId();
+    const inputsUri = await this.proofStore.saveProofInput(id, type, inputs);
     const item: ProvingJobWithResolvers<T> = {
-      id: this.generateId(),
-      request,
+      id,
+      type,
+      inputsUri,
       signal,
       promise,
       resolve,
@@ -250,16 +252,13 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     }
 
     this.log.debug(
-      `Adding id=${item.id} type=${ProvingRequestType[request.type]} proving job to queue depth=${this.queue.length()}`,
+      `Adding id=${item.id} type=${ProvingRequestType[type]} proving job to queue depth=${this.queue.length()}`,
     );
-    // TODO (alexg) remove the `any`
-    if (!this.queue.put(item as any)) {
+
+    if (!this.queue.put(item as ProvingJobWithResolvers<any>)) {
       throw new Error();
     }
 
-    const byteSize = serializeToBuffer(item.request.inputs).length;
-    this.metrics.recordNewJob(item.request.type, byteSize);
-
     return promise.then(({ result }) => result);
   }
 
@@ -268,7 +267,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.PRIVATE_KERNEL_EMPTY, inputs }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.PRIVATE_KERNEL_EMPTY, inputs, signal, epochNumber);
   }
 
   getTubeProof(
@@ -276,7 +275,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<ProofAndVerificationKey<typeof RECURSIVE_PROOF_LENGTH>> {
-    return this.enqueue({ type: ProvingRequestType.TUBE_PROOF, inputs }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.TUBE_PROOF, inputs, signal, epochNumber);
   }
 
   /**
@@ -288,7 +287,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
-    return this.enqueue({ type: ProvingRequestType.BASE_PARITY, inputs }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.BASE_PARITY, inputs, signal, epochNumber);
   }
 
   /**
@@ -300,7 +299,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
-    return this.enqueue({ type: ProvingRequestType.ROOT_PARITY, inputs }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.ROOT_PARITY, inputs, signal, epochNumber);
   }
 
   getPrivateBaseRollupProof(
@@ -308,7 +307,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.PRIVATE_BASE_ROLLUP, inputs }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.PRIVATE_BASE_ROLLUP, inputs, signal, epochNumber);
   }
 
   getPublicBaseRollupProof(
@@ -316,7 +315,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs, signal, epochNumber);
   }
 
   /**
@@ -324,11 +323,11 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
    * @param input - Input to the circuit.
    */
   getMergeRollupProof(
-    input: MergeRollupInputs,
+    inputs: MergeRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.MERGE_ROLLUP, inputs: input }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.MERGE_ROLLUP, inputs, signal, epochNumber);
   }
 
   /**
@@ -336,19 +335,19 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
    * @param input - Input to the circuit.
    */
   getBlockRootRollupProof(
-    input: BlockRootRollupInputs,
+    inputs: BlockRootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.BLOCK_ROOT_ROLLUP, inputs: input }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.BLOCK_ROOT_ROLLUP, inputs, signal, epochNumber);
   }
 
   getEmptyBlockRootRollupProof(
-    input: EmptyBlockRootRollupInputs,
+    inputs: EmptyBlockRootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, inputs: input }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, inputs, signal, epochNumber);
   }
 
   /**
@@ -356,11 +355,11 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
    * @param input - Input to the circuit.
    */
   getBlockMergeRollupProof(
-    input: BlockMergeRollupInputs,
+    inputs: BlockMergeRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.BLOCK_MERGE_ROLLUP, inputs: input }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.BLOCK_MERGE_ROLLUP, inputs, signal, epochNumber);
   }
 
   /**
@@ -368,11 +367,11 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
    * @param input - Input to the circuit.
    */
   getRootRollupProof(
-    input: RootRollupInputs,
+    inputs: RootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.ROOT_ROLLUP, inputs: input }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.ROOT_ROLLUP, inputs, signal, epochNumber);
   }
 
   /**
@@ -383,7 +382,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>> {
-    return this.enqueue({ type: ProvingRequestType.PUBLIC_VM, inputs }, signal, epochNumber);
+    return this.enqueue(ProvingRequestType.PUBLIC_VM, inputs, signal, epochNumber);
   }
 
   /**

package/src/prover-agent/prover-agent.ts

@@ -1,9 +1,9 @@
 import {
   type ProverAgentApi,
   type ProvingJob,
+  type ProvingJobInputs,
+  type ProvingJobResultsMap,
   type ProvingJobSource,
-  type ProvingRequest,
-  type ProvingRequestResultFor,
   ProvingRequestType,
   type ServerCircuitProver,
   makeProvingRequestResult,
@@ -12,6 +12,8 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { elapsed } from '@aztec/foundation/timer';
 
+import { InlineProofStore } from '../proving_broker/proof_store.js';
+
 const PRINT_THRESHOLD_NS = 6e10; // 60 seconds
 
 /**
@@ -27,6 +29,7 @@ export class ProverAgent implements ProverAgentApi {
     }
   >();
   private runningPromise?: RunningPromise;
+  private proofInputsDatabase = new InlineProofStore();
 
   constructor(
     /** The prover implementation to defer jobs to */
@@ -101,12 +104,12 @@ export class ProverAgent implements ProverAgentApi {
             const promise = this.work(jobSource, job).finally(() => this.inFlightPromises.delete(job.id));
             this.inFlightPromises.set(job.id, {
               id: job.id,
-              type: job.request.type,
+              type: job.type,
               promise,
             });
           } catch (err) {
             this.log.warn(
-              `Error processing job! type=${ProvingRequestType[job.request.type]}: ${err}. ${(err as Error).stack}`,
+              `Error processing job! type=${ProvingRequestType[job.type]}: ${err}. ${(err as Error).stack}`,
             );
           }
         } catch (err) {
@@ -130,28 +133,24 @@ export class ProverAgent implements ProverAgentApi {
     this.log.info('Agent stopped');
   }
 
-  private async work<TRequest extends ProvingRequest>(
-    jobSource: ProvingJobSource,
-    job: ProvingJob<TRequest>,
-  ): Promise<void> {
+  private async work(jobSource: ProvingJobSource, job: ProvingJob): Promise<void> {
     try {
-      this.log.debug(`Picked up proving job id=${job.id} type=${ProvingRequestType[job.request.type]}`);
-      const type: TRequest['type'] = job.request.type;
-      const [time, result] = await elapsed(this.getProof(job.request));
+      this.log.debug(`Picked up proving job id=${job.id} type=${ProvingRequestType[job.type]}`);
+      const type = job.type;
+      const inputs = await this.proofInputsDatabase.getProofInput(job.inputsUri);
+      const [time, result] = await elapsed(this.getProof(inputs));
       if (this.#isRunning()) {
         this.log.verbose(`Processed proving job id=${job.id} type=${ProvingRequestType[type]} duration=${time}ms`);
         await jobSource.resolveProvingJob(job.id, makeProvingRequestResult(type, result));
       } else {
         this.log.verbose(
-          `Dropping proving job id=${job.id} type=${
-            ProvingRequestType[job.request.type]
-          } duration=${time}ms: agent stopped`,
+          `Dropping proving job id=${job.id} type=${ProvingRequestType[job.type]} duration=${time}ms: agent stopped`,
         );
       }
     } catch (err) {
-      const type = ProvingRequestType[job.request.type];
+      const type = ProvingRequestType[job.type];
       if (this.#isRunning()) {
-        if (job.request.type === ProvingRequestType.PUBLIC_VM && !process.env.AVM_PROVING_STRICT) {
+        if (job.type === ProvingRequestType.PUBLIC_VM && !process.env.AVM_PROVING_STRICT) {
           this.log.warn(`Expected error processing VM proving job id=${job.id} type=${type}: ${err}`);
         } else {
           this.log.error(`Error processing proving job id=${job.id} type=${type}: ${err}`, err);
@@ -164,10 +163,7 @@ export class ProverAgent implements ProverAgentApi {
     }
   }
 
-  private getProof<TRequest extends ProvingRequest>(
-    request: TRequest,
-  ): Promise<ProvingRequestResultFor<TRequest['type']>['result']>;
-  private getProof(request: ProvingRequest): Promise<ProvingRequestResultFor<typeof type>['result']> {
+  private getProof(request: ProvingJobInputs): Promise<ProvingJobResultsMap[ProvingRequestType]> {
     const { type, inputs } = request;
     switch (type) {
       case ProvingRequestType.PUBLIC_VM: {

package/src/prover-client/factory.ts

@@ -0,0 +1,15 @@
+import { type ForkMerkleTreeOperations, 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 { ProverClient } from './prover-client.js';
+
+export function createProverClient(
+  config: ProverClientConfig,
+  worldState: ForkMerkleTreeOperations,
+  broker: ProvingJobBroker,
+  telemetry: TelemetryClient = new NoopTelemetryClient(),
+) {
+  return ProverClient.new(config, worldState, broker, telemetry);
+}

package/src/prover-client/index.ts

@@ -0,0 +1,2 @@
+export * from './factory.js';
+export * from './prover-client.js';

package/src/prover-client/prover-client.ts

@@ -0,0 +1,172 @@
+import { type ACVMConfig, type BBConfig, BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
+import {
+  type ActualProverConfig,
+  type EpochProver,
+  type EpochProverManager,
+  type ForkMerkleTreeOperations,
+  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 { 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';
+
+/** Manages proving of epochs by orchestrating the proving of individual blocks relying on a pool of prover agents. */
+export class ProverClient implements EpochProverManager {
+  private running = false;
+  private agents: ProvingAgent[] = [];
+
+  private cacheDir?: string;
+
+  private constructor(
+    private config: ProverClientConfig,
+    private worldState: ForkMerkleTreeOperations,
+    private telemetry: TelemetryClient,
+    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.cacheDir = this.config.cacheDir ? join(this.config.cacheDir, `tx_prover_${this.config.proverId}`) : undefined;
+  }
+
+  public createEpochProver(cache: ProverCache = new InMemoryProverCache()): EpochProver {
+    return new ProvingOrchestrator(
+      this.worldState,
+      new CachingBrokerFacade(this.orchestratorClient, cache),
+      this.telemetry,
+      this.config.proverId,
+    );
+  }
+
+  public getProverId(): Fr {
+    return this.config.proverId ?? Fr.ZERO;
+  }
+
+  async updateProverConfig(config: Partial<ProverClientConfig>): Promise<void> {
+    const newConfig = { ...this.config, ...config };
+
+    if (
+      newConfig.realProofs !== this.config.realProofs ||
+      newConfig.proverAgentCount !== this.config.proverAgentCount
+    ) {
+      await this.stopAgents();
+      await this.createAndStartAgents();
+    }
+
+    if (!this.config.realProofs && newConfig.realProofs) {
+      // TODO(palla/prover-node): Reset padding tx here once we cache it at this class
+    }
+
+    this.config = newConfig;
+  }
+
+  /**
+   * Starts the prover instance
+   */
+  public async start(): Promise<void> {
+    if (this.running) {
+      return Promise.resolve();
+    }
+
+    this.running = true;
+    await this.createAndStartAgents();
+  }
+
+  /**
+   * Stops the prover instance
+   */
+  public async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    await this.stopAgents();
+  }
+
+  /**
+   * Creates a new prover client and starts it
+   * @param config - The prover configuration.
+   * @param worldState - An instance of the world state
+   * @returns An instance of the prover, constructed and started.
+   */
+  public static async new(
+    config: ProverClientConfig,
+    worldState: ForkMerkleTreeOperations,
+    broker: ProvingJobBroker,
+    telemetry: TelemetryClient,
+  ) {
+    const prover = new ProverClient(config, worldState, telemetry, broker, broker);
+    await prover.start();
+    return prover;
+  }
+
+  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 proofStore = new InlineProofStore();
+    const prover = await buildServerCircuitProver(this.config, this.telemetry);
+    this.agents = times(
+      this.config.proverAgentCount,
+      () =>
+        new ProvingAgent(
+          this.agentClient!,
+          proofStore,
+          prover,
+          this.telemetry,
+          [],
+          this.config.proverAgentPollIntervalMs,
+        ),
+    );
+
+    await Promise.all(this.agents.map(agent => agent.start()));
+  }
+
+  private async stopAgents() {
+    await Promise.all(this.agents.map(agent => agent.stop()));
+  }
+}
+
+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));
+}