@aztec-labs/prover-client 6.0.0-nightly.20260829

package/src/orchestrator/top-tree-proving-state.ts

@@ -0,0 +1,219 @@
+import type { BatchedBlob, BatchedBlobAccumulator, FinalBlobBatchingChallenges } from '@aztec-labs/blob-lib';
+import type { NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec-labs/constants';
+import { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec-labs/foundation/trees';
+import type { PublicInputsAndRecursiveProof } from '@aztec-labs/stdlib/interfaces/server';
+import type { Proof } from '@aztec-labs/stdlib/proofs';
+import {
+  CheckpointMergeRollupPrivateInputs,
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRollupPublicInputs,
+  RootRollupPrivateInputs,
+  type RootRollupPublicInputs,
+} from '@aztec-labs/stdlib/rollup';
+
+import { toProofData } from './block-building-helpers.js';
+import type { ProofState } from './block-proving-state.js';
+
+enum TOP_TREE_LIFECYCLE {
+  CREATED,
+  RESOLVED,
+  REJECTED,
+}
+
+/**
+ * Lean top-tree-only state. Owns the merge tree of checkpoint root proofs, the
+ * single-checkpoint padding proof slot, the final root rollup proof, and the blob
+ * accumulator endpoints needed to finalise the epoch's batched blob proof.
+ *
+ * Constructed with `totalNumCheckpoints` and `finalBlobBatchingChallenges` upfront —
+ * by the time the top tree starts, all checkpoints are known and the challenges are
+ * derivable from their blob fields.
+ */
+export class TopTreeProvingState {
+  private checkpointProofs: UnbalancedTreeStore<
+    ProofState<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  >;
+  private checkpointPaddingProof:
+    | ProofState<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    | undefined;
+  private rootRollupProof: ProofState<RootRollupPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined;
+  private endBlobAccumulator: BatchedBlobAccumulator | undefined;
+  private finalBatchedBlob: BatchedBlob | undefined;
+  private lifecycle = TOP_TREE_LIFECYCLE.CREATED;
+  constructor(
+    public readonly epochNumber: EpochNumber,
+    public readonly totalNumCheckpoints: number,
+    public readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
+    public readonly startBlobAccumulator: BatchedBlobAccumulator,
+    private readonly completionCallback: () => void,
+    private readonly rejectionCallback: (reason: string) => void,
+  ) {
+    if (totalNumCheckpoints < 1) {
+      throw new Error(`TopTreeProvingState requires at least one checkpoint; got ${totalNumCheckpoints}.`);
+    }
+    this.checkpointProofs = new UnbalancedTreeStore(totalNumCheckpoints);
+  }
+
+  // --- checkpoint root rollup ---
+
+  public setCheckpointRootRollupProof(
+    checkpointIndex: number,
+    provingOutput: PublicInputsAndRecursiveProof<
+      CheckpointRollupPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >,
+  ): TreeNodeLocation {
+    return this.checkpointProofs.setLeaf(checkpointIndex, { provingOutput });
+  }
+
+  // --- checkpoint merge rollup ---
+
+  public tryStartProvingCheckpointMerge(location: TreeNodeLocation) {
+    if (this.checkpointProofs.getNode(location)?.isProving) {
+      return false;
+    }
+    this.checkpointProofs.setNode(location, { isProving: true });
+    return true;
+  }
+
+  public setCheckpointMergeRollupProof(
+    location: TreeNodeLocation,
+    provingOutput: PublicInputsAndRecursiveProof<
+      CheckpointRollupPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >,
+  ) {
+    this.checkpointProofs.setNode(location, { provingOutput });
+  }
+
+  public isReadyForCheckpointMerge(location: TreeNodeLocation) {
+    return !!this.checkpointProofs.getSibling(location)?.provingOutput;
+  }
+
+  public getParentLocation(location: TreeNodeLocation) {
+    return this.checkpointProofs.getParentLocation(location);
+  }
+
+  public getCheckpointMergeRollupInputs(mergeLocation: TreeNodeLocation) {
+    const [left, right] = this.checkpointProofs.getChildren(mergeLocation).map(c => c?.provingOutput);
+    if (!left || !right) {
+      throw new Error('At least one child is not ready for the checkpoint merge rollup.');
+    }
+    return new CheckpointMergeRollupPrivateInputs([toProofData(left), toProofData(right)]);
+  }
+
+  // --- padding (single-checkpoint case) ---
+
+  public tryStartProvingPaddingCheckpoint() {
+    if (this.checkpointPaddingProof?.isProving) {
+      return false;
+    }
+    this.checkpointPaddingProof = { isProving: true };
+    return true;
+  }
+
+  public setCheckpointPaddingProof(
+    provingOutput: PublicInputsAndRecursiveProof<
+      CheckpointRollupPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >,
+  ) {
+    this.checkpointPaddingProof = { provingOutput };
+  }
+
+  public getPaddingCheckpointInputs() {
+    return new CheckpointPaddingRollupPrivateInputs();
+  }
+
+  // --- root rollup ---
+
+  public tryStartProvingRootRollup() {
+    if (this.rootRollupProof?.isProving) {
+      return false;
+    }
+    this.rootRollupProof = { isProving: true };
+    return true;
+  }
+
+  public setRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<RootRollupPublicInputs>) {
+    this.rootRollupProof = { provingOutput };
+  }
+
+  public isReadyForRootRollup() {
+    const childProofs = this.#getChildProofsForRoot();
+    return childProofs.every(p => !!p);
+  }
+
+  public getRootRollupInputs() {
+    const [left, right] = this.#getChildProofsForRoot();
+    if (!left || !right) {
+      throw new Error('At least one child is not ready for the root rollup.');
+    }
+    return RootRollupPrivateInputs.from({
+      previousRollups: [toProofData(left), toProofData(right)],
+    });
+  }
+
+  // --- blob accumulator finalisation ---
+
+  /**
+   * Sets the end-of-epoch blob accumulator, computed by the top-tree orchestrator
+   * from the surviving checkpoints' blob fields. Required before `finalizeBatchedBlob`.
+   */
+  public setEndBlobAccumulator(accumulator: BatchedBlobAccumulator) {
+    this.endBlobAccumulator = accumulator;
+  }
+
+  public async finalizeBatchedBlob() {
+    if (!this.endBlobAccumulator) {
+      throw new Error('End blob accumulator not set; call setEndBlobAccumulator before finalize.');
+    }
+    this.finalBatchedBlob = await this.endBlobAccumulator.finalize(true /* verifyProof */);
+  }
+
+  public getEpochProofResult(): { proof: Proof; publicInputs: RootRollupPublicInputs; batchedBlobInputs: BatchedBlob } {
+    const provingOutput = this.rootRollupProof?.provingOutput;
+    if (!provingOutput || !this.finalBatchedBlob) {
+      throw new Error('Top-tree proof not ready; root rollup or batched blob missing.');
+    }
+    return {
+      proof: provingOutput.proof.binaryProof,
+      publicInputs: provingOutput.inputs,
+      batchedBlobInputs: this.finalBatchedBlob,
+    };
+  }
+
+  // --- lifecycle ---
+
+  public verifyState() {
+    return this.lifecycle === TOP_TREE_LIFECYCLE.CREATED;
+  }
+
+  public resolve() {
+    if (!this.verifyState()) {
+      return;
+    }
+    this.lifecycle = TOP_TREE_LIFECYCLE.RESOLVED;
+    this.completionCallback();
+  }
+
+  public reject(reason: string) {
+    if (!this.verifyState()) {
+      return;
+    }
+    this.lifecycle = TOP_TREE_LIFECYCLE.REJECTED;
+    this.rejectionCallback(reason);
+  }
+
+  public cancel() {
+    this.reject('Top-tree proving cancelled');
+  }
+
+  #getChildProofsForRoot() {
+    const rootLocation = { level: 0, index: 0 };
+    return this.totalNumCheckpoints === 1
+      ? [this.checkpointProofs.getNode(rootLocation)?.provingOutput, this.checkpointPaddingProof?.provingOutput]
+      : this.checkpointProofs.getChildren(rootLocation).map(c => c?.provingOutput);
+  }
+}

