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

package/dest/orchestrator/epoch-proving-context.d.ts

@@ -0,0 +1,51 @@
+import type { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
+import { type LoggerBindings } from '@aztec/foundation/log';
+import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { PublicChonkVerifierPrivateInputs, PublicChonkVerifierPublicInputs } from '@aztec/stdlib/rollup';
+/**
+ * Result of a chonk-verifier proof, cached per tx hash on `EpochProvingContext`.
+ */
+export type ChonkVerifierProofResult = PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+/**
+ * Per-epoch state shared across every `CheckpointSubTreeOrchestrator` constructed for
+ * the same epoch. Owns the chonk-verifier proof cache so a tx whose checkpoint is
+ * reorged out and re-appears in a replacement checkpoint does not have to re-prove
+ * its chonk circuit.
+ *
+ * The context's chonk-verifier broker jobs are deliberately submitted **outside** the
+ * sub-tree's deferred-proving queue. The sub-tree's `cancel()` therefore does not abort
+ * them — by design, because their result is tx-scoped, not sub-tree-scoped, and a
+ * replacement sub-tree should be able to consume the cached proof.
+ *
+ * Callers (`EpochProvingJob`, or unit tests) construct one context per epoch and pass
+ * it into every sub-tree they create. `stop()` aborts every in-flight chonk job.
+ */
+export declare class EpochProvingContext {
+    private readonly prover;
+    readonly epochNumber: EpochNumber;
+    private readonly cache;
+    /** Abort controllers for in-flight chonk jobs, keyed by tx hash. */
+    private readonly pending;
+    private readonly log;
+    private stopped;
+    constructor(prover: ServerCircuitProver, epochNumber: EpochNumber, bindings?: LoggerBindings);
+    /**
+     * Returns the cached chonk-verifier proof promise for the given tx hash, or
+     * `undefined` if none has been enqueued yet. Non-mutating.
+     */
+    getCached(txHash: string): Promise<ChonkVerifierProofResult> | undefined;
+    /**
+     * Enqueues a chonk-verifier proof for the given tx hash, returning the promise (or
+     * the already-cached one if already enqueued). The promise resolves when the broker
+     * delivers the result; on rejection (including `stop()`), the cache entry is removed
+     * so a subsequent caller can re-enqueue.
+     */
+    enqueue(txHash: string, inputs: PublicChonkVerifierPrivateInputs): Promise<ChonkVerifierProofResult>;
+    /**
+     * Aborts every in-flight chonk-verifier broker job and clears the cache. Called by
+     * the owning `EpochProvingJob` when the job stops.
+     */
+    stop(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2gtcHJvdmluZy1jb250ZXh0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3JjaGVzdHJhdG9yL2Vwb2NoLXByb3ZpbmctY29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSx5Q0FBeUMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2xGLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RixPQUFPLEtBQUssRUFBRSw2QkFBNkIsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzFHLE9BQU8sS0FBSyxFQUFFLGdDQUFnQyxFQUFFLCtCQUErQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFOUc7O0dBRUc7QUFDSCxNQUFNLE1BQU0sd0JBQXdCLEdBQUcsNkJBQTZCLENBQ2xFLCtCQUErQixFQUMvQixPQUFPLHlDQUF5QyxDQUNqRCxDQUFDO0FBRUY7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNILHFCQUFhLG1CQUFtQjtJQVE1QixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07YUFDUCxXQUFXLEVBQUUsV0FBVztJQVIxQyxPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBd0Q7SUFDOUUsb0VBQW9FO0lBQ3BFLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFzQztJQUM5RCxPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBUztJQUM3QixPQUFPLENBQUMsT0FBTyxDQUFTO0lBRXhCLFlBQ21CLE1BQU0sRUFBRSxtQkFBbUIsRUFDNUIsV0FBVyxFQUFFLFdBQVcsRUFDeEMsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUcxQjtJQUVEOzs7T0FHRztJQUNJLFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyx3QkFBd0IsQ0FBQyxHQUFHLFNBQVMsQ0FFOUU7SUFFRDs7Ozs7T0FLRztJQUNJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxnQ0FBZ0MsR0FBRyxPQUFPLENBQUMsd0JBQXdCLENBQUMsQ0E2QjFHO0lBRUQ7OztPQUdHO0lBQ0ksSUFBSSxTQU9WO0NBQ0YifQ==

package/dest/orchestrator/epoch-proving-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch-proving-context.d.ts","sourceRoot":"","sources":["../../src/orchestrator/epoch-proving-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC1G,OAAO,KAAK,EAAE,gCAAgC,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAE9G;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,6BAA6B,CAClE,+BAA+B,EAC/B,OAAO,yCAAyC,CACjD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,qBAAa,mBAAmB;IAQ5B,OAAO,CAAC,QAAQ,CAAC,MAAM;aACP,WAAW,EAAE,WAAW;IAR1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwD;IAC9E,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAC9D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;IAExB,YACmB,MAAM,EAAE,mBAAmB,EAC5B,WAAW,EAAE,WAAW,EACxC,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED;;;OAGG;IACI,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC,GAAG,SAAS,CAE9E;IAED;;;;;OAKG;IACI,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gCAAgC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CA6B1G;IAED;;;OAGG;IACI,IAAI,SAOV;CACF"}

package/dest/orchestrator/epoch-proving-context.js

@@ -0,0 +1,81 @@
+import { createLogger } from '@aztec/foundation/log';
+/**
+ * Per-epoch state shared across every `CheckpointSubTreeOrchestrator` constructed for
+ * the same epoch. Owns the chonk-verifier proof cache so a tx whose checkpoint is
+ * reorged out and re-appears in a replacement checkpoint does not have to re-prove
+ * its chonk circuit.
+ *
+ * The context's chonk-verifier broker jobs are deliberately submitted **outside** the
+ * sub-tree's deferred-proving queue. The sub-tree's `cancel()` therefore does not abort
+ * them — by design, because their result is tx-scoped, not sub-tree-scoped, and a
+ * replacement sub-tree should be able to consume the cached proof.
+ *
+ * Callers (`EpochProvingJob`, or unit tests) construct one context per epoch and pass
+ * it into every sub-tree they create. `stop()` aborts every in-flight chonk job.
+ */ export class EpochProvingContext {
+    prover;
+    epochNumber;
+    cache;
+    /** Abort controllers for in-flight chonk jobs, keyed by tx hash. */ pending;
+    log;
+    stopped;
+    constructor(prover, epochNumber, bindings){
+        this.prover = prover;
+        this.epochNumber = epochNumber;
+        this.cache = new Map();
+        this.pending = new Map();
+        this.stopped = false;
+        this.log = createLogger('prover-client:epoch-proving-context', bindings);
+    }
+    /**
+   * Returns the cached chonk-verifier proof promise for the given tx hash, or
+   * `undefined` if none has been enqueued yet. Non-mutating.
+   */ getCached(txHash) {
+        return this.cache.get(txHash);
+    }
+    /**
+   * Enqueues a chonk-verifier proof for the given tx hash, returning the promise (or
+   * the already-cached one if already enqueued). The promise resolves when the broker
+   * delivers the result; on rejection (including `stop()`), the cache entry is removed
+   * so a subsequent caller can re-enqueue.
+   */ enqueue(txHash, inputs) {
+        if (this.stopped) {
+            return Promise.reject(new Error('EpochProvingContext is stopped'));
+        }
+        const cached = this.cache.get(txHash);
+        if (cached) {
+            return cached;
+        }
+        const controller = new AbortController();
+        this.pending.set(txHash, controller);
+        this.log.debug(`Enqueueing chonk-verifier circuit`, {
+            txHash,
+            epochNumber: this.epochNumber
+        });
+        const promise = this.prover.getPublicChonkVerifierProof(inputs, controller.signal, this.epochNumber).finally(()=>this.pending.delete(txHash));
+        // Self-clean on rejection so a future caller can re-enqueue. Mark the rejection
+        // path as observed to silence unhandled-rejection warnings when no consumer
+        // awaits the promise (e.g. when the only `.then` chain belonged to a cancelled
+        // sub-tree's tx-proving state).
+        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;
+    }
+    /**
+   * Aborts every in-flight chonk-verifier broker job and clears the cache. Called by
+   * the owning `EpochProvingJob` when the job stops.
+   */ stop() {
+        this.stopped = true;
+        for (const controller of this.pending.values()){
+            controller.abort();
+        }
+        this.pending.clear();
+        this.cache.clear();
+    }
+}

package/dest/orchestrator/epoch-proving-state.d.ts

@@ -39,7 +39,7 @@ export declare class EpochProvingState {
     private endBlobAccumulator;
     private finalBatchedBlob;
     private provingStateLifecycle;
-    readonly cachedChonkVerifierProofs: Map<string, Promise<PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, 519>>>;
+    readonly cachedChonkVerifierProofs: Map<string, Promise<PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, 480>>>;
     constructor(epochNumber: EpochNumber, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, onCheckpointBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => Promise<void>, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
     startNewCheckpoint(checkpointIndex: number, constants: CheckpointConstantData, totalNumBlocks: number, previousBlockHeader: BlockHeader, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, l1ToL2Messages: Fr[], lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>): CheckpointProvingState;
     getCheckpointProvingState(index: number): CheckpointProvingState | undefined;

package/dest/orchestrator/index.d.ts

@@ -1,2 +1,5 @@
 export { ProvingOrchestrator } from './orchestrator.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sbUJBQW1CLENBQUMifQ==
+export { CheckpointSubTreeOrchestrator, type SubTreeResult } from './checkpoint-sub-tree-orchestrator.js';
+export { EpochProvingContext, type ChonkVerifierProofResult } from './epoch-proving-context.js';
+export { TopTreeOrchestrator, TopTreeCancelledError, type CheckpointTopTreeData, type TopTreeResult, } from './top-tree-orchestrator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDeEQsT0FBTyxFQUFFLDZCQUE2QixFQUFFLEtBQUssYUFBYSxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDMUcsT0FBTyxFQUFFLG1CQUFtQixFQUFFLEtBQUssd0JBQXdCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNoRyxPQUFPLEVBQ0wsbUJBQW1CLEVBQ25CLHFCQUFxQixFQUNyQixLQUFLLHFCQUFxQixFQUMxQixLQUFLLGFBQWEsR0FDbkIsTUFBTSw0QkFBNEIsQ0FBQyJ9

package/dest/orchestrator/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/orchestrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/orchestrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,6BAA6B,EAAE,KAAK,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAC1G,OAAO,EAAE,mBAAmB,EAAE,KAAK,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAChG,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,GACnB,MAAM,4BAA4B,CAAC"}

package/dest/orchestrator/index.js

@@ -1 +1,4 @@
 export { ProvingOrchestrator } from './orchestrator.js';
+export { CheckpointSubTreeOrchestrator } from './checkpoint-sub-tree-orchestrator.js';
+export { EpochProvingContext } from './epoch-proving-context.js';
+export { TopTreeOrchestrator, TopTreeCancelledError } from './top-tree-orchestrator.js';

package/dest/orchestrator/orchestrator.d.ts

@@ -1,7 +1,7 @@
 import { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
 import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type LoggerBindings } from '@aztec/foundation/log';
+import type { LoggerBindings } from '@aztec/foundation/log';
 import { EthAddress } from '@aztec/stdlib/block';
 import type { EpochProver, ForkMerkleTreeOperations, ReadonlyWorldStateAccess, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
@@ -10,6 +10,9 @@ import type { BlockHeader, ProcessedTx, Tx } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
 import type { BlockProvingState } from './block-proving-state.js';
+import type { CheckpointProvingState } from './checkpoint-proving-state.js';
+import { EpochProvingState, type ProvingResult } from './epoch-proving-state.js';
+import { TopTreeProvingScheduler } from './top-tree-proving-scheduler.js';
 /**
  * Implements an event driven proving scheduler to build the recursive proof tree. The idea being:
  * 1. Transactions are provided to the scheduler post simulation.
@@ -23,24 +26,21 @@ import type { BlockProvingState } from './block-proving-state.js';
 /**
  * The orchestrator, managing the flow of recursive proving operations required to build the rollup proof tree.
  */
-export declare class ProvingOrchestrator implements EpochProver {
+export declare class ProvingOrchestrator extends TopTreeProvingScheduler implements EpochProver {
     private dbProvider;
-    private prover;
     private readonly proverId;
     private readonly cancelJobsOnStop;
-    private readonly enqueueConcurrency;
-    private provingState;
-    private pendingProvingJobs;
-    private provingPromise;
+    protected provingState: EpochProvingState | undefined;
+    protected provingPromise: Promise<ProvingResult> | undefined;
     private metrics;
     private dbs;
-    private logger;
-    private deferredJobQueue;
     constructor(dbProvider: ReadonlyWorldStateAccess & ForkMerkleTreeOperations, prover: ServerCircuitProver, proverId: EthAddress, cancelJobsOnStop: boolean | undefined, enqueueConcurrency: number, telemetryClient?: TelemetryClient, bindings?: LoggerBindings);
     get tracer(): Tracer;
     getProverId(): EthAddress;
     getNumActiveForks(): number;
-    stop(): Promise<void>;
+    protected cancelInternal(): void;
+    protected wrapCircuitCall<T>(circuitName: string, fn: (signal: AbortSignal) => Promise<T>): (signal: AbortSignal) => Promise<T>;
+    protected onRootRollupComplete(state: EpochProvingState): void;
     startNewEpoch(epochNumber: EpochNumber, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges): void;
     /**
      * Starts a new checkpoint.
@@ -90,17 +90,10 @@ export declare class ProvingOrchestrator implements EpochProver {
         proof: Proof;
         batchedBlobInputs: BatchedBlob;
     }>;
-    /**
-     * Enqueue a job to be scheduled
-     * @param provingState - The proving state object being operated on
-     * @param jobType - The type of job to be queued
-     * @param job - The actual job, returns a promise notifying of the job's completion
-     */
-    private deferredProving;
     private updateL1ToL2MessageTree;
     private prepareBaseRollupInputs;
     private enqueueBaseRollup;
-    private getOrEnqueueChonkVerifier;
+    protected getOrEnqueueChonkVerifier(provingState: BlockProvingState, txIndex: number): void;
     private doEnqueueChonkVerifier;
     private enqueueMergeRollup;
     private enqueueBlockRootRollup;
@@ -109,15 +102,10 @@ export declare class ProvingOrchestrator implements EpochProver {
     private enqueueRootParityCircuit;
     private enqueueBlockMergeRollup;
     private enqueueCheckpointRootRollup;
-    private enqueueCheckpointMergeRollup;
-    private enqueueEpochPadding;
-    private enqueueRootRollup;
     private checkAndEnqueueNextMergeRollup;
     private checkAndEnqueueBlockRootRollup;
     private checkAndEnqueueNextBlockMergeRollup;
-    private checkAndEnqueueCheckpointRootRollup;
-    private checkAndEnqueueNextCheckpointMergeRollup;
-    private checkAndEnqueueRootRollup;
+    protected checkAndEnqueueCheckpointRootRollup(provingState: CheckpointProvingState): Promise<void>;
     /**
      * Executes the VM circuit for a public function, will enqueue the corresponding kernel if the
      * previous kernel is ready
@@ -125,6 +113,6 @@ export declare class ProvingOrchestrator implements EpochProver {
      * @param txIndex - The index of the transaction being proven
      */
     private enqueueVM;
-    private checkAndEnqueueBaseRollup;
+    protected checkAndEnqueueBaseRollup(provingState: BlockProvingState, txIndex: number): void;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/orchestrator/orchestrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"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"}

package/dest/orchestrator/orchestrator.js

@@ -371,18 +371,13 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
 var _dec, _dec1, _dec2, _dec3, _dec4, _initProto;
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
+import { L1_TO_L2_MSG_SUBTREE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { AbortError } from '@aztec/foundation/error';
-import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { SerialQueue } from '@aztec/foundation/queue';
 import { assertLength } from '@aztec/foundation/serialize';
-import { sleep } from '@aztec/foundation/sleep';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
+import { appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging';
 import { BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, CheckpointRootSingleBlockRollupPrivateInputs, PrivateTxBaseRollupPrivateInputs } from '@aztec/stdlib/rollup';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { Attributes, getTelemetryClient, trackSpan, wrapCallbackInSpan } from '@aztec/telemetry-client';
@@ -390,6 +385,7 @@ import { inspect } from 'util';
 import { buildHeaderFromCircuitOutputs, getLastSiblingPath, getPublicChonkVerifierPrivateInputsFromTx, getRootTreeSiblingPath, getSubtreeSiblingPath, getTreeSnapshot, insertSideEffectsAndBuildBaseRollupHints, validatePartialState, validateTx } from './block-building-helpers.js';
 import { EpochProvingState } from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
+import { TopTreeProvingScheduler } from './top-tree-proving-scheduler.js';
 import { TxProvingState } from './tx-proving-state.js';
 _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         [Attributes.BLOCK_NUMBER]: blockNumber
@@ -411,12 +407,10 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
  * The proving implementation is determined by the provided prover. This could be for example a local prover or a remote prover pool.
  */ /**
  * The orchestrator, managing the flow of recursive proving operations required to build the rollup proof tree.
- */ export class ProvingOrchestrator {
+ */ export class ProvingOrchestrator extends TopTreeProvingScheduler {
     dbProvider;
-    prover;
     proverId;
     cancelJobsOnStop;
-    enqueueConcurrency;
     static{
         ({ e: [_initProto] } = _apply_decs_2203_r(this, [
             [
@@ -447,27 +441,12 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         ], []));
     }
     provingState;
-    pendingProvingJobs;
     provingPromise;
     metrics;
-    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
     dbs;
-    logger;
-    deferredJobQueue;
     constructor(dbProvider, prover, proverId, cancelJobsOnStop = false, enqueueConcurrency, telemetryClient = getTelemetryClient(), bindings){
-        this.dbProvider = dbProvider;
-        this.prover = prover;
-        this.proverId = proverId;
-        this.cancelJobsOnStop = cancelJobsOnStop;
-        this.enqueueConcurrency = enqueueConcurrency;
-        this.provingState = (_initProto(this), undefined);
-        this.pendingProvingJobs = [];
-        this.provingPromise = undefined;
-        this.dbs = new Map();
-        this.deferredJobQueue = new SerialQueue();
-        this.logger = createLogger('prover-client:orchestrator', bindings);
+        super(prover, enqueueConcurrency, 'prover-client:orchestrator', bindings), this.dbProvider = dbProvider, this.proverId = proverId, this.cancelJobsOnStop = cancelJobsOnStop, this.provingState = (_initProto(this), undefined), this.provingPromise = undefined, this.dbs = new Map();
         this.metrics = new ProvingOrchestratorMetrics(telemetryClient, 'ProvingOrchestrator');
-        this.deferredJobQueue.start(this.enqueueConcurrency);
     }
     get tracer() {
         return this.metrics.tracer;
@@ -478,11 +457,18 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     getNumActiveForks() {
         return this.dbs.size;
     }
-    async stop() {
-        // Grab the old queue before cancel() replaces it, so we can await its draining.
-        const oldQueue = this.deferredJobQueue;
+    cancelInternal() {
         this.cancel();
-        await oldQueue.cancel();
+    }
+    wrapCircuitCall(circuitName, fn) {
+        return wrapCallbackInSpan(this.tracer, `ProvingOrchestrator.prover.${circuitName}`, {
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName
+        }, fn);
+    }
+    onRootRollupComplete(state) {
+        state.resolve({
+            status: 'success'
+        });
     }
     startNewEpoch(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges) {
         if (this.provingState?.verifyState()) {
@@ -742,15 +728,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
    * If cancelJobsOnStop is true, aborts all pending jobs with the broker (which marks them as 'Aborted').
    * If cancelJobsOnStop is false (default), jobs remain in the broker queue and can be reused on restart/reorg.
    */ cancel() {
-        void this.deferredJobQueue.cancel();
-        // Recreate the queue so it can accept jobs for subsequent epochs.
-        this.deferredJobQueue = new SerialQueue();
-        this.deferredJobQueue.start(this.enqueueConcurrency);
-        if (this.cancelJobsOnStop) {
-            for (const controller of this.pendingProvingJobs){
-                controller.abort();
-            }
-        }
+        this.resetSchedulerState(this.cancelJobsOnStop);
         this.provingState?.cancel();
         for (const [blockNumber, db] of this.dbs.entries()){
             void db.close().catch((err)=>this.logger.error(`Error closing db for block ${blockNumber}`, err));
@@ -782,64 +760,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         });
         return epochProofResult;
     }
-    /**
-   * Enqueue a job to be scheduled
-   * @param provingState - The proving state object being operated on
-   * @param jobType - The type of job to be queued
-   * @param job - The actual job, returns a promise notifying of the job's completion
-   */ deferredProving(provingState, request, callback) {
-        if (!provingState.verifyState()) {
-            this.logger.debug(`Not enqueuing job, state no longer valid`);
-            return;
-        }
-        const controller = new AbortController();
-        this.pendingProvingJobs.push(controller);
-        // We use a 'safeJob'. We don't want promise rejections in the proving pool, we want to capture the error here
-        // and reject the proving job whilst keeping the event loop free of rejections
-        const safeJob = async ()=>{
-            try {
-                // there's a delay between enqueueing this job and it actually running
-                if (controller.signal.aborted) {
-                    return;
-                }
-                const result = await request(controller.signal);
-                if (!provingState.verifyState()) {
-                    this.logger.debug(`State no longer valid, discarding result`);
-                    return;
-                }
-                // we could have been cancelled whilst waiting for the result
-                // and the prover ignored the signal. Drop the result in that case
-                if (controller.signal.aborted) {
-                    return;
-                }
-                await callback(result);
-            } catch (err) {
-                if (err instanceof AbortError) {
-                    // operation was cancelled, probably because the block was cancelled
-                    // drop this result
-                    return;
-                }
-                this.logger.error(`Error thrown when proving job`, err);
-                provingState.reject(`${err}`);
-            } finally{
-                const index = this.pendingProvingJobs.indexOf(controller);
-                if (index > -1) {
-                    this.pendingProvingJobs.splice(index, 1);
-                }
-            }
-        };
-        void this.deferredJobQueue.put(async ()=>{
-            void safeJob();
-            // we yield here to the macro task queue such to give Nodejs a chance to run other operatoins in between enqueues
-            await sleep(0);
-        });
-    }
     async updateL1ToL2MessageTree(l1ToL2Messages, db) {
-        const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, 'Too many L1 to L2 messages');
         const lastL1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
         const lastL1ToL2MessageSubtreeRootSiblingPath = assertLength(await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db), L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH);
         // Update the local trees to include the new l1 to l2 messages
-        await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+        await appendL1ToL2MessagesToTree(db, l1ToL2Messages);
         const newL1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
         const newL1ToL2MessageSubtreeRootSiblingPath = assertLength(await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db), L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH);
         return {
@@ -918,7 +843,6 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         }
         const txProvingState = provingState.getTxProvingState(txIndex);
         const txHash = txProvingState.processedTx.hash.toString();
-        NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH;
         const handleResult = (result)=>{
             this.logger.debug(`Got chonk verifier proof for tx index: ${txIndex}`, {
                 txHash
@@ -993,7 +917,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                 return this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber);
             }
         }), async (result)=>{
-            this.logger.debug(`Completed ${rollupType} proof for block ${provingState.blockNumber}`);
+            this.logger.debug(`Completed ${rollupType} proof for block ${provingState.blockNumber}`, {
+                blockNumber: provingState.blockNumber,
+                checkpointIndex: provingState.parentCheckpoint.index,
+                ...result.inputs.toInspect()
+            });
             const leafLocation = provingState.setBlockRootRollupProof(result);
             const checkpointProvingState = provingState.parentCheckpoint;
             // Verification is called from both here and setBlockCompleted. Whichever runs last
@@ -1065,6 +993,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBlockMergeRollupProof', {
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-block-merge'
         }, (signal)=>this.prover.getBlockMergeRollupProof(inputs, signal, provingState.epochNumber)), async (result)=>{
+            this.logger.debug(`Completed block merge rollup proof for checkpoint ${provingState.index}`, {
+                checkpointIndex: provingState.index,
+                mergeLocation: location,
+                ...result.inputs.toInspect()
+            });
             provingState.setBlockMergeRollupProof(location, result);
             await this.checkAndEnqueueNextBlockMergeRollup(provingState, location);
         });
@@ -1097,7 +1030,10 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                 provingState.reject(`Blob accumulator state mismatch.`);
                 return;
             }
-            this.logger.debug(`Completed ${rollupType} proof for checkpoint ${provingState.index}.`);
+            this.logger.debug(`Completed ${rollupType} proof for checkpoint ${provingState.index}`, {
+                checkpointIndex: provingState.index,
+                ...result.inputs.toInspect()
+            });
             const leafLocation = provingState.setCheckpointRootRollupProof(result);
             const epochProvingState = provingState.parentEpoch;
             if (epochProvingState.totalNumCheckpoints === 1) {
@@ -1107,61 +1043,6 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
             }
         });
     }
-    enqueueCheckpointMergeRollup(provingState, location) {
-        if (!provingState.verifyState()) {
-            this.logger.debug('Not running checkpoint merge rollup. State no longer valid.');
-            return;
-        }
-        if (!provingState.tryStartProvingCheckpointMerge(location)) {
-            this.logger.debug('Checkpoint merge rollup already started.');
-            return;
-        }
-        const inputs = provingState.getCheckpointMergeRollupInputs(location);
-        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getCheckpointMergeRollupProof', {
-            [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-checkpoint-merge'
-        }, (signal)=>this.prover.getCheckpointMergeRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
-            this.logger.debug('Completed proof for checkpoint merge rollup.');
-            provingState.setCheckpointMergeRollupProof(location, result);
-            this.checkAndEnqueueNextCheckpointMergeRollup(provingState, location);
-        });
-    }
-    enqueueEpochPadding(provingState) {
-        if (!provingState.verifyState()) {
-            this.logger.debug('Not running epoch padding. State no longer valid.');
-            return;
-        }
-        if (!provingState.tryStartProvingPaddingCheckpoint()) {
-            this.logger.debug('Padding checkpoint already started.');
-            return;
-        }
-        this.logger.debug('Padding epoch proof with a padding block root proof.');
-        const inputs = provingState.getPaddingCheckpointInputs();
-        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getCheckpointPaddingRollupProof', {
-            [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-checkpoint-padding'
-        }, (signal)=>this.prover.getCheckpointPaddingRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
-            this.logger.debug('Completed proof for padding checkpoint.');
-            provingState.setCheckpointPaddingProof(result);
-            this.checkAndEnqueueRootRollup(provingState);
-        });
-    }
-    // Executes the root rollup circuit
-    enqueueRootRollup(provingState) {
-        if (!provingState.verifyState()) {
-            this.logger.debug('Not running root rollup, state no longer valid');
-            return;
-        }
-        this.logger.debug(`Preparing root rollup`);
-        const inputs = provingState.getRootRollupInputs();
-        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getRootRollupProof', {
-            [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-root'
-        }, (signal)=>this.prover.getRootRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
-            this.logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
-            provingState.setRootRollupProof(result);
-            provingState.resolve({
-                status: 'success'
-            });
-        });
-    }
     checkAndEnqueueNextMergeRollup(provingState, currentLocation) {
         if (!provingState.isReadyForMergeRollup(currentLocation)) {
             return;
@@ -1197,24 +1078,6 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         }
         await this.enqueueCheckpointRootRollup(provingState);
     }
-    checkAndEnqueueNextCheckpointMergeRollup(provingState, currentLocation) {
-        if (!provingState.isReadyForCheckpointMerge(currentLocation)) {
-            return;
-        }
-        const parentLocation = provingState.getParentLocation(currentLocation);
-        if (parentLocation.level === 0) {
-            this.checkAndEnqueueRootRollup(provingState);
-        } else {
-            this.enqueueCheckpointMergeRollup(provingState, parentLocation);
-        }
-    }
-    checkAndEnqueueRootRollup(provingState) {
-        if (!provingState.isReadyForRootRollup()) {
-            this.logger.debug('Not ready for root rollup');
-            return;
-        }
-        this.enqueueRootRollup(provingState);
-    }
     /**
    * Executes the VM circuit for a public function, will enqueue the corresponding kernel if the
    * previous kernel is ready