@aztec/prover-client 0.65.0 → 0.65.2

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/proving_broker/caching_broker_facade.ts

@@ -0,0 +1,312 @@
+import {
+  type ProofAndVerificationKey,
+  type ProverCache,
+  type ProvingJobId,
+  type ProvingJobInputsMap,
+  type ProvingJobProducer,
+  type ProvingJobResultsMap,
+  ProvingRequestType,
+  type PublicInputsAndRecursiveProof,
+  type ServerCircuitProver,
+} from '@aztec/circuit-types';
+import {
+  type AVM_PROOF_LENGTH_IN_FIELDS,
+  type AvmCircuitInputs,
+  type BaseOrMergeRollupPublicInputs,
+  type BaseParityInputs,
+  type BlockMergeRollupInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  type BlockRootRollupInputs,
+  type EmptyBlockRootRollupInputs,
+  type KernelCircuitPublicInputs,
+  type MergeRollupInputs,
+  type NESTED_RECURSIVE_PROOF_LENGTH,
+  type ParityPublicInputs,
+  type PrivateBaseRollupInputs,
+  type PrivateKernelEmptyInputData,
+  type PublicBaseRollupInputs,
+  type RECURSIVE_PROOF_LENGTH,
+  type RootParityInputs,
+  type RootRollupInputs,
+  type RootRollupPublicInputs,
+  type TUBE_PROOF_LENGTH,
+  type TubeInputs,
+} from '@aztec/circuits.js';
+import { sha256 } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+
+import { InlineProofStore, type ProofStore } from './proof_store.js';
+import { InMemoryProverCache } from './prover_cache/memory.js';
+
+// 20 minutes, roughly the length of an Aztec epoch. If a proof isn't ready in this amount of time then we've failed to prove the whole epoch
+const MAX_WAIT_MS = 1_200_000;
+
+/**
+ * A facade around a job broker that generates stable job ids and caches results
+ */
+export class CachingBrokerFacade implements ServerCircuitProver {
+  constructor(
+    private broker: ProvingJobProducer,
+    private cache: ProverCache = new InMemoryProverCache(),
+    private proofStore: ProofStore = new InlineProofStore(),
+    private waitTimeoutMs = MAX_WAIT_MS,
+    private pollIntervalMs = 1000,
+    private log = createDebugLogger('aztec:prover-client:caching-prover-broker'),
+  ) {}
+
+  private async enqueueAndWaitForJob<T extends ProvingRequestType>(
+    id: ProvingJobId,
+    type: T,
+    inputs: ProvingJobInputsMap[T],
+    signal?: AbortSignal,
+  ): Promise<ProvingJobResultsMap[T]> {
+    // first try the cache
+    let jobEnqueued = false;
+    try {
+      const cachedResult = await this.cache.getProvingJobStatus(id);
+      if (cachedResult.status !== 'not-found') {
+        this.log.debug(`Found cached result for job=${id}: status=${cachedResult.status}`);
+      }
+
+      if (cachedResult.status === 'fulfilled') {
+        const output = await this.proofStore.getProofOutput(cachedResult.value);
+        if (output.type === type) {
+          return output.result as ProvingJobResultsMap[T];
+        } else {
+          this.log.warn(`Cached result type mismatch for job=${id}. Expected=${type} but got=${output.type}`);
+        }
+      } else if (cachedResult.status === 'rejected') {
+        // prefer returning a rejected promises so that we don't trigger the catch block below
+        return Promise.reject(new Error(cachedResult.reason));
+      } else if (cachedResult.status === 'in-progress' || cachedResult.status === 'in-queue') {
+        jobEnqueued = true;
+      } else {
+        jobEnqueued = false;
+      }
+    } catch (err) {
+      this.log.warn(`Failed to get cached proving job id=${id}: ${err}. Re-running job`);
+    }
+
+    if (!jobEnqueued) {
+      try {
+        const inputsUri = await this.proofStore.saveProofInput(id, type, inputs);
+        await this.broker.enqueueProvingJob({
+          id,
+          type,
+          inputsUri,
+        });
+        await this.cache.setProvingJobStatus(id, { status: 'in-queue' });
+      } catch (err) {
+        this.log.error(`Failed to enqueue proving job id=${id}: ${err}`);
+        await this.cache.setProvingJobStatus(id, { status: 'not-found' });
+        throw err;
+      }
+    }
+
+    // notify broker of cancelled job
+    const abortFn = async () => {
+      signal?.removeEventListener('abort', abortFn);
+      await this.broker.removeAndCancelProvingJob(id);
+    };
+
+    signal?.addEventListener('abort', abortFn);
+
+    try {
+      // loop here until the job settles
+      // NOTE: this could also terminate because the job was cancelled through event listener above
+      const result = await retryUntil(
+        async () => {
+          try {
+            return await this.broker.waitForJobToSettle(id);
+          } catch (err) {
+            // waitForJobToSettle can only fail for network errors
+            // keep retrying until we time out
+          }
+        },
+        `Proving job=${id} type=${ProvingRequestType[type]}`,
+        this.waitTimeoutMs / 1000,
+        this.pollIntervalMs / 1000,
+      );
+
+      try {
+        await this.cache.setProvingJobStatus(id, result);
+      } catch (err) {
+        this.log.warn(`Failed to cache proving job id=${id} resultStatus=${result.status}: ${err}`);
+      }
+
+      if (result.status === 'fulfilled') {
+        const output = await this.proofStore.getProofOutput(result.value);
+        if (output.type === type) {
+          return output.result as ProvingJobResultsMap[T];
+        } else {
+          return Promise.reject(new Error(`Unexpected proof type: ${output.type}. Expected: ${type}`));
+        }
+      } else {
+        return Promise.reject(new Error(result.reason));
+      }
+    } finally {
+      signal?.removeEventListener('abort', abortFn);
+    }
+  }
+
+  getAvmProof(
+    inputs: AvmCircuitInputs,
+    signal?: AbortSignal,
+    _blockNumber?: number,
+  ): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.PUBLIC_VM, inputs),
+      ProvingRequestType.PUBLIC_VM,
+      inputs,
+      signal,
+    );
+  }
+
+  getBaseParityProof(
+    inputs: BaseParityInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.BASE_PARITY, inputs),
+      ProvingRequestType.BASE_PARITY,
+      inputs,
+      signal,
+    );
+  }
+
+  getBlockMergeRollupProof(
+    input: BlockMergeRollupInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.BLOCK_MERGE_ROLLUP, input),
+      ProvingRequestType.BLOCK_MERGE_ROLLUP,
+      input,
+      signal,
+    );
+  }
+
+  getBlockRootRollupProof(
+    input: BlockRootRollupInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.BLOCK_ROOT_ROLLUP, input),
+      ProvingRequestType.BLOCK_ROOT_ROLLUP,
+      input,
+      signal,
+    );
+  }
+
+  getEmptyBlockRootRollupProof(
+    input: EmptyBlockRootRollupInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, input),
+      ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP,
+      input,
+      signal,
+    );
+  }
+
+  getEmptyPrivateKernelProof(
+    inputs: PrivateKernelEmptyInputData,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.PRIVATE_KERNEL_EMPTY, inputs),
+      ProvingRequestType.PRIVATE_KERNEL_EMPTY,
+      inputs,
+      signal,
+    );
+  }
+
+  getMergeRollupProof(
+    input: MergeRollupInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.MERGE_ROLLUP, input),
+      ProvingRequestType.MERGE_ROLLUP,
+      input,
+      signal,
+    );
+  }
+  getPrivateBaseRollupProof(
+    baseRollupInput: PrivateBaseRollupInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.PRIVATE_BASE_ROLLUP, baseRollupInput),
+      ProvingRequestType.PRIVATE_BASE_ROLLUP,
+      baseRollupInput,
+      signal,
+    );
+  }
+
+  getPublicBaseRollupProof(
+    inputs: PublicBaseRollupInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs),
+      ProvingRequestType.PUBLIC_BASE_ROLLUP,
+      inputs,
+      signal,
+    );
+  }
+
+  getRootParityProof(
+    inputs: RootParityInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.ROOT_PARITY, inputs),
+      ProvingRequestType.ROOT_PARITY,
+      inputs,
+      signal,
+    );
+  }
+
+  getRootRollupProof(
+    input: RootRollupInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.ROOT_ROLLUP, input),
+      ProvingRequestType.ROOT_ROLLUP,
+      input,
+      signal,
+    );
+  }
+
+  getTubeProof(
+    tubeInput: TubeInputs,
+    signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
+    return this.enqueueAndWaitForJob(
+      this.generateId(ProvingRequestType.TUBE_PROOF, tubeInput),
+      ProvingRequestType.TUBE_PROOF,
+      tubeInput,
+      signal,
+    );
+  }
+
+  private generateId(type: ProvingRequestType, inputs: { toBuffer(): Buffer }) {
+    const inputsHash = sha256(inputs.toBuffer());
+    return `${ProvingRequestType[type]}:${inputsHash.toString('hex')}`;
+  }
+}