package/src/orchestrator/tx-proving-state.ts

@@ -0,0 +1,121 @@
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec-labs/constants';
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { getVkData } from '@aztec-labs/noir-protocol-circuits-types/server/vks';
+import type { AvmCircuitInputs } from '@aztec-labs/stdlib/avm';
+import type { PublicInputsAndRecursiveProof } from '@aztec-labs/stdlib/interfaces/server';
+import { ProofData, ProofDataForFixedVk, RecursiveProof } from '@aztec-labs/stdlib/proofs';
+import {
+  type BaseRollupHints,
+  PrivateBaseRollupHints,
+  PrivateTxBaseRollupPrivateInputs,
+  PublicBaseRollupHints,
+  PublicChonkVerifierPublicInputs,
+  PublicTxBaseRollupPrivateInputs,
+} from '@aztec-labs/stdlib/rollup';
+import type { CircuitName } from '@aztec-labs/stdlib/stats';
+import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec-labs/stdlib/trees';
+import type { ProcessedTx } from '@aztec-labs/stdlib/tx';
+
+import {
+  getChonkProofFromTx,
+  getPublicChonkVerifierPrivateInputsFromTx,
+  toProofData,
+} from './block-building-helpers.js';
+
+/**
+ * Helper class to manage the proving cycle of a transaction
+ * This includes the public VMs and the public kernels
+ * Also stores the inputs to the base rollup for this transaction and the tree snapshots
+ */
+export class TxProvingState {
+  private publicChonkVerifier?: PublicInputsAndRecursiveProof<
+    PublicChonkVerifierPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  private avmProof?: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>;
+
+  constructor(
+    public readonly processedTx: ProcessedTx,
+    private readonly baseRollupHints: BaseRollupHints,
+    public readonly treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
+    private readonly proverId: Fr,
+  ) {}
+
+  get requireAvmProof() {
+    return !!this.processedTx.avmProvingRequest;
+  }
+
+  public ready() {
+    return !this.requireAvmProof || (!!this.avmProof && !!this.publicChonkVerifier);
+  }
+
+  public getAvmInputs(): AvmCircuitInputs {
+    return this.processedTx.avmProvingRequest!.inputs;
+  }
+
+  public getPublicChonkVerifierPrivateInputs() {
+    return getPublicChonkVerifierPrivateInputsFromTx(this.processedTx, this.proverId);
+  }
+
+  public getBaseRollupTypeAndInputs() {
+    if (this.requireAvmProof) {
+      return {
+        rollupType: 'rollup-tx-base-public' satisfies CircuitName,
+        inputs: this.#getPublicBaseInputs(),
+      };
+    } else {
+      return {
+        rollupType: 'rollup-tx-base-private' satisfies CircuitName,
+        inputs: this.#getPrivateBaseInputs(),
+      };
+    }
+  }
+
+  public setPublicChonkVerifierProof(
+    publicChonkVerifierProofAndVk: PublicInputsAndRecursiveProof<
+      PublicChonkVerifierPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >,
+  ) {
+    this.publicChonkVerifier = publicChonkVerifierProofAndVk;
+  }
+
+  public setAvmProof(avmProof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>) {
+    this.avmProof = avmProof;
+  }
+
+  #getPrivateBaseInputs() {
+    if (!(this.baseRollupHints instanceof PrivateBaseRollupHints)) {
+      throw new Error('Mismatched base rollup hints, expected private base rollup hints');
+    }
+
+    const privateTailProofData = new ProofData(
+      this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(),
+      getChonkProofFromTx(this.processedTx),
+      getVkData('HidingKernelToRollup'),
+    );
+
+    return new PrivateTxBaseRollupPrivateInputs(privateTailProofData, this.baseRollupHints);
+  }
+
+  #getPublicBaseInputs() {
+    if (!this.processedTx.avmProvingRequest) {
+      throw new Error('Should create private base rollup for a tx not requiring avm proof.');
+    }
+    if (!this.publicChonkVerifier) {
+      throw new Error('Tx not ready for proving base rollup: public chonk verifier proof undefined');
+    }
+    if (!this.avmProof) {
+      throw new Error('Tx not ready for proving base rollup: avm proof undefined');
+    }
+    if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
+      throw new Error('Mismatched base rollup hints, expected public base rollup hints');
+    }
+
+    const publicChonkVerifierProofData = toProofData(this.publicChonkVerifier);
+
+    const avmProofData = new ProofDataForFixedVk(this.processedTx.avmProvingRequest.inputs.publicInputs, this.avmProof);
+
+    return new PublicTxBaseRollupPrivateInputs(publicChonkVerifierProofData, avmProofData, this.baseRollupHints);
+  }
+}

