@aztec/prover-client 5.0.0-private.20260319 → 5.0.0-rc.2

package/dest/orchestrator/top-tree-orchestrator.js

@@ -0,0 +1,232 @@
+import { BatchedBlobAccumulator } from '@aztec/blob-lib';
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, OUT_HASH_TREE_HEIGHT } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { MerkleTreeCalculator, shaMerkleHash } from '@aztec/foundation/trees';
+import { computeCheckpointOutHash } from '@aztec/stdlib/messaging';
+import { CheckpointRootRollupHints, CheckpointRootRollupPrivateInputs, CheckpointRootSingleBlockRollupPrivateInputs } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { buildBlobHints, toProofData } from './block-building-helpers.js';
+import { ProvingScheduler } from './proving-scheduler.js';
+import { TopTreeProvingState } from './top-tree-proving-state.js';
+/**
+ * Sentinel thrown by `cancel` so callers can distinguish reorg-driven cancellation from
+ * a genuine proving failure (and choose to rebuild + retry instead of failing the epoch).
+ */ export class TopTreeCancelledError extends Error {
+    constructor(reason = 'Top-tree proving cancelled'){
+        super(reason);
+        this.name = 'TopTreeCancelledError';
+    }
+}
+/**
+ * Drives proving from checkpoint root rollups through the epoch root rollup. Owns no
+ * world-state forks or tx processing — every input is supplied by the caller.
+ *
+ * Pipelined start: `prove()` does not wait for block-level proving. It pre-computes the
+ * out-hash and blob-accumulator hint chains immediately from archiver-derivable data,
+ * 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 ProvingScheduler {
+    prover;
+    proverId;
+    state;
+    cancelled;
+    constructor(prover, proverId, deferredJobQueue, _telemetryClient = getTelemetryClient(), bindings){
+        super(deferredJobQueue, 'prover-client:top-tree-orchestrator', bindings), this.prover = prover, this.proverId = proverId, this.cancelled = false;
+    }
+    getProverId() {
+        return this.proverId;
+    }
+    /**
+   * Proves the top tree from per-checkpoint data and pending block-proofs promises.
+   * Resolves with the final epoch proof, or rejects with `TopTreeCancelledError` if
+   * `cancel()` is invoked, or any other error if a circuit fails.
+   */ async prove(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges, checkpointData) {
+        if (checkpointData.length !== totalNumCheckpoints) {
+            throw new Error(`checkpointData length (${checkpointData.length}) does not match totalNumCheckpoints (${totalNumCheckpoints}).`);
+        }
+        if (this.state) {
+            throw new Error('TopTreeOrchestrator.prove called twice; construct a new orchestrator per epoch.');
+        }
+        // If cancel() was already called before prove() ran (e.g. a removeCheckpoint that
+        // landed while the caller was still preparing inputs), short-circuit the whole
+        // proving path. Without this, prove() would build its state, the per-checkpoint
+        // .then handlers would all bail on `this.cancelled`, and the completion promise
+        // would never resolve — prove() would hang forever.
+        if (this.cancelled) {
+            throw new TopTreeCancelledError();
+        }
+        const { promise: completionPromise, resolve, reject } = promiseWithResolvers();
+        // 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);
+        this.state = new TopTreeProvingState(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges, startBlobAccumulator, resolve, (reason)=>reject(this.cancelled ? new TopTreeCancelledError(reason) : new Error(reason)));
+        // Compute the full out-hash hint chain and per-checkpoint start blob accumulators
+        // synchronously from archiver data. No proving required.
+        const outHashHints = await this.computeOutHashHints(checkpointData);
+        const checkpointStartBlobs = [];
+        let runningBlobAccumulator = startBlobAccumulator;
+        for (const cd of checkpointData){
+            checkpointStartBlobs.push(runningBlobAccumulator);
+            runningBlobAccumulator = await runningBlobAccumulator.accumulateFields(cd.blobFields);
+        }
+        this.state.setEndBlobAccumulator(runningBlobAccumulator);
+        // For each checkpoint, await its block proofs promise then enqueue the checkpoint root.
+        // Each await runs independently — checkpoints whose sub-trees finish first start their
+        // root proofs first, in parallel with later checkpoints' block-level proving.
+        for(let i = 0; i < checkpointData.length; i++){
+            const cd = checkpointData[i];
+            const checkpointIndex = i;
+            void cd.blockProofs.then((blockProofs)=>{
+                if (this.cancelled || !this.state?.verifyState()) {
+                    return;
+                }
+                this.enqueueCheckpointRoot(this.state, checkpointIndex, blockProofs, cd, outHashHints[i], checkpointStartBlobs[i]);
+            }, (err)=>{
+                if (this.cancelled) {
+                    return;
+                }
+                this.state?.reject(`Sub-tree for checkpoint ${i} failed: ${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();
+    }
+    /**
+   * Cancels in-flight proving. If `abortJobs` is true, each pending broker job is aborted
+   * (used on reorg, when the surviving checkpoint set differs and the in-flight jobs'
+   * inputs are no longer valid). On shutdown the caller passes `false` so jobs remain in
+   * the broker queue for reuse on restart.
+   */ cancel({ abortJobs }) {
+        this.cancelled = true;
+        this.resetSchedulerState(abortJobs);
+        this.state?.cancel();
+    }
+    /** Standard shutdown — preserve the broker queue (`abortJobs: false`). */ cancelInternal() {
+        this.cancel({
+            abortJobs: false
+        });
+    }
+    // --- internal: per-checkpoint enqueue path ---
+    enqueueCheckpointRoot(state, checkpointIndex, blockProofs, cd, outHashHint, startBlobAccumulator) {
+        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}`);
+        });
+    }
+    async buildCheckpointRootInputs(blockProofs, cd, outHashHint, startBlobAccumulator) {
+        const { blobCommitments, blobsHash } = await buildBlobHints(cd.blobFields);
+        const hints = CheckpointRootRollupHints.from({
+            previousBlockHeader: cd.previousBlockHeader,
+            previousArchiveSiblingPath: cd.previousArchiveSiblingPath,
+            previousOutHash: outHashHint.treeSnapshot,
+            newOutHashSiblingPath: outHashHint.siblingPath,
+            startBlobAccumulator: startBlobAccumulator.toBlobAccumulator(),
+            finalBlobChallenges: this.state.finalBlobBatchingChallenges,
+            blobFields: padArrayEnd(cd.blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_CHECKPOINT),
+            blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_CHECKPOINT),
+            blobsHash
+        });
+        const proofDatas = blockProofs.map((p)=>toProofData(p));
+        return proofDatas.length === 1 ? new CheckpointRootSingleBlockRollupPrivateInputs(proofDatas[0], hints) : new CheckpointRootRollupPrivateInputs([
+            proofDatas[0],
+            proofDatas[1]
+        ], hints);
+    }
+    // --- internal: top-tree proof orchestration (formerly TopTreeProvingScheduler) ---
+    enqueueCheckpointMergeRollup(state, location) {
+        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);
+        });
+    }
+    enqueueEpochPadding(state) {
+        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);
+        });
+    }
+    enqueueRootRollup(state) {
+        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();
+        });
+    }
+    checkAndEnqueueNextCheckpointMergeRollup(state, currentLocation) {
+        if (!state.isReadyForCheckpointMerge(currentLocation)) {
+            return;
+        }
+        const parentLocation = state.getParentLocation(currentLocation);
+        if (parentLocation.level === 0) {
+            this.checkAndEnqueueRootRollup(state);
+        } else {
+            this.enqueueCheckpointMergeRollup(state, parentLocation);
+        }
+    }
+    checkAndEnqueueRootRollup(state) {
+        if (!state.isReadyForRootRollup()) {
+            return;
+        }
+        this.enqueueRootRollup(state);
+    }
+    async computeOutHashHints(checkpointData) {
+        const treeCalculator = await MerkleTreeCalculator.create(OUT_HASH_TREE_HEIGHT, undefined, (left, right)=>Promise.resolve(shaMerkleHash(left, right)));
+        const computeHint = async (leaves)=>{
+            const tree = await treeCalculator.computeTree(leaves.map((l)=>l.toBuffer()));
+            const nextAvailableLeafIndex = leaves.length;
+            return {
+                treeSnapshot: new AppendOnlyTreeSnapshot(Fr.fromBuffer(tree.root), nextAvailableLeafIndex),
+                siblingPath: tree.getSiblingPath(nextAvailableLeafIndex).map(Fr.fromBuffer)
+            };
+        };
+        const hints = [];
+        const outHashes = [];
+        for (const cd of checkpointData){
+            hints.push(await computeHint(outHashes));
+            outHashes.push(computeCheckpointOutHash(cd.l2ToL1MsgsPerBlock));
+        }
+        return hints;
+    }
+}

