@aztec/prover-client 0.0.0-test.0

package/src/proving_broker/proving_broker_database/memory.ts

@@ -0,0 +1,63 @@
+import {
+  type ProofUri,
+  type ProvingJob,
+  type ProvingJobId,
+  type ProvingJobSettledResult,
+  getEpochFromProvingJobId,
+} from '@aztec/stdlib/interfaces/server';
+
+import type { ProvingBrokerDatabase } from '../proving_broker_database.js';
+
+export class InMemoryBrokerDatabase implements ProvingBrokerDatabase {
+  private jobs = new Map<ProvingJobId, ProvingJob>();
+  private results = new Map<ProvingJobId, ProvingJobSettledResult>();
+
+  getProvingJob(id: ProvingJobId): ProvingJob | undefined {
+    return this.jobs.get(id);
+  }
+
+  getProvingJobResult(id: ProvingJobId): ProvingJobSettledResult | undefined {
+    return this.results.get(id);
+  }
+
+  addProvingJob(job: ProvingJob): Promise<void> {
+    this.jobs.set(job.id, job);
+    return Promise.resolve();
+  }
+
+  setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void> {
+    this.results.set(id, { status: 'fulfilled', value });
+    return Promise.resolve();
+  }
+
+  setProvingJobError(id: ProvingJobId, reason: string): Promise<void> {
+    this.results.set(id, { status: 'rejected', reason });
+    return Promise.resolve();
+  }
+
+  deleteProvingJobs(ids: ProvingJobId[]): Promise<void> {
+    for (const id of ids) {
+      this.jobs.delete(id);
+      this.results.delete(id);
+    }
+    return Promise.resolve();
+  }
+
+  deleteAllProvingJobsOlderThanEpoch(epochNumber: number): Promise<void> {
+    const toDelete = [
+      ...Array.from(this.jobs.keys()).filter(x => getEpochFromProvingJobId(x) < epochNumber),
+      ...Array.from(this.results.keys()).filter(x => getEpochFromProvingJobId(x) < epochNumber),
+    ];
+    return this.deleteProvingJobs(toDelete);
+  }
+
+  async *allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]> {
+    for await (const item of this.jobs.values()) {
+      yield [item, this.results.get(item.id)] as const;
+    }
+  }
+
+  close(): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/src/proving_broker/proving_broker_database/persisted.ts

