@aztec/prover-client 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/prover-client/server-epoch-prover.ts

@@ -1,5 +1,6 @@
+import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import type { Fr } from '@aztec/foundation/fields';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type { EpochProver } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
 import type { RootRollupPublicInputs } from '@aztec/stdlib/rollup';
@@ -10,10 +11,18 @@ import type { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_
 
 /** Encapsulates the proving orchestrator and the broker facade */
 export class ServerEpochProver implements EpochProver {
-  constructor(private facade: BrokerCircuitProverFacade, private orchestrator: ProvingOrchestrator) {}
+  constructor(
+    private facade: BrokerCircuitProverFacade,
+    private orchestrator: ProvingOrchestrator,
+  ) {}
 
-  startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number): void {
-    this.orchestrator.startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks);
+  startNewEpoch(
+    epochNumber: number,
+    firstBlockNumber: number,
+    totalNumBlocks: number,
+    finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
+  ): void {
+    this.orchestrator.startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks, finalBlobBatchingChallenges);
     this.facade.start();
   }
   startTubeCircuits(txs: Tx[]): Promise<void> {
@@ -22,13 +31,13 @@ export class ServerEpochProver implements EpochProver {
   setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<L2Block> {
     return this.orchestrator.setBlockCompleted(blockNumber, expectedBlockHeader);
   }
-  finaliseEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof }> {
-    return this.orchestrator.finaliseEpoch();
+  finalizeEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof; batchedBlobInputs: BatchedBlob }> {
+    return this.orchestrator.finalizeEpoch();
   }
   cancel(): void {
     this.orchestrator.cancel();
   }
-  getProverId(): Fr {
+  getProverId(): EthAddress {
     return this.orchestrator.getProverId();
   }
   getBlock(index: number): L2Block {

package/src/proving_broker/broker_prover_facade.ts

@@ -1,11 +1,12 @@
 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 { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
 import { truncate } from '@aztec/foundation/string';
@@ -31,6 +32,7 @@ import type {
   BlockRootRollupInputs,
   EmptyBlockRootRollupInputs,
   MergeRollupInputs,
+  PaddingBlockRootRollupInputs,
   PrivateBaseRollupInputs,
   PublicBaseRollupInputs,
   RootRollupInputs,
@@ -93,7 +95,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));
@@ -125,27 +135,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 +164,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) {
@@ -399,16 +391,24 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
 
   getAvmProof(
     inputs: AvmCircuitInputs,
+    skipPublicInputsValidation?: boolean, // TODO(#14234)[Unconditional PIs validation]: remove this argument
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>> {
+  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+    this.log.info(`getAvmProof() called with skipPublicInputsValidation: ${skipPublicInputsValidation}`);
+
     return this.enqueueJob(
       this.generateId(ProvingRequestType.PUBLIC_VM, inputs, epochNumber),
       ProvingRequestType.PUBLIC_VM,
       inputs,
       epochNumber,
       signal,
-    );
+    ).then(result => {
+      // TODO(#14234)[Unconditional PIs validation]: Remove ".then()".
+      // Override the default value of skipPublicInputsValidation potentially set in BBNativeRollupProver.getAvmProof().
+      result.proof.proof[0] = skipPublicInputsValidation ? new Fr(1) : new Fr(0);
+      return result;
+    });
   }
 
   getBaseParityProof(
@@ -489,6 +489,22 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
     );
   }
 
+  getPaddingBlockRootRollupProof(
+    input: PaddingBlockRootRollupInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP, input, epochNumber),
+      ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP,
+      input,
+      epochNumber,
+      signal,
+    );
+  }
+
   getMergeRollupProof(
     input: MergeRollupInputs,
     signal?: AbortSignal,

package/src/proving_broker/config.ts

@@ -5,7 +5,9 @@ import {
   getDefaultConfig,
   numberConfigHelper,
 } from '@aztec/foundation/config';
+import { pickConfigMappings } from '@aztec/foundation/config';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 import { z } from 'zod';
@@ -20,7 +22,9 @@ 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 */
@@ -30,8 +34,9 @@ export const ProverBrokerConfig = z.object({
 });
 
 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 +69,14 @@ 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',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description: "The size of the prover broker's database. Will override the dataStoreMapSizeKb if set.",
+  },
   ...dataConfigMappings,
+  ...l1ReaderConfigMappings,
+  ...pickConfigMappings(chainConfigMappings, ['rollupVersion']),
 };
 
 export const defaultProverBrokerConfig: ProverBrokerConfig = getDefaultConfig(proverBrokerConfigMappings);
@@ -100,7 +111,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 +129,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',

package/src/proving_broker/factory.ts

@@ -6,9 +6,10 @@ import { InMemoryBrokerDatabase } from './proving_broker_database/memory.js';
 import { KVBrokerDatabase } from './proving_broker_database/persisted.js';
 
 export async function createAndStartProvingBroker(
-  config: ProverBrokerConfig,
+  _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);

