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

package/src/proving_broker/config.ts

@@ -0,0 +1,178 @@
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec-labs/ethereum/l1-reader';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getDefaultConfig,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec-labs/foundation/config';
+import { pickConfigMappings } from '@aztec-labs/foundation/config';
+import { type ChainConfig, chainConfigMappings } from '@aztec-labs/stdlib/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec-labs/stdlib/kv-store';
+import { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+import { z } from 'zod';
+
+export const ProverBrokerConfig = z.object({
+  /** If starting a prover broker locally, the max number of retries per proving job */
+  proverBrokerJobMaxRetries: z.number().int().nonnegative(),
+  /** If starting a prover broker locally, the time after which a job times out and gets assigned to a different agent */
+  proverBrokerJobTimeoutMs: z.number().int().nonnegative(),
+  /** If starting a prover broker locally, the interval the broker checks for timed out jobs */
+  proverBrokerPollIntervalMs: z.number().int().nonnegative(),
+  /** If starting a prover broker locally, the directory to store broker data */
+  dataDirectory: z.string().optional(),
+  /** The size of the data store map */
+  dataStoreMapSizeKb: z.number().int().nonnegative(),
+  /** The size of the prover broker's database. Will override the dataStoreMapSizeKb if set. */
+  proverBrokerStoreMapSizeKb: z.number().int().nonnegative().optional(),
+  /** The prover broker may batch jobs together before writing to the database */
+  proverBrokerBatchSize: z.number().int().nonnegative(),
+  /** How often the job batches get flushed */
+  proverBrokerBatchIntervalMs: z.number().int().nonnegative(),
+  /** The maximum number of epochs to keep results for */
+  proverBrokerMaxEpochsToKeepResultsFor: z.number().int().nonnegative(),
+  /** Enable debug replay mode for replaying proving jobs from stored inputs */
+  proverBrokerDebugReplayEnabled: z.boolean(),
+});
+
+export type ProverBrokerConfig = z.infer<typeof ProverBrokerConfig> &
+  Pick<DataStoreConfig, 'dataStoreMapSizeKb' | 'dataDirectory'> &
+  L1ReaderConfig &
+  Pick<ChainConfig, 'rollupVersion'>;
+
+export const proverBrokerConfigMappings: ConfigMappingsType<ProverBrokerConfig> = {
+  proverBrokerJobTimeoutMs: {
+    env: 'PROVER_BROKER_JOB_TIMEOUT_MS',
+    description: 'Jobs are retried if not kept alive for this long',
+    ...numberConfigHelper(30_000),
+  },
+  proverBrokerPollIntervalMs: {
+    env: 'PROVER_BROKER_POLL_INTERVAL_MS',
+    description: 'The interval to check job health status',
+    ...numberConfigHelper(1_000),
+  },
+  proverBrokerJobMaxRetries: {
+    env: 'PROVER_BROKER_JOB_MAX_RETRIES',
+    description: 'If starting a prover broker locally, the max number of retries per proving job',
+    ...numberConfigHelper(3),
+  },
+  proverBrokerBatchSize: {
+    env: 'PROVER_BROKER_BATCH_SIZE',
+    description: 'The prover broker writes jobs to disk in batches',
+    ...numberConfigHelper(100),
+  },
+  proverBrokerBatchIntervalMs: {
+    env: 'PROVER_BROKER_BATCH_INTERVAL_MS',
+    description: 'How often to flush batches to disk',
+    ...numberConfigHelper(50),
+  },
+  proverBrokerMaxEpochsToKeepResultsFor: {
+    env: 'PROVER_BROKER_MAX_EPOCHS_TO_KEEP_RESULTS_FOR',
+    description: 'The maximum number of epochs to keep results for',
+    ...numberConfigHelper(1),
+  },
+  proverBrokerStoreMapSizeKb: {
+    env: 'PROVER_BROKER_STORE_MAP_SIZE_KB',
+    ...optionalNumberConfigHelper(),
+    description: "The size of the prover broker's database. Will override the dataStoreMapSizeKb if set.",
+  },
+  proverBrokerDebugReplayEnabled: {
+    env: 'PROVER_BROKER_DEBUG_REPLAY_ENABLED',
+    description: 'Enable debug replay mode for replaying proving jobs from stored inputs',
+    ...booleanConfigHelper(false),
+  },
+  ...dataConfigMappings,
+  ...l1ReaderConfigMappings,
+  ...pickConfigMappings(chainConfigMappings, ['rollupVersion']),
+};
+
+export const defaultProverBrokerConfig: ProverBrokerConfig = getDefaultConfig(proverBrokerConfigMappings);
+
+export const ProverAgentConfig = z.object({
+  /** The number of prover agents to start */
+  proverAgentCount: z.number(),
+  /** The types of proofs the prover agent can generate */
+  proverAgentProofTypes: z.array(z.nativeEnum(ProvingRequestType)),
+  /** How often the prover agents poll for jobs */
+  proverAgentPollIntervalMs: z.number(),
+  /** The URL where this agent takes jobs from */
+  proverBrokerUrl: z.string().optional(),
+  /** Whether to construct real proofs */
+  realProofs: z.boolean(),
+  /** The type of artificial delay to introduce */
+  proverTestDelayType: z.enum(['fixed', 'realistic']),
+  /** If using fixed delay, the time each operation takes. */
+  proverTestDelayMs: z.number(),
+  /** If using realistic delays, what percentage of realistic times to apply. */
+  proverTestDelayFactor: z.number(),
+  /** The delay (ms) to inject during fake proof verification */
+  proverTestVerificationDelayMs: z.number().optional(),
+  /** Whether to abort pending proving jobs when the orchestrator is cancelled */
+  cancelJobsOnStop: z.boolean(),
+  /** Where to store proving results. Must be accessible to both prover node and agents. If not set will inline-encode the parameters */
+  proofStore: z.string().optional(),
+});
+
+export type ProverAgentConfig = z.infer<typeof ProverAgentConfig>;
+
+export const proverAgentConfigMappings: ConfigMappingsType<ProverAgentConfig> = {
+  proverAgentCount: {
+    env: 'PROVER_AGENT_COUNT',
+    description: 'Whether this prover has a local prover agent',
+    ...numberConfigHelper(1),
+  },
+  proverAgentPollIntervalMs: {
+    env: 'PROVER_AGENT_POLL_INTERVAL_MS',
+    description: 'The interval agents poll for jobs at',
+    ...numberConfigHelper(1000),
+  },
+  proverAgentProofTypes: {
+    env: 'PROVER_AGENT_PROOF_TYPES',
+    description: 'The types of proofs the prover agent can generate',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(v => ProvingRequestType[v as any])
+        .filter(v => typeof v === 'number'),
+  },
+  proverBrokerUrl: {
+    env: 'PROVER_BROKER_HOST',
+    description: 'The URL where this agent takes jobs from',
+  },
+  realProofs: {
+    env: 'PROVER_REAL_PROOFS',
+    description: 'Whether to construct real proofs',
+    ...booleanConfigHelper(true),
+  },
+  proverTestDelayType: {
+    env: 'PROVER_TEST_DELAY_TYPE',
+    description: 'The type of artificial delay to introduce',
+    defaultValue: 'fixed',
+  },
+  proverTestDelayMs: {
+    env: 'PROVER_TEST_DELAY_MS',
+    description: 'Artificial delay to introduce to all operations to the test prover.',
+    ...numberConfigHelper(0),
+  },
+  proverTestDelayFactor: {
+    env: 'PROVER_TEST_DELAY_FACTOR',
+    description: 'If using realistic delays, what percentage of realistic times to apply.',
+    ...numberConfigHelper(1),
+  },
+  proverTestVerificationDelayMs: {
+    env: 'PROVER_TEST_VERIFICATION_DELAY_MS',
+    description: 'The delay (ms) to inject during fake proof verification',
+    ...numberConfigHelper(10),
+  },
+  cancelJobsOnStop: {
+    env: 'PROVER_CANCEL_JOBS_ON_STOP',
+    description:
+      'Whether to abort pending proving jobs when the orchestrator is cancelled. ' +
+      'When false (default), jobs remain in the broker queue and can be reused on restart/reorg.',
+    ...booleanConfigHelper(false),
+  },
+  proofStore: {
+    env: 'PROVER_PROOF_STORE',
+    description: 'Optional proof input store for the prover',
+  },
+};

package/src/proving_broker/factory.ts

@@ -0,0 +1,19 @@
+import type { TelemetryClient } from '@aztec-labs/telemetry-client';
+
+import type { ProverBrokerConfig } from './config.js';
+import { ProvingBroker } from './proving_broker.js';
+import { InMemoryBrokerDatabase } from './proving_broker_database/memory.js';
+import { KVBrokerDatabase } from './proving_broker_database/persisted.js';
+
+export async function createAndStartProvingBroker(
+  _config: ProverBrokerConfig,
+  client: TelemetryClient,
+): Promise<ProvingBroker> {
+  const config = { ..._config, dataStoreMapSizeKb: _config.proverBrokerStoreMapSizeKb ?? _config.dataStoreMapSizeKb };
+  const database = config.dataDirectory ? await KVBrokerDatabase.new(config, client) : new InMemoryBrokerDatabase();
+
+  const broker = new ProvingBroker(database, config, client);
+
+  await broker.start();
+  return broker;
+}

package/src/proving_broker/fixtures.ts

@@ -0,0 +1,20 @@
+import { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import { randomBytes } from '@aztec-labs/foundation/crypto/random';
+import { type ProofUri, type ProvingJobId, makeProvingJobId } from '@aztec-labs/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+
+export function makeRandomProvingJobId(epochNumber?: EpochNumber): ProvingJobId {
+  return makeProvingJobId(
+    epochNumber ?? EpochNumber(1),
+    ProvingRequestType.INBOX_PARITY,
+    randomBytes(8).toString('hex'),
+  );
+}
+
+export function makeInputsUri(): ProofUri {
+  return randomBytes(8).toString('hex') as ProofUri;
+}
+
+export function makeOutputsUri(): ProofUri {
+  return randomBytes(8).toString('hex') as ProofUri;
+}

package/src/proving_broker/index.ts

@@ -0,0 +1,10 @@
+export * from './proving_agent.js';
+export * from './proving_broker.js';
+export * from './rpc.js';
+export * from './proving_broker_database.js';
+export * from './proving_broker_database/memory.js';
+export * from './proving_broker_database/persisted.js';
+export * from './proof_store/index.js';
+export * from './factory.js';
+export * from './config.js';
+export { BrokerCircuitProverFacade } from './broker_prover_facade.js';

package/src/proving_broker/proof_store/factory.ts

@@ -0,0 +1,20 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { createFileStore } from '@aztec-labs/stdlib/file-store';
+
+import { FileStoreProofStore } from './file_store_proof_store.js';
+import { InlineProofStore } from './inline_proof_store.js';
+import type { ProofStore } from './proof_store.js';
+
+export async function createProofStore(
+  config: string | undefined,
+  logger = createLogger('prover-client:proof-store'),
+): Promise<ProofStore> {
+  if (!config) {
+    logger.info('Creating inline proof store');
+    return new InlineProofStore();
+  }
+
+  const fileStore = await createFileStore(config, logger);
+  logger.info(`Creating file store proof store at ${config}`);
+  return new FileStoreProofStore(fileStore);
+}

package/src/proving_broker/proof_store/file_store_proof_store.ts

@@ -0,0 +1,78 @@
+import { jsonParseWithSchema, jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import type { FileStore } from '@aztec-labs/stdlib/file-store';
+import {
+  type ProofUri,
+  type ProvingJobId,
+  type ProvingJobInputs,
+  type ProvingJobInputsMap,
+  ProvingJobResult,
+  type ProvingJobResultsMap,
+  getProvingJobInputClassFor,
+} from '@aztec-labs/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+
+import type { ProofStore } from './proof_store.js';
+
+const INPUTS_PATH = 'inputs';
+const OUTPUTS_PATH = 'outputs';
+
+/**
+ * A proof store implementation backed by a generic FileStore.
+ * Supports any storage backend (GCS, S3, local filesystem) via the FileStore abstraction.
+ */
+export class FileStoreProofStore implements ProofStore {
+  constructor(private readonly fileStore: FileStore) {}
+
+  async saveProofInput<T extends ProvingRequestType>(
+    id: ProvingJobId,
+    type: T,
+    inputs: ProvingJobInputsMap[T],
+  ): Promise<ProofUri> {
+    const path = `${INPUTS_PATH}/${ProvingRequestType[type]}/${id}`;
+    const uri = await this.fileStore.save(path, inputs.toBuffer());
+    return uri as ProofUri;
+  }
+
+  async saveProofOutput<T extends ProvingRequestType>(
+    id: ProvingJobId,
+    type: T,
+    result: ProvingJobResultsMap[T],
+  ): Promise<ProofUri> {
+    const jobResult = { type, result } as ProvingJobResult;
+    const json = jsonStringify(jobResult);
+    const path = `${OUTPUTS_PATH}/${ProvingRequestType[type]}/${id}.json`;
+    const uri = await this.fileStore.save(path, Buffer.from(json, 'utf-8'));
+    return uri as ProofUri;
+  }
+
+  async getProofInput(uri: ProofUri): Promise<ProvingJobInputs> {
+    try {
+      const buffer = await this.fileStore.read(uri);
+      const type = this.extractTypeFromUri(uri);
+      const inputs = getProvingJobInputClassFor(type).fromBuffer(buffer);
+      return { inputs, type } as ProvingJobInputs;
+    } catch (err) {
+      throw new Error(`Error getting proof input at ${uri}: ${err}`);
+    }
+  }
+
+  async getProofOutput(uri: ProofUri): Promise<ProvingJobResult> {
+    try {
+      const buffer = await this.fileStore.read(uri);
+      return jsonParseWithSchema(buffer.toString('utf-8'), ProvingJobResult);
+    } catch (err) {
+      throw new Error(`Error getting proof output at ${uri}: ${err}`);
+    }
+  }
+
+  private extractTypeFromUri(uri: string): ProvingRequestType {
+    const url = new URL(uri);
+    const pathParts = url.pathname.split('/').filter(Boolean);
+    const typeString = pathParts.at(-2);
+    const type = typeString ? ProvingRequestType[typeString as keyof typeof ProvingRequestType] : undefined;
+    if (type === undefined) {
+      throw new Error(`Unrecognized proof type ${typeString} in URI ${uri}`);
+    }
+    return type;
+  }
+}

package/src/proving_broker/proof_store/index.ts

@@ -0,0 +1,4 @@
+export * from './proof_store.js';
+export * from './inline_proof_store.js';
+export * from './factory.js';
+export * from './file_store_proof_store.js';

package/src/proving_broker/proof_store/inline_proof_store.ts

@@ -0,0 +1,63 @@
+import { jsonParseWithSchema, jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import {
+  type ProofUri,
+  type ProvingJobId,
+  ProvingJobInputs,
+  type ProvingJobInputsMap,
+  ProvingJobResult,
+  type ProvingJobResultsMap,
+} from '@aztec-labs/stdlib/interfaces/server';
+import type { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+import type { ZodFor } from '@aztec-labs/stdlib/schemas';
+
+import type { ProofStore } from './proof_store.js';
+
+// use an ASCII encoded data uri https://datatracker.ietf.org/doc/html/rfc2397#section-2
+// we do this to avoid double encoding to base64 (since the inputs already serialize to a base64 string)
+const PREFIX = 'data:application/json;charset=utf-8';
+const SEPARATOR = ',';
+
+/**
+ * An implementation of a proof input/output database that stores data inline in the URI.
+ */
+export class InlineProofStore implements ProofStore {
+  saveProofInput<T extends ProvingRequestType>(
+    _id: ProvingJobId,
+    type: T,
+    inputs: ProvingJobInputsMap[T],
+  ): Promise<ProofUri> {
+    const jobInputs = { type, inputs } as ProvingJobInputs;
+    return Promise.resolve(this.encode(jobInputs));
+  }
+
+  saveProofOutput<T extends ProvingRequestType>(
+    _id: ProvingJobId,
+    type: T,
+    result: ProvingJobResultsMap[T],
+  ): Promise<ProofUri> {
+    const jobResult = { type, result } as ProvingJobResult;
+    return Promise.resolve(this.encode(jobResult));
+  }
+
+  getProofInput(uri: ProofUri): Promise<ProvingJobInputs> {
+    return Promise.resolve(this.decode(uri, ProvingJobInputs));
+  }
+
+  getProofOutput(uri: ProofUri): Promise<ProvingJobResult> {
+    return Promise.resolve(this.decode(uri, ProvingJobResult));
+  }
+
+  private encode(obj: object): ProofUri {
+    const encoded = encodeURIComponent(jsonStringify(obj));
+    return (PREFIX + SEPARATOR + encoded) as ProofUri;
+  }
+
+  private decode<T>(uri: ProofUri, schema: ZodFor<T>): T {
+    const [prefix, data] = uri.split(SEPARATOR);
+    if (prefix !== PREFIX) {
+      throw new Error('Invalid proof input URI: ' + prefix);
+    }
+
+    return jsonParseWithSchema(decodeURIComponent(data), schema);
+  }
+}

package/src/proving_broker/proof_store/proof_store.ts

@@ -0,0 +1,54 @@
+import type {
+  ProofUri,
+  ProvingJobId,
+  ProvingJobInputs,
+  ProvingJobInputsMap,
+  ProvingJobResult,
+  ProvingJobResultsMap,
+} from '@aztec-labs/stdlib/interfaces/server';
+import type { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+
+/**
+ * A database for storing proof inputs and outputs.
+ */
+export interface ProofStore {
+  /**
+   * Save a proof input to the database.
+   * @param jobId - The ID of the job the proof input is associated with.
+   * @param type - The type of the proving request.
+   * @param inputs - The proof input to save.
+   * @returns The URI of the saved proof input.
+   */
+  saveProofInput<T extends ProvingRequestType>(
+    jobId: ProvingJobId,
+    type: T,
+    inputs: ProvingJobInputsMap[T],
+  ): Promise<ProofUri>;
+
+  /**
+   * Save a proof output to the database.
+   * @param jobId - The ID of the job the proof input is associated with.
+   * @param type - The type of the proving request.
+   * @param result - The proof output to save.
+   * @returns The URI of the saved proof output.
+   */
+  saveProofOutput<T extends ProvingRequestType>(
+    id: ProvingJobId,
+    type: T,
+    result: ProvingJobResultsMap[T],
+  ): Promise<ProofUri>;
+
+  /**
+   * Retrieve a proof input from the database.
+   * @param uri - The URI of the proof input to retrieve.
+   * @returns The proof input.
+   */
+  getProofInput(uri: ProofUri): Promise<ProvingJobInputs>;
+
+  /**
+   * Retrieve a proof output from the database.
+   * @param uri - The URI of the proof output to retrieve.
+   * @returns The proof output.
+   */
+  getProofOutput(uri: ProofUri): Promise<ProvingJobResult>;
+}

package/src/proving_broker/proving_agent.ts

@@ -0,0 +1,210 @@
+import { AbortError } from '@aztec-labs/foundation/error';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec-labs/foundation/log';
+import { RunningPromise } from '@aztec-labs/foundation/running-promise';
+import { truncate } from '@aztec-labs/foundation/string';
+import { ProvingError } from '@aztec-labs/stdlib/errors';
+import type {
+  GetProvingJobResponse,
+  ProverAgentStatus,
+  ProvingJobConsumer,
+  ProvingJobId,
+  ProvingJobInputs,
+  ProvingJobResultsMap,
+  ServerCircuitProver,
+} from '@aztec-labs/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+
+import type { ProofStore } from './proof_store/index.js';
+import { ProvingJobController, ProvingJobControllerStatus } from './proving_job_controller.js';
+
+/**
+ * A helper class that encapsulates a circuit prover and connects it to a job source.
+ */
+export class ProvingAgent {
+  private currentJobController?: ProvingJobController;
+  private runningPromise: RunningPromise;
+  private log: Logger;
+
+  constructor(
+    /** The source of proving jobs */
+    private broker: ProvingJobConsumer,
+    /** Database holding proof inputs and outputs */
+    private proofStore: ProofStore,
+    /** The prover implementation to defer jobs to */
+    private circuitProver: ServerCircuitProver,
+    /** Optional list of allowed proof types to build */
+    private proofAllowList: Array<ProvingRequestType> = [],
+    /** How long to wait between jobs */
+    private pollIntervalMs = 1000,
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('prover-client:proving-agent', bindings);
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollIntervalMs);
+  }
+
+  public setCircuitProver(circuitProver: ServerCircuitProver): void {
+    this.circuitProver = circuitProver;
+  }
+
+  public isRunning(): boolean {
+    return this.runningPromise?.isRunning() ?? false;
+  }
+
+  public start(): void {
+    this.runningPromise.start();
+  }
+
+  public async stop(): Promise<void> {
+    this.currentJobController?.abort();
+    await this.runningPromise.stop();
+  }
+
+  public getStatus(): ProverAgentStatus {
+    if (this.currentJobController) {
+      return {
+        status: 'proving',
+        jobId: this.currentJobController.getJobId(),
+        proofType: this.currentJobController.getProofType(),
+        startedAtISO: new Date(this.currentJobController.getStartedAt()).toISOString(),
+      };
+    }
+
+    return this.runningPromise.isRunning() ? { status: 'running' } : { status: 'stopped' };
+  }
+
+  private async work() {
+    // every tick we need to take one of the following actions:
+    // 1. send a hearbeat to the broker that we're working on some job
+    // 2. if the job is complete, send its result to the broker
+    // 3. get a job from the broker
+    // Any one of these actions could give us a new job to work on. If that happens we abort the current job.
+    //
+    // This loop gets triggered in one of two ways:
+    // - either on a timer (see pollIntervalMs)
+    // - or when a proof completes
+    let maybeJob: GetProvingJobResponse | undefined;
+
+    if (this.currentJobController) {
+      const status = this.currentJobController.getStatus();
+      const jobId = this.currentJobController.getJobId();
+      const proofType = this.currentJobController.getProofType();
+      const startedAt = this.currentJobController.getStartedAt();
+      const result = this.currentJobController.getResult();
+
+      if (status === ProvingJobControllerStatus.RUNNING) {
+        maybeJob = await this.broker.reportProvingJobProgress(jobId, startedAt, { allowList: this.proofAllowList });
+      } else if (status === ProvingJobControllerStatus.DONE) {
+        if (result) {
+          maybeJob = await this.reportResult(jobId, proofType, result);
+        } else {
+          this.log.warn(
+            `Job controller for job ${this.currentJobController.getJobId()} is done but doesn't have a result`,
+            { jobId },
+          );
+          maybeJob = await this.reportResult(
+            jobId,
+            proofType,
+            new ProvingError('No result found after proving', undefined, /* retry */ true),
+          );
+        }
+
+        this.currentJobController = undefined;
+      } else {
+        // IDLE status should not be seen because a job is started as soon as it is created
+        this.log.warn(`Idle job controller for job: ${this.currentJobController.getJobId()}. Skipping main loop work`, {
+          jobId: this.currentJobController.getJobId(),
+        });
+        return;
+      }
+    } else {
+      maybeJob = await this.broker.getProvingJob({ allowList: this.proofAllowList });
+    }
+
+    if (maybeJob) {
+      await this.startJob(maybeJob);
+    }
+  }
+
+  private async startJob({ job, time: startedAt }: GetProvingJobResponse): Promise<void> {
+    let abortedProofJobId: string | undefined;
+    let abortedProofName: string | undefined;
+
+    if (this.currentJobController?.getStatus() === ProvingJobControllerStatus.RUNNING) {
+      abortedProofJobId = this.currentJobController.getJobId();
+      abortedProofName = this.currentJobController.getProofTypeName();
+      this.currentJobController?.abort();
+    }
+
+    let inputs: ProvingJobInputs;
+    try {
+      inputs = await this.proofStore.getProofInput(job.inputsUri);
+    } catch {
+      const maybeJob = await this.broker.reportProvingJobError(job.id, 'Failed to load proof inputs', true, {
+        allowList: this.proofAllowList,
+      });
+
+      if (maybeJob) {
+        return this.startJob(maybeJob);
+      }
+
+      return;
+    }
+
+    this.currentJobController = new ProvingJobController(
+      job.id,
+      inputs,
+      job.epochNumber,
+      startedAt,
+      this.circuitProver,
+      () => {
+        // trigger a run of the main work loop when proving completes
+        // no need to await this here. The controller will stay alive (in DONE state) until the result is send to the broker
+        void this.runningPromise.trigger();
+      },
+      this.log.getBindings(),
+    );
+
+    if (abortedProofJobId) {
+      this.log.info(
+        `Aborting job id=${abortedProofJobId} type=${abortedProofName} to start new job id=${this.currentJobController.getJobId()} type=${this.currentJobController.getProofTypeName()} inputsUri=${truncate(
+          job.inputsUri,
+        )}`,
+      );
+    } else {
+      this.log.info(
+        `Starting job id=${this.currentJobController.getJobId()} type=${this.currentJobController.getProofTypeName()} inputsUri=${truncate(
+          job.inputsUri,
+        )}`,
+      );
+    }
+
+    this.currentJobController.start();
+  }
+
+  private async reportResult<T extends ProvingRequestType>(
+    jobId: ProvingJobId,
+    type: T,
+    result: ProvingJobResultsMap[T] | Error,
+  ): Promise<GetProvingJobResponse | undefined> {
+    let maybeJob: GetProvingJobResponse | undefined;
+    if (result instanceof AbortError) {
+      // no-op
+      this.log.warn(`Job id=${jobId} was aborted. Not reporting result back to broker`, result);
+    } else if (result instanceof Error) {
+      const retry = result.name === ProvingError.NAME ? (result as ProvingError).retry : false;
+      this.log.error(
+        `Job id=${jobId} type=${ProvingRequestType[type]} failed err=${result.message} retry=${retry}`,
+        result,
+      );
+      maybeJob = await this.broker.reportProvingJobError(jobId, result.message, retry, {
+        allowList: this.proofAllowList,
+      });
+    } else {
+      const outputUri = await this.proofStore.saveProofOutput(jobId, type, result);
+      this.log.info(`Job id=${jobId} type=${ProvingRequestType[type]} completed outputUri=${truncate(outputUri)}`);
+      maybeJob = await this.broker.reportProvingJobSuccess(jobId, outputUri, { allowList: this.proofAllowList });
+    }
+
+    return maybeJob;
+  }
+}