@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/proving_broker/broker_prover_facade.ts

@@ -1,17 +1,17 @@
 import type {
-  AVM_PROOF_LENGTH_IN_FIELDS,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
-import { sha256 } from '@aztec/foundation/crypto';
-import { createLogger } from '@aztec/foundation/log';
+import { asyncPool } from '@aztec/foundation/async-pool';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { chunk } from '@aztec/foundation/collection';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
 import { truncate } from '@aztec/foundation/string';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import {
-  type ProofAndVerificationKey,
   type ProofUri,
   type ProvingJobId,
   type ProvingJobInputsMap,
@@ -22,23 +22,33 @@ import {
   type ServerCircuitProver,
   makeProvingJobId,
 } from '@aztec/stdlib/interfaces/server';
-import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
+import { ProvingRequestType, RecursiveProof } from '@aztec/stdlib/proofs';
 import type {
-  BaseOrMergeRollupPublicInputs,
-  BlockMergeRollupInputs,
-  BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
-  MergeRollupInputs,
-  PrivateBaseRollupInputs,
-  PublicBaseRollupInputs,
-  RootRollupInputs,
+  BlockMergeRollupPrivateInputs,
+  BlockRollupPublicInputs,
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+  CheckpointMergeRollupPrivateInputs,
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRollupPublicInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+  PrivateTxBaseRollupPrivateInputs,
+  PublicChonkVerifierPrivateInputs,
+  PublicChonkVerifierPublicInputs,
+  PublicTxBaseRollupPrivateInputs,
+  RootRollupPrivateInputs,
   RootRollupPublicInputs,
-  SingleTxBlockRootRollupInputs,
-  TubeInputs,
+  TxMergeRollupPrivateInputs,
+  TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 
+import { createHash } from 'node:crypto';
+
 import { InlineProofStore, type ProofStore } from './proof_store/index.js';
 
 // Perform a snapshot sync every 30 seconds
@@ -61,14 +71,17 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
   private runningPromise?: RunningPromise;
   private timeOfLastSnapshotSync = Date.now();
   private jobsToRetrieve: Set<ProvingJobId> = new Set();
+  private log: Logger;
 
   constructor(
     private broker: ProvingJobProducer,
     private proofStore: ProofStore = new InlineProofStore(),
     private failedProofStore?: ProofStore,
     private pollIntervalMs = 1000,
-    private log = createLogger('prover-client:broker-circuit-prover-facade'),
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('prover-client:broker-circuit-prover-facade', bindings);
+  }
 
   /**
    * This is a critical section. This function can not be async since it writes
@@ -93,7 +106,15 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
 
     // Create a promise for this job id, regardless of whether it was enqueued at the broker
     // The running promise will monitor for the job to be completed and resolve it either way
+    // We install an error handler to prevent unhandled rejections in the process before the
+    // job promise is awaited by the caller (see #13166)
     const promise = promiseWithResolvers<ProvingJobResultsMap[T]>();
+    promise.promise.catch(err =>
+      this.log.error(`Job errored with '${err.message ?? err}' id=${id} type=${ProvingRequestType[type]}`, {
+        provingJobId: id,
+        provingJobType: ProvingRequestType[type],
+      }),
+    );
     const abortFn = () => {
       signal?.removeEventListener('abort', abortFn);
       void this.broker.cancelProvingJob(id).catch(err => this.log.warn(`Error cancelling job id=${id}`, err));
@@ -114,7 +135,7 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
     id: ProvingJobId,
     type: T,
     inputs: ProvingJobInputsMap[T],
-    epochNumber = 0,
+    epochNumber = EpochNumber.ZERO,
     signal?: AbortSignal,
   ): Promise<ProvingJobResultsMap[T]> {
     const { job: job, isEnqueued } = this.getOrCreateProvingJob(id, type, signal);
@@ -125,27 +146,26 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
     try {
       const inputsUri = await this.proofStore.saveProofInput(id, type, inputs);
       job.inputsUri = inputsUri;
-      const jobStatus = await this.broker.enqueueProvingJob({
-        id,
-        type,
-        inputsUri,
+
+      // Send the job to the broker
+      const jobStatus = await this.broker.enqueueProvingJob({ id, type, inputsUri, epochNumber });
+
+      const jobLogText = `id=${id} type=${ProvingRequestType[type]} epochNumber=${epochNumber}`;
+      const jobLogData = {
+        provingJobId: id,
+        provingJobType: ProvingRequestType[type],
         epochNumber,
-      });
+        inputsUri: truncate(inputsUri),
+        status: jobStatus.status,
+        numOutstandingJobs: this.jobs.size,
+      };
 
       // If we are here then the job was successfully accepted by the broker
       // the returned status is for before any action was performed
       if (jobStatus.status === 'fulfilled' || jobStatus.status === 'rejected') {
         // Job was already completed by the broker
         // No need to notify the broker on aborted job
-        this.log.verbose(
-          `Job already completed when sent to broker id=${id} type=${ProvingRequestType[type]} epochNumber=${epochNumber}`,
-          {
-            provingJobId: id,
-            provingJobType: ProvingRequestType[type],
-            epochNumber,
-            inputsUri: truncate(inputsUri),
-          },
-        );
+        this.log.verbose(`Job already completed when sent to broker ${jobLogText}`, jobLogData);
 
         // Job was not enqueued. It must be completed already, add to our set of already completed jobs
         this.jobsToRetrieve.add(id);
@@ -155,27 +175,10 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
 
         // Job added for the first time
         if (jobStatus.status === 'not-found') {
-          this.log.verbose(
-            `Job enqueued with broker id=${id} type=${ProvingRequestType[type]} epochNumber=${epochNumber}`,
-            {
-              provingJobId: id,
-              provingJobType: ProvingRequestType[type],
-              epochNumber,
-              inputsUri: truncate(inputsUri),
-              numOutstandingJobs: this.jobs.size,
-            },
-          );
+          this.log.verbose(`Job enqueued with broker ${jobLogText}`, jobLogData);
         } else {
           // Job was previously sent to the broker but is not completed
-          this.log.verbose(
-            `Job already in queue or in progress when sent to broker id=${id} type=${ProvingRequestType[type]} epochNumber=${epochNumber}`,
-            {
-              provingJobId: id,
-              provingJobType: ProvingRequestType[type],
-              epochNumber,
-              inputsUri: truncate(inputsUri),
-            },
-          );
+          this.log.verbose(`Job already in queue or in progress when sent to broker ${jobLogText}`, jobLogData);
         }
       }
     } catch (err) {
@@ -225,17 +228,11 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
       // We collect all returned notifications and return them
       const allCompleted = new Set<ProvingJobId>();
       try {
-        let numRequests = 0;
-        while (ids.length > 0) {
-          const slice = ids.splice(0, SNAPSHOT_SYNC_CHECK_MAX_REQUEST_SIZE);
-          const completed = await this.broker.getCompletedJobs(slice);
+        const batches = ids.length > 0 ? chunk(ids, SNAPSHOT_SYNC_CHECK_MAX_REQUEST_SIZE) : [[]];
+        await asyncPool(1, batches, async batch => {
+          const completed = await this.broker.getCompletedJobs(batch);
           completed.forEach(id => allCompleted.add(id));
-          ++numRequests;
-        }
-        if (numRequests === 0) {
-          const final = await this.broker.getCompletedJobs([]);
-          final.forEach(id => allCompleted.add(id));
-        }
+        });
       } catch (err) {
         this.log.error(`Error thrown when requesting completed job notifications from the broker`, err);
       }
@@ -351,12 +348,8 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
       .map(id => this.jobs.get(id)!)
       .filter(x => x !== undefined);
     const totalJobsToRetrieve = toBeRetrieved.length;
-    let totalJobsRetrieved = 0;
-    while (toBeRetrieved.length > 0) {
-      const slice = toBeRetrieved.splice(0, MAX_CONCURRENT_JOB_SETTLED_REQUESTS);
-      const results = await Promise.all(slice.map(job => processJob(job!)));
-      totalJobsRetrieved += results.filter(x => x).length;
-    }
+    const results = await asyncPool(MAX_CONCURRENT_JOB_SETTLED_REQUESTS, toBeRetrieved, job => processJob(job));
+    const totalJobsRetrieved = results.filter(x => x).length;
     if (totalJobsToRetrieve > 0) {
       this.log.verbose(
         `Successfully retrieved ${totalJobsRetrieved} of ${totalJobsToRetrieve} jobs that should be ready, total ready jobs is now: ${this.jobsToRetrieve.size}`,
@@ -400,8 +393,8 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
   getAvmProof(
     inputs: AvmCircuitInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>> {
+    epochNumber?: EpochNumber,
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
     return this.enqueueJob(
       this.generateId(ProvingRequestType.PUBLIC_VM, inputs, epochNumber),
       ProvingRequestType.PUBLIC_VM,
@@ -412,29 +405,127 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
   }
 
   getBaseParityProof(
-    inputs: BaseParityInputs,
+    inputs: ParityBasePrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
+    epochNumber?: EpochNumber,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BASE_PARITY, inputs, epochNumber),
-      ProvingRequestType.BASE_PARITY,
+      this.generateId(ProvingRequestType.PARITY_BASE, inputs, epochNumber),
+      ProvingRequestType.PARITY_BASE,
       inputs,
       epochNumber,
       signal,
     );
   }
 
-  getBlockMergeRollupProof(
-    input: BlockMergeRollupInputs,
+  getTxMergeRollupProof(
+    input: TxMergeRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.TX_MERGE_ROLLUP, input, epochNumber),
+      ProvingRequestType.TX_MERGE_ROLLUP,
+      input,
+      epochNumber,
+      signal,
+    );
+  }
+
+  getPublicChonkVerifierProof(
+    inputs: PublicChonkVerifierPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: EpochNumber,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BLOCK_MERGE_ROLLUP, input, epochNumber),
-      ProvingRequestType.BLOCK_MERGE_ROLLUP,
+      this.generateId(ProvingRequestType.PUBLIC_CHONK_VERIFIER, inputs, epochNumber),
+      ProvingRequestType.PUBLIC_CHONK_VERIFIER,
+      inputs,
+      epochNumber,
+      signal,
+    );
+  }
+
+  getPrivateTxBaseRollupProof(
+    baseRollupInput: PrivateTxBaseRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, baseRollupInput, epochNumber),
+      ProvingRequestType.PRIVATE_TX_BASE_ROLLUP,
+      baseRollupInput,
+      epochNumber,
+      signal,
+    );
+  }
+
+  getPublicTxBaseRollupProof(
+    inputs: PublicTxBaseRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP, inputs, epochNumber),
+      ProvingRequestType.PUBLIC_TX_BASE_ROLLUP,
+      inputs,
+      epochNumber,
+      signal,
+    );
+  }
+
+  getRootParityProof(
+    inputs: ParityRootPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.PARITY_ROOT, inputs, epochNumber),
+      ProvingRequestType.PARITY_ROOT,
+      inputs,
+      epochNumber,
+      signal,
+    );
+  }
+
+  getBlockRootFirstRollupProof(
+    input: BlockRootFirstRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP, input, epochNumber),
+      ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP,
+      input,
+      epochNumber,
+      signal,
+    );
+  }
+
+  getBlockRootSingleTxFirstRollupProof(
+    input: BlockRootSingleTxFirstRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP, input, epochNumber),
+      ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP,
+      input,
+      epochNumber,
+      signal,
+    );
+  }
+
+  getBlockRootEmptyTxFirstRollupProof(
+    input: BlockRootEmptyTxFirstRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP, input, epochNumber),
+      ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP,
       input,
       epochNumber,
       signal,
@@ -442,12 +533,10 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
   }
 
   getBlockRootRollupProof(
-    input: BlockRootRollupInputs,
+    input: BlockRootRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return this.enqueueJob(
       this.generateId(ProvingRequestType.BLOCK_ROOT_ROLLUP, input, epochNumber),
       ProvingRequestType.BLOCK_ROOT_ROLLUP,
@@ -457,103 +546,102 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
     );
   }
 
-  getSingleTxBlockRootRollupProof(
-    input: SingleTxBlockRootRollupInputs,
+  getBlockRootSingleTxRollupProof(
+    input: BlockRootSingleTxRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BLOCK_ROOT_ROLLUP, input, epochNumber),
-      ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP,
+      this.generateId(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP, input, epochNumber),
+      ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
 
-  getEmptyBlockRootRollupProof(
-    input: EmptyBlockRootRollupInputs,
+  getBlockMergeRollupProof(
+    input: BlockMergeRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+    epochNumber?: EpochNumber,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, input, epochNumber),
-      ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP,
+      this.generateId(ProvingRequestType.BLOCK_MERGE_ROLLUP, input, epochNumber),
+      ProvingRequestType.BLOCK_MERGE_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
 
-  getMergeRollupProof(
-    input: MergeRollupInputs,
+  getCheckpointRootRollupProof(
+    input: CheckpointRootRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
+    epochNumber?: EpochNumber,
   ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.MERGE_ROLLUP, input, epochNumber),
-      ProvingRequestType.MERGE_ROLLUP,
+      this.generateId(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP, input, epochNumber),
+      ProvingRequestType.CHECKPOINT_ROOT_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
-  getPrivateBaseRollupProof(
-    baseRollupInput: PrivateBaseRollupInputs,
+
+  getCheckpointRootSingleBlockRollupProof(
+    input: CheckpointRootSingleBlockRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
+    epochNumber?: EpochNumber,
   ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.PRIVATE_BASE_ROLLUP, baseRollupInput, epochNumber),
-      ProvingRequestType.PRIVATE_BASE_ROLLUP,
-      baseRollupInput,
+      this.generateId(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP, input, epochNumber),
+      ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP,
+      input,
       epochNumber,
       signal,
     );
   }
 
-  getPublicBaseRollupProof(
-    inputs: PublicBaseRollupInputs,
+  getCheckpointPaddingRollupProof(
+    input: CheckpointPaddingRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
+    epochNumber?: EpochNumber,
   ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs, epochNumber),
-      ProvingRequestType.PUBLIC_BASE_ROLLUP,
-      inputs,
+      this.generateId(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP, input, epochNumber),
+      ProvingRequestType.CHECKPOINT_PADDING_ROLLUP,
+      input,
       epochNumber,
       signal,
     );
   }
 
-  getRootParityProof(
-    inputs: RootParityInputs,
+  getCheckpointMergeRollupProof(
+    input: CheckpointMergeRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
+    epochNumber?: EpochNumber,
+  ): Promise<
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.ROOT_PARITY, inputs, epochNumber),
-      ProvingRequestType.ROOT_PARITY,
-      inputs,
+      this.generateId(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP, input, epochNumber),
+      ProvingRequestType.CHECKPOINT_MERGE_ROLLUP,
+      input,
       epochNumber,
       signal,
     );
   }
 
   getRootRollupProof(
-    input: RootRollupInputs,
+    input: RootRollupPrivateInputs,
     signal?: AbortSignal,
-    epochNumber?: number,
+    epochNumber?: EpochNumber,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
     return this.enqueueJob(
       this.generateId(ProvingRequestType.ROOT_ROLLUP, input, epochNumber),
@@ -564,22 +652,12 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
     );
   }
 
-  getTubeProof(
-    tubeInput: TubeInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    return this.enqueueJob(
-      this.generateId(ProvingRequestType.TUBE_PROOF, tubeInput, epochNumber),
-      ProvingRequestType.TUBE_PROOF,
-      tubeInput,
-      epochNumber,
-      signal,
-    );
-  }
-
-  private generateId(type: ProvingRequestType, inputs: { toBuffer(): Buffer }, epochNumber = 0) {
-    const inputsHash = sha256(inputs.toBuffer());
-    return makeProvingJobId(epochNumber, type, inputsHash.toString('hex'));
+  private generateId(
+    type: ProvingRequestType,
+    inputs: { toBuffer(): Buffer },
+    epochNumber = EpochNumber.ZERO,
+  ): ProvingJobId {
+    const inputsHash = createHash('sha256').update(inputs.toBuffer()).digest('hex');
+    return makeProvingJobId(epochNumber, type, inputsHash);
   }
 }

package/src/proving_broker/config.ts

@@ -1,11 +1,14 @@
-import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
   getDefaultConfig,
   numberConfigHelper,
+  optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
-import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { pickConfigMappings } from '@aztec/foundation/config';
+import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 import { z } from 'zod';
@@ -20,18 +23,23 @@ export const ProverBrokerConfig = z.object({
   /** 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(),
+  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<DataStoreConfig, 'dataStoreMapSizeKb' | 'dataDirectory'> &
+  L1ReaderConfig &
+  Pick<ChainConfig, 'rollupVersion'>;
 
 export const proverBrokerConfigMappings: ConfigMappingsType<ProverBrokerConfig> = {
   proverBrokerJobTimeoutMs: {
@@ -64,8 +72,19 @@ export const proverBrokerConfigMappings: ConfigMappingsType<ProverBrokerConfig>
     description: 'The maximum number of epochs to keep results for',
     ...numberConfigHelper(1),
   },
-  ...l1ReaderConfigMappings,
+  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);
@@ -87,6 +106,12 @@ export const ProverAgentConfig = z.object({
   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>;
@@ -100,7 +125,7 @@ export const proverAgentConfigMappings: ConfigMappingsType<ProverAgentConfig> =
   proverAgentPollIntervalMs: {
     env: 'PROVER_AGENT_POLL_INTERVAL_MS',
     description: 'The interval agents poll for jobs at',
-    ...numberConfigHelper(100),
+    ...numberConfigHelper(1000),
   },
   proverAgentProofTypes: {
     env: 'PROVER_AGENT_PROOF_TYPES',
@@ -118,7 +143,7 @@ export const proverAgentConfigMappings: ConfigMappingsType<ProverAgentConfig> =
   realProofs: {
     env: 'PROVER_REAL_PROOFS',
     description: 'Whether to construct real proofs',
-    ...booleanConfigHelper(false),
+    ...booleanConfigHelper(true),
   },
   proverTestDelayType: {
     env: 'PROVER_TEST_DELAY_TYPE',
@@ -135,4 +160,20 @@ export const proverAgentConfigMappings: ConfigMappingsType<ProverAgentConfig> =
     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',
+  },
 };