@@ -0,0 +1,218 @@
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { BatchQueue } from '@aztec/foundation/queue';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { openVersionedStoreAt } from '@aztec/kv-store/lmdb-v2';
+import {
+  type ProofUri,
+  ProvingJob,
+  type ProvingJobId,
+  ProvingJobSettledResult,
+  getEpochFromProvingJobId,
+} from '@aztec/stdlib/interfaces/server';
+import { Attributes, LmdbMetrics, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { mkdir, readdir } from 'fs/promises';
+import { join } from 'path';
+
+import type { ProverBrokerConfig } from '../config.js';
+import type { ProvingBrokerDatabase } from '../proving_broker_database.js';
+
+class SingleEpochDatabase {
+  public static readonly SCHEMA_VERSION = 1;
+
+  private jobs: AztecAsyncMap<ProvingJobId, string>;
+  private jobResults: AztecAsyncMap<ProvingJobId, string>;
+
+  constructor(public readonly store: AztecAsyncKVStore) {
+    this.jobs = store.openMap('proving_jobs');
+    this.jobResults = store.openMap('proving_job_results');
+  }
+
+  estimateSize() {
+    return this.store.estimateSize();
+  }
+
+  async batchWrite(jobs: ProvingJob[], results: Array<[ProvingJobId, ProvingJobSettledResult]>) {
+    await this.store.transactionAsync(async () => {
+      for (const job of jobs) {
+        await this.jobs.set(job.id, jsonStringify(job));
+      }
+      for (const [id, result] of results) {
+        await this.jobResults.set(id, jsonStringify(result));
+      }
+    });
+  }
+
+  async *allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]> {
+    for await (const jobStr of this.jobs.valuesAsync()) {
+      const job = await jsonParseWithSchema(jobStr, ProvingJob);
+      const resultStr = await this.jobResults.getAsync(job.id);
+      const result = resultStr ? await jsonParseWithSchema(resultStr, ProvingJobSettledResult) : undefined;
+      yield [job, result];
+    }
+  }
+
+  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));
+  }
+
+  delete() {
+    return this.store.delete();
+  }
+
+  close() {
+    return this.store.close();
+  }
+}
+
+export class KVBrokerDatabase implements ProvingBrokerDatabase {
+  private metrics: LmdbMetrics;
+
+  private batchQueue: BatchQueue<ProvingJob | [ProvingJobId, ProvingJobSettledResult], number>;
+
+  private constructor(
+    private epochs: Map<number, SingleEpochDatabase>,
+    private config: ProverBrokerConfig,
+    client: TelemetryClient = getTelemetryClient(),
+    private logger: Logger,
+  ) {
+    this.metrics = new LmdbMetrics(
+      client.getMeter('KVBrokerDatabase'),
+      {
+        [Attributes.DB_DATA_TYPE]: 'prover-broker',
+      },
+      () => this.estimateSize(),
+    );
+
+    this.batchQueue = new BatchQueue(
+      (items, key) => this.commitWrites(items, key),
+      config.proverBrokerBatchSize,
+      config.proverBrokerBatchIntervalMs,
+      createLogger('proving-client:proving-broker-database:batch-queue'),
+    );
+  }
+
+  // exposed for testing
+  public async commitWrites(items: Array<ProvingJob | [ProvingJobId, ProvingJobSettledResult]>, epochNumber: number) {
+    const jobsToAdd = items.filter((item): item is ProvingJob => 'id' in item);
+    const resultsToAdd = items.filter((item): item is [ProvingJobId, ProvingJobSettledResult] => Array.isArray(item));
+
+    const db = await this.getEpochDatabase(epochNumber);
+    await db.batchWrite(jobsToAdd, resultsToAdd);
+  }
+
+  private async estimateSize() {
+    const sizes = await Promise.all(Array.from(this.epochs.values()).map(x => x.estimateSize()));
+    return {
+      mappingSize: this.config.dataStoreMapSizeKB,
+      numItems: sizes.reduce((prev, curr) => prev + curr.numItems, 0),
+      actualSize: sizes.reduce((prev, curr) => prev + curr.actualSize, 0),
+    };
+  }
+
+  public static async new(
+    config: ProverBrokerConfig,
+    client: TelemetryClient = getTelemetryClient(),
+    logger = createLogger('prover-client:proving-broker-database'),
+  ) {
+    const epochs: Map<number, SingleEpochDatabase> = new Map<number, SingleEpochDatabase>();
+    const files = await readdir(config.dataDirectory!, { recursive: false, withFileTypes: true });
+    for (const file of files) {
+      if (!file.isDirectory()) {
+        continue;
+      }
+      const fullDirectory = join(config.dataDirectory!, file.name);
+      const epochDirectory = file.name;
+      const epochNumber = parseInt(epochDirectory, 10);
+      if (!Number.isSafeInteger(epochNumber) || epochNumber < 0) {
+        logger.warn(`Found invalid epoch directory ${fullDirectory} when loading epoch databases, ignoring`);
+        continue;
+      }
+      logger.info(
+        `Loading broker database for epoch ${epochNumber} from ${fullDirectory} with map size ${config.dataStoreMapSizeKB}KB`,
+      );
+      const db = await openVersionedStoreAt(
+        fullDirectory,
+        SingleEpochDatabase.SCHEMA_VERSION,
+        config.l1Contracts.rollupAddress,
+        config.dataStoreMapSizeKB,
+      );
+      const epochDb = new SingleEpochDatabase(db);
+      epochs.set(epochNumber, epochDb);
+    }
+    const db = new KVBrokerDatabase(epochs, config, client, logger);
+    db.start();
+    return db;
+  }
+
+  private start(): void {
+    this.batchQueue.start();
+  }
+
+  async close(): Promise<void> {
+    await this.batchQueue.stop();
+    for (const [_, v] of this.epochs) {
+      await v.close();
+    }
+  }
+
+  async deleteAllProvingJobsOlderThanEpoch(epochNumber: number): Promise<void> {
+    const oldEpochs = Array.from(this.epochs.keys()).filter(e => e < epochNumber);
+    for (const old of oldEpochs) {
+      const db = this.epochs.get(old);
+      if (!db) {
+        continue;
+      }
+      this.logger.info(`Deleting broker database for epoch ${old}`);
+      await db.delete();
+      this.epochs.delete(old);
+    }
+  }
+
+  addProvingJob(job: ProvingJob): Promise<void> {
+    return this.batchQueue.put(job, job.epochNumber);
+  }
+
+  async *allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]> {
+    const iterators = Array.from(this.epochs.values()).map(x => x.allProvingJobs());
+    for (const it of iterators) {
+      yield* it;
+    }
+  }
+
+  setProvingJobError(id: ProvingJobId, reason: string): Promise<void> {
+    return this.batchQueue.put([id, { status: 'rejected', reason }], getEpochFromProvingJobId(id));
+  }
+
+  setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void> {
+    return this.batchQueue.put([id, { status: 'fulfilled', value }], getEpochFromProvingJobId(id));
+  }
+
+  private async getEpochDatabase(epochNumber: number): Promise<SingleEpochDatabase> {
+    let epochDb = this.epochs.get(epochNumber);
+    if (!epochDb) {
+      const newEpochDirectory = join(this.config.dataDirectory!, epochNumber.toString());
+      await mkdir(newEpochDirectory, { recursive: true });
+      this.logger.info(
+        `Creating broker database for epoch ${epochNumber} at ${newEpochDirectory} with map size ${this.config.dataStoreMapSizeKB}`,
+      );
+      const db = await openVersionedStoreAt(
+        newEpochDirectory,
+        SingleEpochDatabase.SCHEMA_VERSION,
+        this.config.l1Contracts.rollupAddress,
+        this.config.dataStoreMapSizeKB,
+      );
+      epochDb = new SingleEpochDatabase(db);
+      this.epochs.set(epochNumber, epochDb);
+    }
+
+    return epochDb;
+  }
+}

