@aztec/prover-client 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

package/src/orchestrator/chonk-cache.ts

@@ -0,0 +1,99 @@
+import type { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { PublicChonkVerifierPublicInputs } from '@aztec/stdlib/rollup';
+
+/** Result of a chonk-verifier proof, cached by tx hash. */
+export type ChonkVerifierProofResult = PublicInputsAndRecursiveProof<
+  PublicChonkVerifierPublicInputs,
+  typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+>;
+
+/**
+ * Shared cache of `getPublicChonkVerifierProof` results, keyed by tx hash.
+ *
+ * Owned by the prover-node and shared across every epoch / session: a tx remined into
+ * a different block (e.g. after a brief L1 reorg) reuses the already-computed chonk
+ * proof rather than redoing it. Entries are released via `releaseForBlocks` once the
+ * containing block is no longer interesting to the caller (e.g. its epoch's proof
+ * submission window has expired).
+ */
+export class ChonkCache {
+  private readonly cache = new Map<string, Promise<ChonkVerifierProofResult>>();
+  private readonly pending = new Map<string, AbortController>();
+  private readonly log: Logger;
+  private stopped = false;
+
+  constructor(bindings?: LoggerBindings) {
+    this.log = createLogger('prover-client:chonk-cache', bindings);
+  }
+
+  /** Returns the cached promise for `txHash`, or `undefined` if none is registered. */
+  public get(txHash: string): Promise<ChonkVerifierProofResult> | undefined {
+    return this.cache.get(txHash);
+  }
+
+  /**
+   * Atomic get-or-compute: returns the cached promise for `txHash`, or runs `factory`
+   * (passing an AbortSignal the cache controls) and caches its result. Concurrent
+   * callers for the same `txHash` share the same promise.
+   *
+   * Rejected promises are evicted so a future caller can retry. The factory's
+   * AbortSignal fires when the cache is stopped.
+   */
+  public getOrCompute(
+    txHash: string,
+    factory: (signal: AbortSignal) => Promise<ChonkVerifierProofResult>,
+  ): Promise<ChonkVerifierProofResult> {
+    if (this.stopped) {
+      return Promise.reject(new Error('ChonkCache is stopped'));
+    }
+    const existing = this.cache.get(txHash);
+    if (existing) {
+      return existing;
+    }
+    const controller = new AbortController();
+    this.pending.set(txHash, controller);
+    this.log.debug(`Enqueueing chonk-verifier circuit`, { txHash });
+    const promise = factory(controller.signal).finally(() => this.pending.delete(txHash));
+    // Silently observe the rejection branch and evict so a retry is possible.
+    promise.catch(err => {
+      this.cache.delete(txHash);
+      this.log.debug(`Chonk-verifier proof failed; evicted from cache`, { txHash, error: `${err}` });
+    });
+    this.cache.set(txHash, promise);
+    return promise;
+  }
+
+  /** Drops cache entries for every tx in the supplied blocks. */
+  public releaseForBlocks(blocks: L2Block[]): void {
+    let released = 0;
+    for (const block of blocks) {
+      for (const txEffect of block.body.txEffects) {
+        if (this.cache.delete(txEffect.txHash.toString())) {
+          released++;
+        }
+      }
+    }
+    if (released > 0) {
+      this.log.debug(`Released ${released} chonk-verifier cache entries`, {
+        blockCount: blocks.length,
+        releasedCount: released,
+      });
+    }
+  }
+
+  /** Aborts every in-flight chonk-verifier job and clears the cache. */
+  public stop(): void {
+    if (this.stopped) {
+      return;
+    }
+    this.stopped = true;
+    for (const controller of this.pending.values()) {
+      controller.abort();
+    }
+    this.pending.clear();
+    this.cache.clear();
+  }
+}

package/src/orchestrator/index.ts

@@ -1,6 +1,5 @@
-export { ProvingOrchestrator } from './orchestrator.js';
 export { CheckpointSubTreeOrchestrator, type SubTreeResult } from './checkpoint-sub-tree-orchestrator.js';
-export { EpochProvingContext, type ChonkVerifierProofResult } from './epoch-proving-context.js';
+export { ChonkCache, type ChonkVerifierProofResult } from './chonk-cache.js';
 export {
   TopTreeOrchestrator,
   TopTreeCancelledError,

package/src/orchestrator/proving-scheduler.ts

@@ -4,9 +4,9 @@ import { SerialQueue } from '@aztec/foundation/queue';
 import { sleep } from '@aztec/foundation/sleep';
 
 /**
- * Minimal surface a deferred-proving state must expose. Both `EpochProvingState` /
- * `CheckpointProvingState` / `BlockProvingState` (used by `ProvingOrchestrator`) and
- * `TopTreeProvingState` (used by `TopTreeOrchestrator`) satisfy it.
+ * Minimal surface a deferred-proving state must expose. Both `CheckpointProvingState` /
+ * `BlockProvingState` (used by `CheckpointSubTreeOrchestrator`) and `TopTreeProvingState`
+ * (used by `TopTreeOrchestrator`) satisfy it.
  */
 export interface ProvingStateLike {
   /** Returns false once the state has been cancelled or otherwise invalidated. */
@@ -19,7 +19,16 @@ export interface ProvingStateLike {
  * Common scheduling infrastructure shared by every orchestrator that drives broker
  * proving jobs:
  *
- *   - One `SerialQueue` (`deferredJobQueue`) acting as the enqueue-throttle.
+ *   - A shared `SerialQueue` (`deferredJobQueue`) that serialises the *act of handing a
+ *     job to the broker*, one initiation per event-loop tick. Each queue task kicks off
+ *     `safeJob` (which submits to the broker) without awaiting it, then yields with
+ *     `sleep(0)`; the next task therefore runs on the following macrotask. This does NOT
+ *     cap how many broker jobs are concurrently in flight — the broker's own queue absorbs
+ *     that. What it bounds is the burst rate: a sub-tree that synchronously discovers
+ *     thousands of ready jobs can't flood the broker (and monopolise the event loop) in a
+ *     single tick. The queue is owned by the `ProverClient` and shared across every
+ *     orchestrator (every sub-tree and top-tree across every concurrent epoch session), so
+ *     this pacing is applied once globally rather than once-per-orchestrator.
  *   - A list of `AbortController`s (`pendingProvingJobs`) so a `cancel()` can abort
  *     in-flight broker jobs when needed.
  *   - A `deferredProving<T>(state, request, callback, isCancelled?)` method that wraps
@@ -28,23 +37,20 @@ export interface ProvingStateLike {
  *
  * Subclasses own their own concrete proving state and define `cancelInternal()` for
  * the rest of the cleanup work (closing world-state forks, marking sub-trees
- * cancelled, etc.). `stop()` lives on the base class and follows the standard pattern
- * of grabbing the old queue, calling `cancelInternal()` (which recreates the queue),
- * and awaiting the old queue's drain.
+ * cancelled, etc.). Because the queue is shared, neither `cancel()` nor `stop()` touch
+ * it — they only abort this orchestrator's in-flight broker jobs. Queued-but-unrun jobs
+ * for a cancelled orchestrator no-op via the guards in `deferredProving`.
  */
 export abstract class ProvingScheduler {
   protected pendingProvingJobs: AbortController[] = [];
   protected logger: Logger;
-  private deferredJobQueue: SerialQueue;
 
   constructor(
-    private readonly enqueueConcurrency: number,
+    private readonly deferredJobQueue: SerialQueue,
     loggerName = 'prover-client:proving-scheduler',
     bindings?: LoggerBindings,
   ) {
     this.logger = createLogger(loggerName, bindings);
-    this.deferredJobQueue = new SerialQueue();
-    this.deferredJobQueue.start(this.enqueueConcurrency);
   }
 
   /** Number of broker jobs currently in flight. */
@@ -53,16 +59,14 @@ export abstract class ProvingScheduler {
   }
 
   /**
-   * Drains the deferred-job queue, recreates it (so the subclass can be reused), and
-   * optionally aborts every in-flight broker job. Aborting is the right choice on
+   * Optionally aborts every in-flight broker job. Aborting is the right choice on
    * reorg-driven cancel (where the in-flight inputs are no longer valid) and the
    * wrong choice on shutdown (where leaving jobs in the broker queue lets a restart
-   * pick them up).
+   * pick them up). The shared queue is not touched — queued-but-unrun jobs belonging
+   * to this orchestrator no-op once their controller is aborted (or once their state
+   * is marked invalid by the subclass).
    */
   protected resetSchedulerState(abortJobs: boolean): void {
-    void this.deferredJobQueue.cancel();
-    this.deferredJobQueue = new SerialQueue();
-    this.deferredJobQueue.start(this.enqueueConcurrency);
     if (abortJobs) {
       for (const controller of this.pendingProvingJobs) {
         controller.abort();
@@ -78,14 +82,12 @@ export abstract class ProvingScheduler {
   protected abstract cancelInternal(): void;
 
   /**
-   * Standard stop: grab the old queue, cancel (which recreates the queue), then
-   * await the old queue's drain so any final job tear-down has unwound before we
-   * return.
+   * Standard stop: cancel this orchestrator's work. The shared queue is owned by the
+   * `ProverClient` and outlives every orchestrator, so it is not drained here.
    */
-  public async stop(): Promise<void> {
-    const oldQueue = this.deferredJobQueue;
+  public stop(): Promise<void> {
     this.cancelInternal();
-    await oldQueue.cancel();
+    return Promise.resolve();
   }
 
   /**
@@ -147,9 +149,11 @@ export abstract class ProvingScheduler {
     };
 
     void this.deferredJobQueue.put(async () => {
+      // Kick off the broker submission without awaiting it — awaiting here would serialise all
+      // proving (one job at a time) and kill parallelism. The `sleep(0)` yields the event loop
+      // so the next queued job initiates on the following macrotask, pacing bursts rather than
+      // bounding in-flight broker concurrency (the broker's own queue handles that).
       void safeJob();
-      // Yield to the macrotask queue so Node has a chance to interleave other work
-      // between enqueues.
       await sleep(0);
     });
   }

package/src/orchestrator/top-tree-orchestrator.ts

@@ -13,8 +13,9 @@ import { BLS12Point } from '@aztec/foundation/curves/bls12';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LoggerBindings } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
+import type { SerialQueue } from '@aztec/foundation/queue';
 import type { Tuple } from '@aztec/foundation/serialize';
-import { MerkleTreeCalculator, shaMerkleHash } from '@aztec/foundation/trees';
+import { MerkleTreeCalculator, type TreeNodeLocation, shaMerkleHash } from '@aztec/foundation/trees';
 import type { EthAddress } from '@aztec/stdlib/block';
 import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
 import { computeCheckpointOutHash } from '@aztec/stdlib/messaging';
@@ -31,7 +32,7 @@ import type { BlockHeader } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { buildBlobHints, toProofData } from './block-building-helpers.js';
-import { TopTreeProvingScheduler } from './top-tree-proving-scheduler.js';
+import { ProvingScheduler } from './proving-scheduler.js';
 import { TopTreeProvingState } from './top-tree-proving-state.js';
 
 /** Per-checkpoint data fed into the top tree. */
@@ -86,18 +87,18 @@ type OutHashHint = {
  * and each checkpoint's root rollup fires the moment its sub-tree's `blockProofs`
  * promise resolves. Later checkpoints can still be block-level proving in parallel.
  */
-export class TopTreeOrchestrator extends TopTreeProvingScheduler {
+export class TopTreeOrchestrator extends ProvingScheduler {
   private state: TopTreeProvingState | undefined;
   private cancelled = false;
 
   constructor(
-    prover: ServerCircuitProver,
+    protected readonly prover: ServerCircuitProver,
     private readonly proverId: EthAddress,
-    enqueueConcurrency: number,
+    deferredJobQueue: SerialQueue,
     _telemetryClient: TelemetryClient = getTelemetryClient(),
     bindings?: LoggerBindings,
   ) {
-    super(prover, enqueueConcurrency, 'prover-client:top-tree-orchestrator', bindings);
+    super(deferredJobQueue, 'prover-client:top-tree-orchestrator', bindings);
   }
 
   public getProverId(): EthAddress {
@@ -133,10 +134,9 @@ export class TopTreeOrchestrator extends TopTreeProvingScheduler {
     }
 
     const { promise: completionPromise, resolve, reject } = promiseWithResolvers<void>();
-    // The completion promise is awaited inside the try/catch below. Attach a no-op catch
-    // here as well so any spurious unhandled-rejection detection during cancellation
-    // (where reject() can fire synchronously before the await microtask installs a handler)
-    // is silenced.
+    // The completion promise is awaited below. Attach a no-op catch here as well so any
+    // spurious unhandled-rejection detection during cancellation (where reject() can fire
+    // synchronously before the await microtask installs a handler) is silenced.
     completionPromise.catch(() => {});
     const startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(finalBlobBatchingChallenges);
 
@@ -189,16 +189,13 @@ export class TopTreeOrchestrator extends TopTreeProvingScheduler {
       );
     }
 
-    try {
-      await completionPromise;
-      await this.state.finalizeBatchedBlob();
-      return this.state.getEpochProofResult();
-    } catch (err: any) {
-      if (this.cancelled) {
-        throw new TopTreeCancelledError();
-      }
-      throw err;
-    }
+    // The error type is stamped atomically at rejection time by the rejectionCallback above
+    // (TopTreeCancelledError iff cancel() drove the rejection). Re-deriving it here from the
+    // live `cancelled` flag would mask a genuine failure that lost a race with a late cancel
+    // (A-1035), so let the original error propagate untouched.
+    await completionPromise;
+    await this.state.finalizeBatchedBlob();
+    return this.state.getEpochProofResult();
   }
 
   /**
@@ -220,10 +217,6 @@ export class TopTreeOrchestrator extends TopTreeProvingScheduler {
 
   // --- internal: per-checkpoint enqueue path ---
 
-  protected override onRootRollupComplete(state: TopTreeProvingState) {
-    state.resolve();
-  }
-
   private enqueueCheckpointRoot(
     state: TopTreeProvingState,
     checkpointIndex: number,
@@ -235,26 +228,36 @@ export class TopTreeOrchestrator extends TopTreeProvingScheduler {
     outHashHint: OutHashHint,
     startBlobAccumulator: BatchedBlobAccumulator,
   ) {
-    void this.buildCheckpointRootInputs(blockProofs, cd, outHashHint, startBlobAccumulator).then(inputs => {
-      this.deferredProving(
-        state,
-        signal => {
-          if (inputs instanceof CheckpointRootSingleBlockRollupPrivateInputs) {
-            return this.prover.getCheckpointRootSingleBlockRollupProof(inputs, signal, state.epochNumber);
-          }
-          return this.prover.getCheckpointRootRollupProof(inputs, signal, state.epochNumber);
-        },
-        result => {
-          this.logger.debug(`Completed checkpoint root proof for checkpoint ${checkpointIndex}`);
-          const leafLocation = state.setCheckpointRootRollupProof(checkpointIndex, result);
-          if (state.totalNumCheckpoints === 1) {
-            this.enqueueEpochPadding(state);
-          } else {
-            this.checkAndEnqueueNextCheckpointMergeRollup(state, leafLocation);
-          }
-        },
-      );
-    });
+    void this.buildCheckpointRootInputs(blockProofs, cd, outHashHint, startBlobAccumulator).then(
+      inputs => {
+        this.deferredProving(
+          state,
+          signal => {
+            if (inputs instanceof CheckpointRootSingleBlockRollupPrivateInputs) {
+              return this.prover.getCheckpointRootSingleBlockRollupProof(inputs, signal, state.epochNumber);
+            }
+            return this.prover.getCheckpointRootRollupProof(inputs, signal, state.epochNumber);
+          },
+          result => {
+            this.logger.debug(`Completed checkpoint root proof for checkpoint ${checkpointIndex}`);
+            const leafLocation = state.setCheckpointRootRollupProof(checkpointIndex, result);
+            if (state.totalNumCheckpoints === 1) {
+              this.enqueueEpochPadding(state);
+            } else {
+              this.checkAndEnqueueNextCheckpointMergeRollup(state, leafLocation);
+            }
+          },
+        );
+      },
+      // Without this, an input-building failure rejects a discarded promise, state.reject() is
+      // never called, and prove() hangs forever on its completion promise (A-1036).
+      err => {
+        if (this.cancelled) {
+          return;
+        }
+        state.reject(`Building checkpoint root inputs for checkpoint ${checkpointIndex} failed: ${err}`);
+      },
+    );
   }
 
   private async buildCheckpointRootInputs(
@@ -286,6 +289,73 @@ export class TopTreeOrchestrator extends TopTreeProvingScheduler {
       : new CheckpointRootRollupPrivateInputs([proofDatas[0], proofDatas[1]], hints);
   }
 
+  // --- internal: top-tree proof orchestration (formerly TopTreeProvingScheduler) ---
+
+  private enqueueCheckpointMergeRollup(state: TopTreeProvingState, location: TreeNodeLocation) {
+    if (!state.verifyState() || !state.tryStartProvingCheckpointMerge(location)) {
+      return;
+    }
+    const inputs = state.getCheckpointMergeRollupInputs(location);
+    this.deferredProving(
+      state,
+      signal => this.prover.getCheckpointMergeRollupProof(inputs, signal, state.epochNumber),
+      result => {
+        state.setCheckpointMergeRollupProof(location, result);
+        this.checkAndEnqueueNextCheckpointMergeRollup(state, location);
+      },
+    );
+  }
+
+  private enqueueEpochPadding(state: TopTreeProvingState) {
+    if (!state.verifyState() || !state.tryStartProvingPaddingCheckpoint()) {
+      return;
+    }
+    const inputs = state.getPaddingCheckpointInputs();
+    this.deferredProving(
+      state,
+      signal => this.prover.getCheckpointPaddingRollupProof(inputs, signal, state.epochNumber),
+      result => {
+        state.setCheckpointPaddingProof(result);
+        this.checkAndEnqueueRootRollup(state);
+      },
+    );
+  }
+
+  private enqueueRootRollup(state: TopTreeProvingState) {
+    if (!state.verifyState() || !state.tryStartProvingRootRollup()) {
+      return;
+    }
+    const inputs = state.getRootRollupInputs();
+    this.deferredProving(
+      state,
+      signal => this.prover.getRootRollupProof(inputs, signal, state.epochNumber),
+      result => {
+        this.logger.verbose(`Completed root rollup for epoch ${state.epochNumber}`);
+        state.setRootRollupProof(result);
+        state.resolve();
+      },
+    );
+  }
+
+  private checkAndEnqueueNextCheckpointMergeRollup(state: TopTreeProvingState, currentLocation: TreeNodeLocation) {
+    if (!state.isReadyForCheckpointMerge(currentLocation)) {
+      return;
+    }
+    const parentLocation = state.getParentLocation(currentLocation);
+    if (parentLocation.level === 0) {
+      this.checkAndEnqueueRootRollup(state);
+    } else {
+      this.enqueueCheckpointMergeRollup(state, parentLocation);
+    }
+  }
+
+  private checkAndEnqueueRootRollup(state: TopTreeProvingState) {
+    if (!state.isReadyForRootRollup()) {
+      return;
+    }
+    this.enqueueRootRollup(state);
+  }
+
   private async computeOutHashHints(checkpointData: CheckpointTopTreeData[]): Promise<OutHashHint[]> {
     const treeCalculator = await MerkleTreeCalculator.create(OUT_HASH_TREE_HEIGHT, undefined, (left, right) =>
       Promise.resolve(shaMerkleHash(left, right)),

package/src/orchestrator/top-tree-proving-state.ts

@@ -41,7 +41,6 @@ export class TopTreeProvingState {
   private endBlobAccumulator: BatchedBlobAccumulator | undefined;
   private finalBatchedBlob: BatchedBlob | undefined;
   private lifecycle = TOP_TREE_LIFECYCLE.CREATED;
-
   constructor(
     public readonly epochNumber: EpochNumber,
     public readonly totalNumCheckpoints: number,

package/src/orchestrator/tx-proving-state.ts

@@ -1,4 +1,4 @@
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
@@ -32,7 +32,7 @@ export class TxProvingState {
     PublicChonkVerifierPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  private avmProof?: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
+  private avmProof?: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>;
 
   constructor(
     public readonly processedTx: ProcessedTx,
@@ -80,7 +80,7 @@ export class TxProvingState {
     this.publicChonkVerifier = publicChonkVerifierProofAndVk;
   }
 
-  public setAvmProof(avmProof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>) {
+  public setAvmProof(avmProof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>) {
     this.avmProof = avmProof;
   }
 

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

@@ -4,10 +4,10 @@ import { times } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
 import { NativeACVMSimulator } from '@aztec/simulator/server';
 import {
   type ActualProverConfig,
-  type EpochProver,
   type EpochProverManager,
   type ForkMerkleTreeOperations,
   type ProvingJobBroker,
@@ -23,13 +23,11 @@ import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-clien
 
 import type { ProverClientConfig } from '../config.js';
 import { CheckpointSubTreeOrchestrator } from '../orchestrator/checkpoint-sub-tree-orchestrator.js';
-import { EpochProvingContext } from '../orchestrator/epoch-proving-context.js';
-import { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
+import type { ChonkCache } from '../orchestrator/chonk-cache.js';
 import { TopTreeOrchestrator } from '../orchestrator/top-tree-orchestrator.js';
 import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
 import { InlineProofStore, type ProofStore, createProofStore } from '../proving_broker/proof_store/index.js';
 import { ProvingAgent } from '../proving_broker/proving_agent.js';
-import { ServerEpochProver } from './server-epoch-prover.js';
 
 /**
  * The factory surface that `EpochProvingJob` (in `prover-node`) depends on. Implemented
@@ -49,14 +47,13 @@ import { ServerEpochProver } from './server-epoch-prover.js';
 export interface EpochProverFactory {
   getProverId(): EthAddress;
   /**
-   * Constructs a per-epoch shared context for the caching of e.g. chonk verifier results
-   */
-  createEpochProvingContext(epochNumber: EpochNumber): EpochProvingContext;
-  /**
-   * Constructs and starts a `CheckpointSubTreeOrchestrator` for a single checkpoint.
+   * Constructs and starts a `CheckpointSubTreeOrchestrator` for a single checkpoint
+   * against the supplied shared `chonkCache`. The cache is owned by the prover-node
+   * and survives across epochs / sessions.
    */
   createCheckpointSubTreeOrchestrator(
-    epochContext: EpochProvingContext,
+    chonkCache: ChonkCache,
+    epochNumber: EpochNumber,
     checkpointConstants: CheckpointConstantData,
     l1ToL2Messages: Fr[],
     totalNumBlocks: number,
@@ -75,6 +72,13 @@ export class ProverClient implements EpochProverManager, EpochProverFactory {
    * `EpochProverFactory` for why a single shared facade is required.
    */
   private facade: BrokerCircuitProverFacade | undefined;
+  /**
+   * Single deferred-proving-job queue shared across every orchestrator (sub-trees and
+   * top-trees, across every concurrent epoch session). Throttles the total rate of job
+   * submission to the broker once, rather than once per orchestrator. Started lazily
+   * alongside the facade and cancelled on `stop()`.
+   */
+  private deferredJobQueue: SerialQueue | undefined;
 
   private constructor(
     private config: ProverClientConfig,
@@ -112,40 +116,21 @@ export class ProverClient implements EpochProverManager, EpochProverFactory {
     return this.facade;
   }
 
-  /**
-   * Legacy single-class epoch prover. Each call constructs its own
-   * `BrokerCircuitProverFacade`; the new factory methods (`createCheckpointSubTreeOrchestrator`,
-   * `createTopTreeOrchestrator`, `createEpochProvingContext`) share a single facade
-   * owned by `ProverClient`. Both APIs coexist while the prover-node migrates onto
-   * the new pair.
-   */
-  public createEpochProver(): EpochProver {
-    const bindings = this.log.getBindings();
-    const facade = new BrokerCircuitProverFacade(
-      this.orchestratorClient,
-      this.proofStore,
-      this.failedProofStore,
-      undefined,
-      bindings,
-    );
-    const orchestrator = new ProvingOrchestrator(
-      this.worldState,
-      facade,
-      this.config.proverId,
-      this.config.cancelJobsOnStop,
-      this.config.enqueueConcurrency,
-      this.telemetry,
-      bindings,
-    );
-    return new ServerEpochProver(facade, orchestrator);
-  }
-
-  public createEpochProvingContext(epochNumber: EpochNumber): EpochProvingContext {
-    return new EpochProvingContext(this.getFacade(), epochNumber, this.log.getBindings());
+  /** Lazy-init the shared deferred-job queue, started with the configured enqueue concurrency. */
+  private getDeferredJobQueue(): SerialQueue {
+    if (!this.running) {
+      throw new Error('ProverClient is not running; call start() before constructing orchestrators.');
+    }
+    if (!this.deferredJobQueue) {
+      this.deferredJobQueue = new SerialQueue();
+      this.deferredJobQueue.start(this.config.enqueueConcurrency);
+    }
+    return this.deferredJobQueue;
   }
 
   public createCheckpointSubTreeOrchestrator(
-    epochContext: EpochProvingContext,
+    chonkCache: ChonkCache,
+    epochNumber: EpochNumber,
     checkpointConstants: CheckpointConstantData,
     l1ToL2Messages: Fr[],
     totalNumBlocks: number,
@@ -155,9 +140,10 @@ export class ProverClient implements EpochProverManager, EpochProverFactory {
       this.worldState,
       this.getFacade(),
       this.config.proverId,
-      epochContext,
+      chonkCache,
+      epochNumber,
       this.config.cancelJobsOnStop,
-      this.config.enqueueConcurrency,
+      this.getDeferredJobQueue(),
       checkpointConstants,
       l1ToL2Messages,
       totalNumBlocks,
@@ -171,7 +157,7 @@ export class ProverClient implements EpochProverManager, EpochProverFactory {
     return new TopTreeOrchestrator(
       this.getFacade(),
       this.config.proverId,
-      this.config.enqueueConcurrency,
+      this.getDeferredJobQueue(),
       this.telemetry,
       this.log.getBindings(),
     );
@@ -216,12 +202,12 @@ export class ProverClient implements EpochProverManager, EpochProverFactory {
     }
     this.running = false;
     await this.stopAgents();
+    if (this.deferredJobQueue) {
+      await this.deferredJobQueue.cancel();
+      this.deferredJobQueue = undefined;
+    }
     if (this.facade) {
-      try {
-        await this.facade.stop();
-      } catch (err) {
-        this.log.error('Error stopping shared broker facade', err);
-      }
+      await tryStop(this.facade, this.log);
       this.facade = undefined;
     }
     await tryStop(this.orchestratorClient);

package/src/proving_broker/broker_prover_facade.ts

@@ -1,5 +1,5 @@
 import type {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -394,7 +394,7 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
     inputs: AvmCircuitInputs,
     signal?: AbortSignal,
     epochNumber?: EpochNumber,
-  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>> {
     return this.enqueueJob(
       this.generateId(ProvingRequestType.PUBLIC_VM, inputs, epochNumber),
       ProvingRequestType.PUBLIC_VM,