package/src/proving_broker/proof_store/factory.ts

@@ -15,7 +15,7 @@ export function createProofStore(config: string | undefined, logger = createLogg
       const path = url.pathname.replace(/^\/+/, '');
       logger.info(`Creating google cloud proof store at ${bucket}`, { bucket, path });
       return new GoogleCloudStorageProofStore(bucket, path);
-    } catch (err) {
+    } catch {
       throw new Error(
         `Invalid google cloud proof store definition: '${config}'. Supported values are 'gs://bucket-name/path/to/store'.`,
       );

package/src/proving_broker/proof_store/gcs_proof_store.ts

@@ -16,10 +16,14 @@ import type { ProofStore } from './proof_store.js';
 
 const INPUTS_PATH = 'inputs';
 
+// REFACTOR(#13067): Use the stdlib/file-store instead of referencing google-cloud-storage directly.
 export class GoogleCloudStorageProofStore implements ProofStore {
   private readonly storage: Storage;
 
-  constructor(private readonly bucketName: string, private readonly path: string) {
+  constructor(
+    private readonly bucketName: string,
+    private readonly path: string,
+  ) {
     this.storage = new Storage();
   }
 

package/src/proving_broker/proof_store/inline_proof_store.ts

@@ -52,7 +52,7 @@ export class InlineProofStore implements ProofStore {
     return (PREFIX + SEPARATOR + encoded) as ProofUri;
   }
 
-  private decode<T>(uri: ProofUri, schema: ZodFor<T>): Promise<T> {
+  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);

package/src/proving_broker/proving_agent.ts

@@ -1,10 +1,11 @@
+import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { truncate } from '@aztec/foundation/string';
-import { Timer } from '@aztec/foundation/timer';
 import { ProvingError } from '@aztec/stdlib/errors';
 import type {
-  ProvingJob,
+  GetProvingJobResponse,
+  ProverAgentStatus,
   ProvingJobConsumer,
   ProvingJobId,
   ProvingJobInputs,
@@ -31,7 +32,6 @@ export class ProvingAgent implements Traceable {
   private currentJobController?: ProvingJobController;
   private runningPromise: RunningPromise;
   private instrumentation: ProvingAgentInstrumentation;
-  private idleTimer: Timer | undefined;
 
   public readonly tracer: Tracer;
 
@@ -64,7 +64,6 @@ export class ProvingAgent implements Traceable {
   }
 
   public start(): void {
-    this.idleTimer = new Timer();
     this.runningPromise.start();
   }
 
@@ -73,41 +72,78 @@ export class ProvingAgent implements Traceable {
     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' };
+  }
+
   @trackSpan('ProvingAgent.safeWork')
   private async work() {
-    // every tick we need to
-    // (1) either do a heartbeat, telling the broker that we're working
-    // (2) get a new job
-    // If during (1) the broker returns a new job that means we can cancel the current job and start the new one
-    let maybeJob: { job: ProvingJob; time: number } | undefined;
-    if (this.currentJobController?.getStatus() === ProvingJobControllerStatus.PROVING) {
-      maybeJob = await this.broker.reportProvingJobProgress(
-        this.currentJobController.getJobId(),
-        this.currentJobController.getStartedAt(),
-        { allowList: this.proofAllowList },
-      );
+    // 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) {
-      return;
-    }
-
-    if (this.idleTimer) {
-      this.instrumentation.recordIdleTime(this.idleTimer);
+    if (maybeJob) {
+      await this.startJob(maybeJob);
     }
-    this.idleTimer = undefined;
-
-    const { job, time } = maybeJob;
-    await this.startJob(job, time);
   }
 
-  private async startJob(job: ProvingJob, startedAt: number): Promise<void> {
+  private async startJob({ job, time: startedAt }: GetProvingJobResponse): Promise<void> {
     let abortedProofJobId: string | undefined;
     let abortedProofName: string | undefined;
 
-    if (this.currentJobController?.getStatus() === ProvingJobControllerStatus.PROVING) {
+    if (this.currentJobController?.getStatus() === ProvingJobControllerStatus.RUNNING) {
       abortedProofJobId = this.currentJobController.getJobId();
       abortedProofName = this.currentJobController.getProofTypeName();
       this.currentJobController?.abort();
@@ -116,13 +152,13 @@ export class ProvingAgent implements Traceable {
     let inputs: ProvingJobInputs;
     try {
       inputs = await this.proofStore.getProofInput(job.inputsUri);
-    } catch (err) {
+    } catch {
       const maybeJob = await this.broker.reportProvingJobError(job.id, 'Failed to load proof inputs', true, {
         allowList: this.proofAllowList,
       });
 
       if (maybeJob) {
-        return this.startJob(maybeJob.job, maybeJob.time);
+        return this.startJob(maybeJob);
       }
 
       return;
@@ -134,7 +170,11 @@ export class ProvingAgent implements Traceable {
       job.epochNumber,
       startedAt,
       this.circuitProver,
-      this.handleJobResult,
+      () => {
+        // 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();
+      },
     );
 
     if (abortedProofJobId) {
@@ -154,28 +194,30 @@ export class ProvingAgent implements Traceable {
     this.currentJobController.start();
   }
 
-  handleJobResult = async <T extends ProvingRequestType>(
+  private async reportResult<T extends ProvingRequestType>(
     jobId: ProvingJobId,
     type: T,
-    err: Error | undefined,
-    result: ProvingJobResultsMap[T] | undefined,
-  ) => {
-    let maybeJob: { job: ProvingJob; time: number } | undefined;
-    if (err) {
-      const retry = err.name === ProvingError.NAME ? (err as ProvingError).retry : false;
-      this.log.error(`Job id=${jobId} type=${ProvingRequestType[type]} failed err=${err.message} retry=${retry}`, err);
-      maybeJob = await this.broker.reportProvingJobError(jobId, err.message, retry, { allowList: this.proofAllowList });
-    } else if (result) {
+    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 });
     }
 
-    if (maybeJob) {
-      const { job, time } = maybeJob;
-      await this.startJob(job, time);
-    } else {
-      this.idleTimer = new Timer();
-    }
-  };
+    return maybeJob;
+  }
 }

package/src/proving_broker/proving_broker.ts

@@ -2,16 +2,17 @@ import { createLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
 import { PriorityMemoryQueue } from '@aztec/foundation/queue';
 import { Timer } from '@aztec/foundation/timer';
-import type {
-  GetProvingJobResponse,
-  ProofUri,
-  ProvingJob,
-  ProvingJobConsumer,
-  ProvingJobFilter,
-  ProvingJobId,
-  ProvingJobProducer,
-  ProvingJobSettledResult,
-  ProvingJobStatus,
+import {
+  type GetProvingJobResponse,
+  type ProofUri,
+  type ProvingJob,
+  type ProvingJobConsumer,
+  type ProvingJobFilter,
+  type ProvingJobId,
+  type ProvingJobProducer,
+  type ProvingJobSettledResult,
+  type ProvingJobStatus,
+  tryStop,
 } from '@aztec/stdlib/interfaces/server';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import {
@@ -54,6 +55,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Tr
     [ProvingRequestType.BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
     [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
     [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
 
     [ProvingRequestType.BASE_PARITY]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
     [ProvingRequestType.ROOT_PARITY]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
@@ -93,7 +95,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Tr
   /**
    * The broker keeps track of the highest epoch its seen.
    * This information is used for garbage collection: once it reaches the next epoch, it can start pruning the database of old state.
-   * It is important that this value is initialised to zero. This ensures that we don't delete any old jobs until the current
+   * It is important that this value is initialized to zero. This ensures that we don't delete any old jobs until the current
    * process instance receives a job request informing it of the actual current highest epoch
    * Example:
    * proving epoch 11 - the broker will wipe all jobs for epochs 9 and lower
@@ -184,7 +186,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Tr
       this.logger.warn('ProvingBroker not started');
       return Promise.resolve();
     }
-    await this.cleanupPromise.stop();
+    await tryStop(this.cleanupPromise);
   }
 
   public enqueueProvingJob(job: ProvingJob): Promise<ProvingJobStatus> {
@@ -313,7 +315,6 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Tr
     return Promise.resolve(notifications.concat(completedJobs));
   }
 
-  // eslint-disable-next-line require-await
   #getProvingJob(filter: ProvingJobFilter = { allowList: [] }): { job: ProvingJob; time: number } | undefined {
     const allowedProofs: ProvingRequestType[] =
       Array.isArray(filter.allowList) && filter.allowList.length > 0
@@ -571,7 +572,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Tr
 
     if (jobsToClean.length > 0) {
       this.cleanUpProvingJobState(jobsToClean);
-      this.logger.info(`Cleaned up jobs=${jobsToClean.length}`);
+      this.logger.verbose(`Cleaned up proving jobs=${jobsToClean.length}`);
     }
   }
 
@@ -671,7 +672,7 @@ function proofTypeComparator(a: ProvingRequestType, b: ProvingRequestType): -1 |
  * The aim is that this will speed up block proving as the closer we get to a block's root proof the more likely it
  * is to get picked up by agents
  */
-const PROOF_TYPES_IN_PRIORITY_ORDER: ProvingRequestType[] = [
+export const PROOF_TYPES_IN_PRIORITY_ORDER: ProvingRequestType[] = [
   ProvingRequestType.BLOCK_ROOT_ROLLUP,
   ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP,
   ProvingRequestType.BLOCK_MERGE_ROLLUP,

package/src/proving_broker/proving_broker_database/memory.ts

@@ -52,7 +52,7 @@ export class InMemoryBrokerDatabase implements ProvingBrokerDatabase {
   }
 
   async *allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]> {
-    for await (const item of this.jobs.values()) {
+    for (const item of this.jobs.values()) {
       yield [item, this.results.get(item.id)] as const;
     }
   }