package/src/proving_broker/proving_broker_database.ts

@@ -0,0 +1,44 @@
+import type { ProofUri, ProvingJob, ProvingJobId, ProvingJobSettledResult } from '@aztec/stdlib/interfaces/server';
+
+/**
+ * A database for storing proof requests and their results
+ */
+export interface ProvingBrokerDatabase {
+  /**
+   * Saves a proof request so it can be retrieved later
+   * @param job - The proof request to save
+   */
+  addProvingJob(job: ProvingJob): Promise<void>;
+
+  /**
+   * Deletes all proving jobs belonging to epochs older than the given epoch
+   * @param epochNumber - The epoch number beyond which jobs should be deleted
+   */
+  deleteAllProvingJobsOlderThanEpoch(epochNumber: number): Promise<void>;
+
+  /**
+   * Returns an iterator over all saved proving jobs
+   */
+  allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]>;
+
+  /**
+   * Saves the result of a proof request
+   * @param id - The ID of the proof request to save the result for
+   * @param ProvingRequestType - The type of proof that was requested
+   * @param value - The result of the proof request
+   */
+  setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void>;
+
+  /**
+   * Saves an error that occurred while processing a proof request
+   * @param id - The ID of the proof request to save the error for
+   * @param ProvingRequestType - The type of proof that was requested
+   * @param err - The error that occurred while processing the proof request
+   */
+  setProvingJobError(id: ProvingJobId, err: string): Promise<void>;
+
+  /**
+   * Closes the database
+   */
+  close(): Promise<void>;
+}

package/src/proving_broker/proving_broker_instrumentation.ts