package/src/prover-client/factory.ts

@@ -0,0 +1,18 @@
+import type {
+  ForkMerkleTreeOperations,
+  ProvingJobBroker,
+  ReadonlyWorldStateAccess,
+} from '@aztec-labs/stdlib/interfaces/server';
+import { type TelemetryClient, getTelemetryClient } from '@aztec-labs/telemetry-client';
+
+import type { ProverClientConfig } from '../config.js';
+import { ProverClient } from './prover-client.js';
+
+export function createProverClient(
+  config: ProverClientConfig,
+  worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
+  broker: ProvingJobBroker,
+  telemetry: TelemetryClient = getTelemetryClient(),
+) {
+  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,286 @@
+import { type ACVMConfig, type BBConfig, BBNativeRollupProver, TestCircuitProver } from '@aztec-labs/bb-prover';
+import type { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import { times } from '@aztec-labs/foundation/collection';
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+import { NativeACVMSimulator } from '@aztec-labs/simulator/server';
+import {
+  type ActualProverConfig,
+  type EpochProverManager,
+  type ForkMerkleTreeOperations,
+  type ProvingJobBroker,
+  type ProvingJobConsumer,
+  type ProvingJobProducer,
+  type ReadonlyWorldStateAccess,
+  type ServerCircuitProver,
+  tryStop,
+} from '@aztec-labs/stdlib/interfaces/server';
+import type { CheckpointConstantData } from '@aztec-labs/stdlib/rollup';
+import type { BlockHeader } from '@aztec-labs/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec-labs/telemetry-client';
+
+import type { ProverClientConfig } from '../config.js';
+import { CheckpointSubTreeOrchestrator } from '../orchestrator/checkpoint-sub-tree-orchestrator.js';
+import type { ChonkCache } from '../orchestrator/chonk-cache.js';
+import { TopTreeOrchestrator } from '../orchestrator/top-tree-orchestrator.js';
+import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
+import { InlineProofStore, type ProofStore, createProofStore } from '../proving_broker/proof_store/index.js';
+import { ProvingAgent } from '../proving_broker/proving_agent.js';
+
+/**
+ * The factory surface that `EpochProvingJob` (in `prover-node`) depends on. Implemented
+ * by `ProverClient`. Defined here rather than in stdlib because the return types
+ * (`CheckpointSubTreeOrchestrator`, `TopTreeOrchestrator`) are concrete classes from
+ * this package.
+ *
+ * A single `BrokerCircuitProverFacade` is owned by `ProverClient` and shared across
+ * every orchestrator (every sub-tree and every top-tree across every concurrent epoch
+ * job). The broker delivers each completed-job notification exactly once (drained on
+ * the first `getCompletedJobs` poll), so multiple facades polling the same broker
+ * race and lose notifications
+ *
+ * The facade's job map cleans up entries on resolve/reject, and the prover-node
+ * keeps `ProverClient` alive for its whole lifetime
+ */
+export interface EpochProverFactory {
+  getProverId(): EthAddress;
+  /**
+   * Constructs and starts a `CheckpointSubTreeOrchestrator` for a single checkpoint
+   * against the supplied shared `chonkCache`. The cache is owned by the prover-node
+   * and survives across epochs / sessions.
+   */
+  createCheckpointSubTreeOrchestrator(
+    chonkCache: ChonkCache,
+    epochNumber: EpochNumber,
+    checkpointConstants: CheckpointConstantData,
+    l1ToL2Messages: Fr[],
+    startInboxRollingHash: Fr,
+    totalNumBlocks: number,
+    headerOfLastBlockInPreviousCheckpoint: BlockHeader,
+  ): Promise<CheckpointSubTreeOrchestrator>;
+  createTopTreeOrchestrator(): TopTreeOrchestrator;
+}
+
+/** Manages proving of epochs by orchestrating the proving of individual blocks relying on a pool of prover agents. */
+export class ProverClient implements EpochProverManager, EpochProverFactory {
+  private running = false;
+  private agents: ProvingAgent[] = [];
+  /**
+   * The single broker facade shared by every orchestrator created from this client.
+   * Constructed lazily on `start()` and torn down on `stop()` — see the comment on
+   * `EpochProverFactory` for why a single shared facade is required.
+   */
+  private facade: BrokerCircuitProverFacade | undefined;
+  /**
+   * Single deferred-proving-job queue shared across every orchestrator (sub-trees and
+   * top-trees, across every concurrent epoch session). Throttles the total rate of job
+   * submission to the broker once, rather than once per orchestrator. Started lazily
+   * alongside the facade and cancelled on `stop()`.
+   */
+  private deferredJobQueue: SerialQueue | undefined;
+
+  private constructor(
+    private config: ProverClientConfig,
+    private worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
+    private orchestratorClient: ProvingJobProducer,
+    private proofStore: ProofStore,
+    private failedProofStore: ProofStore | undefined,
+    private agentClient?: ProvingJobConsumer,
+    private telemetry: TelemetryClient = getTelemetryClient(),
+    private log: Logger = createLogger('prover-client:tx-prover'),
+  ) {}
+
+  /**
+   * Lazy-init the shared facade. The broker delivers each completed-job notification
+   * exactly once (drained on the first `getCompletedJobs` poll), so we cannot start
+   * a shared facade alongside the per-call facades that `createEpochProver` builds —
+   * they would race for notifications and one side would silently drop them. Starting
+   * the shared facade only on first use of one of the new factory methods keeps the
+   * legacy `createEpochProver` path race-free.
+   */
+  private getFacade(): BrokerCircuitProverFacade {
+    if (!this.running) {
+      throw new Error('ProverClient is not running; call start() before constructing orchestrators.');
+    }
+    if (!this.facade) {
+      this.facade = new BrokerCircuitProverFacade(
+        this.orchestratorClient,
+        this.proofStore,
+        this.failedProofStore,
+        undefined,
+        this.log.getBindings(),
+      );
+      this.facade.start();
+    }
+    return this.facade;
+  }
+
+  /** Lazy-init the shared deferred-job queue, started with the configured enqueue concurrency. */
+  private getDeferredJobQueue(): SerialQueue {
+    if (!this.running) {
+      throw new Error('ProverClient is not running; call start() before constructing orchestrators.');
+    }
+    if (!this.deferredJobQueue) {
+      this.deferredJobQueue = new SerialQueue();
+      this.deferredJobQueue.start(this.config.enqueueConcurrency);
+    }
+    return this.deferredJobQueue;
+  }
+
+  public createCheckpointSubTreeOrchestrator(
+    chonkCache: ChonkCache,
+    epochNumber: EpochNumber,
+    checkpointConstants: CheckpointConstantData,
+    l1ToL2Messages: Fr[],
+    startInboxRollingHash: Fr,
+    totalNumBlocks: number,
+    headerOfLastBlockInPreviousCheckpoint: BlockHeader,
+  ): Promise<CheckpointSubTreeOrchestrator> {
+    return CheckpointSubTreeOrchestrator.start(
+      this.worldState,
+      this.getFacade(),
+      this.config.proverId,
+      chonkCache,
+      epochNumber,
+      this.config.cancelJobsOnStop,
+      this.getDeferredJobQueue(),
+      checkpointConstants,
+      l1ToL2Messages,
+      startInboxRollingHash,
+      totalNumBlocks,
+      headerOfLastBlockInPreviousCheckpoint,
+      this.telemetry,
+      this.log.getBindings(),
+    );
+  }
+
+  public createTopTreeOrchestrator(): TopTreeOrchestrator {
+    return new TopTreeOrchestrator(
+      this.getFacade(),
+      this.config.proverId,
+      this.getDeferredJobQueue(),
+      this.telemetry,
+      this.log.getBindings(),
+    );
+  }
+
+  public getProverId(): EthAddress {
+    return this.config.proverId;
+  }
+
+  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();
+    }
+
+    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();
+    if (this.deferredJobQueue) {
+      await this.deferredJobQueue.cancel();
+      this.deferredJobQueue = undefined;
+    }
+    if (this.facade) {
+      await tryStop(this.facade, this.log);
+      this.facade = undefined;
+    }
+    await tryStop(this.orchestratorClient);
+  }
+
+  /**
+   * 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 & ReadonlyWorldStateAccess,
+    broker: ProvingJobBroker,
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ) {
+    const proofStore = await createProofStore(config.proofStore);
+    const failedProofStore = config.failedProofStore ? await createProofStore(config.failedProofStore) : undefined;
+    const prover = new ProverClient(config, worldState, broker, proofStore, failedProofStore, broker, telemetry);
+    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);
+    const bindings = this.log.getBindings();
+    this.agents = times(
+      this.config.proverAgentCount,
+      () =>
+        new ProvingAgent(this.agentClient!, proofStore, prover, [], this.config.proverAgentPollIntervalMs, bindings),
+    );
+
+    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: Omit<ActualProverConfig, 'enqueueConcurrency'> & ACVMConfig & BBConfig,
+  telemetry: TelemetryClient,
+): Promise<ServerCircuitProver> {
+  if (config.realProofs) {
+    return BBNativeRollupProver.new(config, telemetry);
+  }
+
+  const logger = createLogger('prover-client:acvm-native');
+  const simulator = config.acvmBinaryPath
+    ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath, undefined, logger)
+    : undefined;
+
+  return Promise.resolve(new TestCircuitProver(simulator, config, telemetry));
+}