package/dest/orchestrator/top-tree-proving-state.d.ts

@@ -0,0 +1,61 @@
+import type { BatchedBlob, BatchedBlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import type { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { type TreeNodeLocation } from '@aztec/foundation/trees';
+import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { Proof } from '@aztec/stdlib/proofs';
+import { CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, CheckpointRollupPublicInputs, RootRollupPrivateInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+/**
+ * Lean top-tree-only state. Owns the merge tree of checkpoint root proofs, the
+ * single-checkpoint padding proof slot, the final root rollup proof, and the blob
+ * accumulator endpoints needed to finalise the epoch's batched blob proof.
+ *
+ * Constructed with `totalNumCheckpoints` and `finalBlobBatchingChallenges` upfront —
+ * by the time the top tree starts, all checkpoints are known and the challenges are
+ * derivable from their blob fields.
+ */
+export declare class TopTreeProvingState {
+    #private;
+    readonly epochNumber: EpochNumber;
+    readonly totalNumCheckpoints: number;
+    readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges;
+    readonly startBlobAccumulator: BatchedBlobAccumulator;
+    private readonly completionCallback;
+    private readonly rejectionCallback;
+    private checkpointProofs;
+    private checkpointPaddingProof;
+    private rootRollupProof;
+    private endBlobAccumulator;
+    private finalBatchedBlob;
+    private lifecycle;
+    constructor(epochNumber: EpochNumber, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, startBlobAccumulator: BatchedBlobAccumulator, completionCallback: () => void, rejectionCallback: (reason: string) => void);
+    setCheckpointRootRollupProof(checkpointIndex: number, provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    tryStartProvingCheckpointMerge(location: TreeNodeLocation): boolean;
+    setCheckpointMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    isReadyForCheckpointMerge(location: TreeNodeLocation): boolean;
+    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
+    getCheckpointMergeRollupInputs(mergeLocation: TreeNodeLocation): CheckpointMergeRollupPrivateInputs;
+    tryStartProvingPaddingCheckpoint(): boolean;
+    setCheckpointPaddingProof(provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    getPaddingCheckpointInputs(): CheckpointPaddingRollupPrivateInputs;
+    tryStartProvingRootRollup(): boolean;
+    setRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<RootRollupPublicInputs>): void;
+    isReadyForRootRollup(): boolean;
+    getRootRollupInputs(): RootRollupPrivateInputs;
+    /**
+     * Sets the end-of-epoch blob accumulator, computed by the top-tree orchestrator
+     * from the surviving checkpoints' blob fields. Required before `finalizeBatchedBlob`.
+     */
+    setEndBlobAccumulator(accumulator: BatchedBlobAccumulator): void;
+    finalizeBatchedBlob(): Promise<void>;
+    getEpochProofResult(): {
+        proof: Proof;
+        publicInputs: RootRollupPublicInputs;
+        batchedBlobInputs: BatchedBlob;
+    };
+    verifyState(): boolean;
+    resolve(): void;
+    reject(reason: string): void;
+    cancel(): void;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/orchestrator/top-tree-proving-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"top-tree-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AACxG,OAAO,KAAK,EAAiC,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AACjH,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,yBAAyB,CAAC;AACrF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EACL,kCAAkC,EAClC,oCAAoC,EACpC,4BAA4B,EAC5B,uBAAuB,EACvB,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAW9B;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;;aAYZ,WAAW,EAAE,WAAW;aACxB,mBAAmB,EAAE,MAAM;aAC3B,2BAA2B,EAAE,2BAA2B;aACxD,oBAAoB,EAAE,sBAAsB;IAC5D,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAhBpC,OAAO,CAAC,gBAAgB,CAEtB;IACF,OAAO,CAAC,sBAAsB,CAEhB;IACd,OAAO,CAAC,eAAe,CAAuF;IAC9G,OAAO,CAAC,kBAAkB,CAAqC;IAC/D,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,SAAS,CAA8B;IAC/C,YACkB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,EACxD,oBAAoB,EAAE,sBAAsB,EAC3C,kBAAkB,EAAE,MAAM,IAAI,EAC9B,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EAM7D;IAIM,4BAA4B,CACjC,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,GACA,gBAAgB,CAElB;IAIM,8BAA8B,CAAC,QAAQ,EAAE,gBAAgB,WAM/D;IAEM,6BAA6B,CAClC,QAAQ,EAAE,gBAAgB,EAC1B,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,QAGF;IAEM,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,WAE1D;IAEM,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,oBAElD;IAEM,8BAA8B,CAAC,aAAa,EAAE,gBAAgB,sCAMpE;IAIM,gCAAgC,YAMtC;IAEM,yBAAyB,CAC9B,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,QAGF;IAEM,0BAA0B,yCAEhC;IAIM,yBAAyB,YAM/B;IAEM,kBAAkB,CAAC,aAAa,EAAE,6BAA6B,CAAC,sBAAsB,CAAC,QAE7F;IAEM,oBAAoB,YAG1B;IAEM,mBAAmB,4BAQzB;IAID;;;OAGG;IACI,qBAAqB,CAAC,WAAW,EAAE,sBAAsB,QAE/D;IAEY,mBAAmB,kBAK/B;IAEM,mBAAmB,IAAI;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,YAAY,EAAE,sBAAsB,CAAC;QAAC,iBAAiB,EAAE,WAAW,CAAA;KAAE,CAUnH;IAIM,WAAW,YAEjB;IAEM,OAAO,SAMb;IAEM,MAAM,CAAC,MAAM,EAAE,MAAM,QAM3B;IAEM,MAAM,SAEZ;CAQF"}

package/dest/orchestrator/top-tree-proving-state.js

@@ -0,0 +1,185 @@
+import { UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, RootRollupPrivateInputs } from '@aztec/stdlib/rollup';
+import { toProofData } from './block-building-helpers.js';
+var TOP_TREE_LIFECYCLE = /*#__PURE__*/ function(TOP_TREE_LIFECYCLE) {
+    TOP_TREE_LIFECYCLE[TOP_TREE_LIFECYCLE["CREATED"] = 0] = "CREATED";
+    TOP_TREE_LIFECYCLE[TOP_TREE_LIFECYCLE["RESOLVED"] = 1] = "RESOLVED";
+    TOP_TREE_LIFECYCLE[TOP_TREE_LIFECYCLE["REJECTED"] = 2] = "REJECTED";
+    return TOP_TREE_LIFECYCLE;
+}(TOP_TREE_LIFECYCLE || {});
+/**
+ * Lean top-tree-only state. Owns the merge tree of checkpoint root proofs, the
+ * single-checkpoint padding proof slot, the final root rollup proof, and the blob
+ * accumulator endpoints needed to finalise the epoch's batched blob proof.
+ *
+ * Constructed with `totalNumCheckpoints` and `finalBlobBatchingChallenges` upfront —
+ * by the time the top tree starts, all checkpoints are known and the challenges are
+ * derivable from their blob fields.
+ */ export class TopTreeProvingState {
+    epochNumber;
+    totalNumCheckpoints;
+    finalBlobBatchingChallenges;
+    startBlobAccumulator;
+    completionCallback;
+    rejectionCallback;
+    checkpointProofs;
+    checkpointPaddingProof;
+    rootRollupProof;
+    endBlobAccumulator;
+    finalBatchedBlob;
+    lifecycle;
+    constructor(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges, startBlobAccumulator, completionCallback, rejectionCallback){
+        this.epochNumber = epochNumber;
+        this.totalNumCheckpoints = totalNumCheckpoints;
+        this.finalBlobBatchingChallenges = finalBlobBatchingChallenges;
+        this.startBlobAccumulator = startBlobAccumulator;
+        this.completionCallback = completionCallback;
+        this.rejectionCallback = rejectionCallback;
+        this.lifecycle = 0;
+        if (totalNumCheckpoints < 1) {
+            throw new Error(`TopTreeProvingState requires at least one checkpoint; got ${totalNumCheckpoints}.`);
+        }
+        this.checkpointProofs = new UnbalancedTreeStore(totalNumCheckpoints);
+    }
+    // --- checkpoint root rollup ---
+    setCheckpointRootRollupProof(checkpointIndex, provingOutput) {
+        return this.checkpointProofs.setLeaf(checkpointIndex, {
+            provingOutput
+        });
+    }
+    // --- checkpoint merge rollup ---
+    tryStartProvingCheckpointMerge(location) {
+        if (this.checkpointProofs.getNode(location)?.isProving) {
+            return false;
+        }
+        this.checkpointProofs.setNode(location, {
+            isProving: true
+        });
+        return true;
+    }
+    setCheckpointMergeRollupProof(location, provingOutput) {
+        this.checkpointProofs.setNode(location, {
+            provingOutput
+        });
+    }
+    isReadyForCheckpointMerge(location) {
+        return !!this.checkpointProofs.getSibling(location)?.provingOutput;
+    }
+    getParentLocation(location) {
+        return this.checkpointProofs.getParentLocation(location);
+    }
+    getCheckpointMergeRollupInputs(mergeLocation) {
+        const [left, right] = this.checkpointProofs.getChildren(mergeLocation).map((c)=>c?.provingOutput);
+        if (!left || !right) {
+            throw new Error('At least one child is not ready for the checkpoint merge rollup.');
+        }
+        return new CheckpointMergeRollupPrivateInputs([
+            toProofData(left),
+            toProofData(right)
+        ]);
+    }
+    // --- padding (single-checkpoint case) ---
+    tryStartProvingPaddingCheckpoint() {
+        if (this.checkpointPaddingProof?.isProving) {
+            return false;
+        }
+        this.checkpointPaddingProof = {
+            isProving: true
+        };
+        return true;
+    }
+    setCheckpointPaddingProof(provingOutput) {
+        this.checkpointPaddingProof = {
+            provingOutput
+        };
+    }
+    getPaddingCheckpointInputs() {
+        return new CheckpointPaddingRollupPrivateInputs();
+    }
+    // --- root rollup ---
+    tryStartProvingRootRollup() {
+        if (this.rootRollupProof?.isProving) {
+            return false;
+        }
+        this.rootRollupProof = {
+            isProving: true
+        };
+        return true;
+    }
+    setRootRollupProof(provingOutput) {
+        this.rootRollupProof = {
+            provingOutput
+        };
+    }
+    isReadyForRootRollup() {
+        const childProofs = this.#getChildProofsForRoot();
+        return childProofs.every((p)=>!!p);
+    }
+    getRootRollupInputs() {
+        const [left, right] = this.#getChildProofsForRoot();
+        if (!left || !right) {
+            throw new Error('At least one child is not ready for the root rollup.');
+        }
+        return RootRollupPrivateInputs.from({
+            previousRollups: [
+                toProofData(left),
+                toProofData(right)
+            ]
+        });
+    }
+    // --- blob accumulator finalisation ---
+    /**
+   * Sets the end-of-epoch blob accumulator, computed by the top-tree orchestrator
+   * from the surviving checkpoints' blob fields. Required before `finalizeBatchedBlob`.
+   */ setEndBlobAccumulator(accumulator) {
+        this.endBlobAccumulator = accumulator;
+    }
+    async finalizeBatchedBlob() {
+        if (!this.endBlobAccumulator) {
+            throw new Error('End blob accumulator not set; call setEndBlobAccumulator before finalize.');
+        }
+        this.finalBatchedBlob = await this.endBlobAccumulator.finalize(true);
+    }
+    getEpochProofResult() {
+        const provingOutput = this.rootRollupProof?.provingOutput;
+        if (!provingOutput || !this.finalBatchedBlob) {
+            throw new Error('Top-tree proof not ready; root rollup or batched blob missing.');
+        }
+        return {
+            proof: provingOutput.proof.binaryProof,
+            publicInputs: provingOutput.inputs,
+            batchedBlobInputs: this.finalBatchedBlob
+        };
+    }
+    // --- lifecycle ---
+    verifyState() {
+        return this.lifecycle === 0;
+    }
+    resolve() {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.lifecycle = 1;
+        this.completionCallback();
+    }
+    reject(reason) {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.lifecycle = 2;
+        this.rejectionCallback(reason);
+    }
+    cancel() {
+        this.reject('Top-tree proving cancelled');
+    }
+    #getChildProofsForRoot() {
+        const rootLocation = {
+            level: 0,
+            index: 0
+        };
+        return this.totalNumCheckpoints === 1 ? [
+            this.checkpointProofs.getNode(rootLocation)?.provingOutput,
+            this.checkpointPaddingProof?.provingOutput
+        ] : this.checkpointProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
+    }
+}

package/dest/prover-client/prover-client.d.ts

@@ -1,10 +1,42 @@
 import { type ACVMConfig, type BBConfig } from '@aztec/bb-prover';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type ActualProverConfig, type EpochProver, type EpochProverManager, type ForkMerkleTreeOperations, type ProvingJobBroker, type ProvingJobConsumer, type ReadonlyWorldStateAccess, type ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import { type ActualProverConfig, type EpochProverManager, type ForkMerkleTreeOperations, type ProvingJobBroker, type ProvingJobConsumer, type ReadonlyWorldStateAccess, type ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { CheckpointConstantData } from '@aztec/stdlib/rollup';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import type { ProverClientConfig } from '../config.js';
+import { CheckpointSubTreeOrchestrator } from '../orchestrator/checkpoint-sub-tree-orchestrator.js';
+import type { ChonkCache } from '../orchestrator/chonk-cache.js';
+import { TopTreeOrchestrator } from '../orchestrator/top-tree-orchestrator.js';
+/**
+ * The factory surface that `EpochProvingJob` (in `prover-node`) depends on. Implemented
+ * by `ProverClient`. Defined here rather than in stdlib because the return types
+ * (`CheckpointSubTreeOrchestrator`, `TopTreeOrchestrator`) are concrete classes from
+ * this package.
+ *
+ * A single `BrokerCircuitProverFacade` is owned by `ProverClient` and shared across
+ * every orchestrator (every sub-tree and every top-tree across every concurrent epoch
+ * job). The broker delivers each completed-job notification exactly once (drained on
+ * the first `getCompletedJobs` poll), so multiple facades polling the same broker
+ * race and lose notifications
+ *
+ * The facade's job map cleans up entries on resolve/reject, and the prover-node
+ * keeps `ProverClient` alive for its whole lifetime
+ */
+export interface EpochProverFactory {
+    getProverId(): EthAddress;
+    /**
+     * 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(chonkCache: ChonkCache, epochNumber: EpochNumber, checkpointConstants: CheckpointConstantData, l1ToL2Messages: Fr[], totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader): Promise<CheckpointSubTreeOrchestrator>;
+    createTopTreeOrchestrator(): TopTreeOrchestrator;
+}
 /** Manages proving of epochs by orchestrating the proving of individual blocks relying on a pool of prover agents. */
-export declare class ProverClient implements EpochProverManager {
+export declare class ProverClient implements EpochProverManager, EpochProverFactory {
     private config;
     private worldState;
     private orchestratorClient;
@@ -15,8 +47,33 @@ export declare class ProverClient implements EpochProverManager {
     private log;
     private running;
     private agents;
+    /**
+     * The single broker facade shared by every orchestrator created from this client.
+     * Constructed lazily on `start()` and torn down on `stop()` — see the comment on
+     * `EpochProverFactory` for why a single shared facade is required.
+     */
+    private facade;
+    /**
+     * 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;
     private constructor();
-    createEpochProver(): EpochProver;
+    /**
+     * Lazy-init the shared facade. The broker delivers each completed-job notification
+     * exactly once (drained on the first `getCompletedJobs` poll), so we cannot start
+     * a shared facade alongside the per-call facades that `createEpochProver` builds —
+     * they would race for notifications and one side would silently drop them. Starting
+     * the shared facade only on first use of one of the new factory methods keeps the
+     * legacy `createEpochProver` path race-free.
+     */
+    private getFacade;
+    /** Lazy-init the shared deferred-job queue, started with the configured enqueue concurrency. */
+    private getDeferredJobQueue;
+    createCheckpointSubTreeOrchestrator(chonkCache: ChonkCache, epochNumber: EpochNumber, checkpointConstants: CheckpointConstantData, l1ToL2Messages: Fr[], totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader): Promise<CheckpointSubTreeOrchestrator>;
+    createTopTreeOrchestrator(): TopTreeOrchestrator;
     getProverId(): EthAddress;
     updateProverConfig(config: Partial<ProverClientConfig>): Promise<void>;
     /**
@@ -39,4 +96,4 @@ export declare class ProverClient implements EpochProverManager {
     private stopAgents;
 }
 export declare function buildServerCircuitProver(config: Omit<ActualProverConfig, 'enqueueConcurrency'> & ACVMConfig & BBConfig, telemetry: TelemetryClient): Promise<ServerCircuitProver>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmVyLWNsaWVudC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3Zlci1jbGllbnQvcHJvdmVyLWNsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxVQUFVLEVBQUUsS0FBSyxRQUFRLEVBQTJDLE1BQU0sa0JBQWtCLENBQUM7QUFFM0csT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFHaEUsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssV0FBVyxFQUNoQixLQUFLLGtCQUFrQixFQUN2QixLQUFLLHdCQUF3QixFQUM3QixLQUFLLGdCQUFnQixFQUNyQixLQUFLLGtCQUFrQixFQUV2QixLQUFLLHdCQUF3QixFQUM3QixLQUFLLG1CQUFtQixFQUV6QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx5QkFBeUIsQ0FBQztBQUVuRixPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQU92RCxzSEFBc0g7QUFDdEgscUJBQWEsWUFBYSxZQUFXLGtCQUFrQjtJQUtuRCxPQUFPLENBQUMsTUFBTTtJQUNkLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxrQkFBa0I7SUFDMUIsT0FBTyxDQUFDLFVBQVU7SUFDbEIsT0FBTyxDQUFDLGdCQUFnQjtJQUN4QixPQUFPLENBQUMsV0FBVyxDQUFDO0lBQ3BCLE9BQU8sQ0FBQyxTQUFTO0lBQ2pCLE9BQU8sQ0FBQyxHQUFHO0lBWGIsT0FBTyxDQUFDLE9BQU8sQ0FBUztJQUN4QixPQUFPLENBQUMsTUFBTSxDQUFzQjtJQUVwQyxPQUFPLGVBU0g7SUFFRyxpQkFBaUIsSUFBSSxXQUFXLENBbUJ0QztJQUVNLFdBQVcsSUFBSSxVQUFVLENBRS9CO0lBRUssa0JBQWtCLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FZM0U7SUFFRDs7T0FFRztJQUNVLEtBQUssSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBT2xDO0lBRUQ7O09BRUc7SUFDVSxJQUFJLGtCQU9oQjtJQUVEOzs7OztPQUtHO0lBQ0gsT0FBb0IsR0FBRyxDQUNyQixNQUFNLEVBQUUsa0JBQWtCLEVBQzFCLFVBQVUsRUFBRSx3QkFBd0IsR0FBRyx3QkFBd0IsRUFDL0QsTUFBTSxFQUFFLGdCQUFnQixFQUN4QixTQUFTLEdBQUUsZUFBc0MseUJBT2xEO0lBRU0sbUJBQW1CLElBQUksa0JBQWtCLENBTS9DO1lBRWEsb0JBQW9CO1lBcUJwQixVQUFVO0NBR3pCO0FBRUQsd0JBQWdCLHdCQUF3QixDQUN0QyxNQUFNLEVBQUUsSUFBSSxDQUFDLGtCQUFrQixFQUFFLG9CQUFvQixDQUFDLEdBQUcsVUFBVSxHQUFHLFFBQVEsRUFDOUUsU0FBUyxFQUFFLGVBQWUsR0FDekIsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBVzlCIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dest/prover-client/prover-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prover-client.d.ts","sourceRoot":"","sources":["../../src/prover-client/prover-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAA2C,MAAM,kBAAkB,CAAC;AAE3G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAEvB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EAEzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAOvD,sHAAsH;AACtH,qBAAa,YAAa,YAAW,kBAAkB;IAKnD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,WAAW,CAAC;IACpB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAXb,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAsB;IAEpC,OAAO,eASH;IAEG,iBAAiB,IAAI,WAAW,CAmBtC;IAEM,WAAW,IAAI,UAAU,CAE/B;IAEK,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAY3E;IAED;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAOlC;IAED;;OAEG;IACU,IAAI,kBAOhB;IAED;;;;;OAKG;IACH,OAAoB,GAAG,CACrB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,wBAAwB,GAAG,wBAAwB,EAC/D,MAAM,EAAE,gBAAgB,EACxB,SAAS,GAAE,eAAsC,yBAOlD;IAEM,mBAAmB,IAAI,kBAAkB,CAM/C;YAEa,oBAAoB;YAqBpB,UAAU;CAGzB;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,GAAG,UAAU,GAAG,QAAQ,EAC9E,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAW9B"}
+{"version":3,"file":"prover-client.d.ts","sourceRoot":"","sources":["../../src/prover-client/prover-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAA2C,MAAM,kBAAkB,CAAC;AAC3G,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAIhE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAEvB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EAEzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,6BAA6B,EAAE,MAAM,qDAAqD,CAAC;AACpG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAK/E;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,kBAAkB;IACjC,WAAW,IAAI,UAAU,CAAC;IAC1B;;;;OAIG;IACH,mCAAmC,CACjC,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,sBAAsB,EAC3C,cAAc,EAAE,EAAE,EAAE,EACpB,cAAc,EAAE,MAAM,EACtB,qCAAqC,EAAE,WAAW,GACjD,OAAO,CAAC,6BAA6B,CAAC,CAAC;IAC1C,yBAAyB,IAAI,mBAAmB,CAAC;CAClD;AAED,sHAAsH;AACtH,qBAAa,YAAa,YAAW,kBAAkB,EAAE,kBAAkB;IAkBvE,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,WAAW,CAAC;IACpB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAxBb,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAsB;IACpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAwC;IACtD;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB,CAA0B;IAElD,OAAO,eASH;IAEJ;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAiBjB,gGAAgG;IAChG,OAAO,CAAC,mBAAmB;IAWpB,mCAAmC,CACxC,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,sBAAsB,EAC3C,cAAc,EAAE,EAAE,EAAE,EACpB,cAAc,EAAE,MAAM,EACtB,qCAAqC,EAAE,WAAW,GACjD,OAAO,CAAC,6BAA6B,CAAC,CAgBxC;IAEM,yBAAyB,IAAI,mBAAmB,CAQtD;IAEM,WAAW,IAAI,UAAU,CAE/B;IAEK,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAY3E;IAED;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAOlC;IAED;;OAEG;IACU,IAAI,kBAehB;IAED;;;;;OAKG;IACH,OAAoB,GAAG,CACrB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,wBAAwB,GAAG,wBAAwB,EAC/D,MAAM,EAAE,gBAAgB,EACxB,SAAS,GAAE,eAAsC,yBAOlD;IAEM,mBAAmB,IAAI,kBAAkB,CAM/C;YAEa,oBAAoB;YAqBpB,UAAU;CAGzB;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,GAAG,UAAU,GAAG,QAAQ,EAC9E,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAW9B"}