@@ -0,0 +1,145 @@
+import type { Timer } from '@aztec/foundation/timer';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type ObservableGauge,
+  type ObservableResult,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export type MonitorCallback = (proofType: ProvingRequestType) => number;
+
+export class ProvingBrokerInstrumentation {
+  private queueSize: ObservableGauge;
+  private activeJobs: ObservableGauge;
+  private resolvedJobs: UpDownCounter;
+  private rejectedJobs: UpDownCounter;
+  private timedOutJobs: UpDownCounter;
+  private cachedJobs: UpDownCounter;
+  private totalJobs: UpDownCounter;
+  private jobWait: Histogram;
+  private jobDuration: Histogram;
+  private retriedJobs: UpDownCounter;
+
+  constructor(client: TelemetryClient, name = 'ProvingBroker') {
+    const meter = client.getMeter(name);
+
+    this.queueSize = meter.createObservableGauge(Metrics.PROVING_QUEUE_SIZE, {
+      valueType: ValueType.INT,
+    });
+
+    this.activeJobs = meter.createObservableGauge(Metrics.PROVING_QUEUE_ACTIVE_JOBS, {
+      valueType: ValueType.INT,
+    });
+
+    this.resolvedJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_RESOLVED_JOBS, {
+      valueType: ValueType.INT,
+    });
+
+    this.rejectedJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_REJECTED_JOBS, {
+      valueType: ValueType.INT,
+    });
+
+    this.retriedJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_RETRIED_JOBS, {
+      valueType: ValueType.INT,
+    });
+
+    this.timedOutJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_TIMED_OUT_JOBS, {
+      valueType: ValueType.INT,
+    });
+
+    this.cachedJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_CACHED_JOBS, {
+      valueType: ValueType.INT,
+    });
+
+    this.totalJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_TOTAL_JOBS, {
+      valueType: ValueType.INT,
+    });
+
+    this.jobWait = meter.createHistogram(Metrics.PROVING_QUEUE_JOB_WAIT, {
+      description: 'Records how long a job sits in the queue',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.jobDuration = meter.createHistogram(Metrics.PROVING_QUEUE_JOB_DURATION, {
+      description: 'Records how long a job takes to complete',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+  }
+
+  monitorQueueDepth(fn: MonitorCallback) {
+    this.queueSize.addCallback(obs => this.observe(obs, fn));
+  }
+
+  monitorActiveJobs(fn: MonitorCallback) {
+    this.activeJobs.addCallback(obs => this.observe(obs, fn));
+  }
+
+  incResolvedJobs(proofType: ProvingRequestType) {
+    this.resolvedJobs.add(1, {
+      [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+    });
+  }
+
+  incRejectedJobs(proofType: ProvingRequestType) {
+    this.rejectedJobs.add(1, {
+      [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+    });
+  }
+
+  incRetriedJobs(proofType: ProvingRequestType) {
+    this.retriedJobs.add(1, {
+      [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+    });
+  }
+
+  incTimedOutJobs(proofType: ProvingRequestType) {
+    this.timedOutJobs.add(1, {
+      [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+    });
+  }
+
+  incCachedJobs(proofType: ProvingRequestType) {
+    this.cachedJobs.add(1, {
+      [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+    });
+  }
+
+  incTotalJobs(proofType: ProvingRequestType) {
+    this.totalJobs.add(1, {
+      [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+    });
+  }
+
+  recordJobWait(proofType: ProvingRequestType, msOrTimer: Timer | number) {
+    const duration = typeof msOrTimer === 'number' ? msOrTimer : Math.floor(msOrTimer.ms());
+    this.jobWait.record(duration, {
+      [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+    });
+  }
+
+  recordJobDuration(proofType: ProvingRequestType, msOrTimer: Timer | number) {
+    const duration = typeof msOrTimer === 'number' ? msOrTimer : Math.floor(msOrTimer.ms());
+    this.jobDuration.record(duration, {
+      [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+    });
+  }
+
+  private observe(obs: ObservableResult, fn: MonitorCallback) {
+    for (const proofType of Object.values(ProvingRequestType)) {
+      // a type predicate for TypeScript to recognize that we're only iterating over enum values
+      if (typeof proofType !== 'number') {
+        continue;
+      }
+      obs.observe(fn(proofType), {
+        [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType],
+      });
+    }
+  }
+}

package/src/proving_broker/proving_job_controller.ts

@@ -0,0 +1,194 @@
+import { createLogger } from '@aztec/foundation/log';
+import type {
+  ProvingJobId,
+  ProvingJobInputs,
+  ProvingJobResultsMap,
+  ServerCircuitProver,
+} from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+
+export enum ProvingJobControllerStatus {
+  IDLE = 'idle',
+  PROVING = 'proving',
+  DONE = 'done',
+  ABORTED = 'aborted',
+}
+
+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: ProvingJobControllerStatus = ProvingJobControllerStatus.IDLE;
+  private promise?: Promise<void>;
+  private abortController = new AbortController();
+
+  constructor(
+    private jobId: ProvingJobId,
+    private inputs: ProvingJobInputs,
+    private epochNumber: number,
+    private startedAt: number,
+    private circuitProver: ServerCircuitProver,
+    private onComplete: ProvingJobCompletionCallback,
+    private log = createLogger('prover-client:proving-agent:job-controller'),
+  ) {}
+
+  public start(): void {
+    if (this.status !== ProvingJobControllerStatus.IDLE) {
+      this.log.verbose(
+        `Job controller for jobId=${this.jobId} not starting because it is not idle currentStatus=${this.status}`,
+        {
+          currentStatus: this.status,
+          jobId: this.jobId,
+        },
+      );
+      return;
+    }
+
+    this.status = ProvingJobControllerStatus.PROVING;
+    this.log.verbose(`Job controller started jobId=${this.jobId}`, {
+      jobId: this.jobId,
+    });
+
+    this.promise = this.generateProof()
+      .then(
+        result => {
+          if (this.status === ProvingJobControllerStatus.ABORTED) {
+            this.log.warn(`Job controller for jobId=${this.jobId} completed successfully but job was aborted`, {
+              currentStatus: this.status,
+              jobId: this.jobId,
+            });
+            return;
+          }
+          this.status = ProvingJobControllerStatus.DONE;
+          this.log.verbose(`Job controller for jobId=${this.jobId} completed successfully`, {
+            jobId: this.jobId,
+          });
+          return this.onComplete(this.jobId, this.inputs.type, undefined, result);
+        },
+        error => {
+          if (this.status === ProvingJobControllerStatus.ABORTED) {
+            this.log.warn(`Job controller for jobId=${this.jobId} finished with an error but job was aborted`, {
+              currentStatus: this.status,
+              jobId: this.jobId,
+            });
+            return;
+          }
+
+          if (error.name === 'AbortError') {
+            // Ignore abort errors
+            return;
+          }
+
+          this.log.verbose(`Job controller for jobId=${this.jobId} finished with an error`, {
+            jobId: this.jobId,
+            err: error,
+          });
+
+          this.status = ProvingJobControllerStatus.DONE;
+          return this.onComplete(this.jobId, this.inputs.type, error, undefined);
+        },
+      )
+      .catch(err => {
+        this.log.error(`Job constroller failed to send result for jobId=${this.jobId}: ${err}`, err, {
+          jobId: this.jobId,
+        });
+      });
+  }
+
+  public getStatus(): ProvingJobControllerStatus {
+    return this.status;
+  }
+
+  public abort(): void {
+    if (this.status !== ProvingJobControllerStatus.PROVING) {
+      this.log.warn(`Tried to abort job controller for jobId=${this.jobId} but it is not running`, {
+        currentStatus: this.status,
+        jobId: this.jobId,
+      });
+      return;
+    }
+
+    this.status = ProvingJobControllerStatus.ABORTED;
+    this.abortController.abort();
+    this.log.verbose(`Aborted job controller for jobId=${this.jobId}`, {
+      jobId: this.jobId,
+    });
+  }
+
+  public getJobId(): ProvingJobId {
+    return this.jobId;
+  }
+
+  public getStartedAt(): number {
+    return this.startedAt;
+  }
+
+  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: {
+        return await this.circuitProver.getAvmProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.PRIVATE_BASE_ROLLUP: {
+        return await this.circuitProver.getPrivateBaseRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.PUBLIC_BASE_ROLLUP: {
+        return await this.circuitProver.getPublicBaseRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.MERGE_ROLLUP: {
+        return await this.circuitProver.getMergeRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP: {
+        return await this.circuitProver.getEmptyBlockRootRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
+        return await this.circuitProver.getBlockRootRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP: {
+        return await this.circuitProver.getSingleTxBlockRootRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.BLOCK_MERGE_ROLLUP: {
+        return await this.circuitProver.getBlockMergeRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.ROOT_ROLLUP: {
+        return await this.circuitProver.getRootRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.BASE_PARITY: {
+        return await this.circuitProver.getBaseParityProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.ROOT_PARITY: {
+        return await this.circuitProver.getRootParityProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.TUBE_PROOF: {
+        return await this.circuitProver.getTubeProof(inputs, signal, this.epochNumber);
+      }
+
+      default: {
+        const _exhaustive: never = type;
+        return Promise.reject(new Error(`Invalid proof request type: ${type}`));
+      }
+    }
+  }
+}