@aztec/prover-client 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/dest/orchestrator/proving-scheduler.d.ts

@@ -0,0 +1,72 @@
+import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
+/**
+ * Minimal surface a deferred-proving state must expose. Both `EpochProvingState` /
+ * `CheckpointProvingState` / `BlockProvingState` (used by `ProvingOrchestrator`) and
+ * `TopTreeProvingState` (used by `TopTreeOrchestrator`) satisfy it.
+ */
+export interface ProvingStateLike {
+    /** Returns false once the state has been cancelled or otherwise invalidated. */
+    verifyState(): boolean;
+    /** Surfaces a proving error to the state's owner. */
+    reject(reason: string): void;
+}
+/**
+ * Common scheduling infrastructure shared by every orchestrator that drives broker
+ * proving jobs:
+ *
+ *   - One `SerialQueue` (`deferredJobQueue`) acting as the enqueue-throttle.
+ *   - 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
+ *     a broker request in the standard "submit, drop result if state invalidated, push
+ *     errors to state.reject" envelope.
+ *
+ * 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.
+ */
+export declare abstract class ProvingScheduler {
+    private readonly enqueueConcurrency;
+    protected pendingProvingJobs: AbortController[];
+    protected logger: Logger;
+    private deferredJobQueue;
+    constructor(enqueueConcurrency: number, loggerName?: string, bindings?: LoggerBindings);
+    /** Number of broker jobs currently in flight. */
+    getNumPendingProvingJobs(): number;
+    /**
+     * 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
+     * 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).
+     */
+    protected resetSchedulerState(abortJobs: boolean): void;
+    /**
+     * Subclass-defined cancellation. Implementations call `resetSchedulerState(...)`
+     * and then do their own cleanup (close world-state forks, propagate cancel into
+     * the proving state, etc.).
+     */
+    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.
+     */
+    stop(): Promise<void>;
+    /**
+     * Submits a broker request. The returned-via-callback result is dropped if the
+     * state has become invalid (re-org, cancellation) by the time it lands. Errors
+     * are routed to `state.reject` unless they are abort-driven or the state is
+     * already invalid (in which case they're a stale echo of the cancel).
+     *
+     * @param state - Object exposing `verifyState()` and `reject()`.
+     * @param request - The broker call. Receives the controller's signal.
+     * @param callback - Runs on success, after `verifyState()` is checked.
+     * @param isCancelled - Optional extra cancellation predicate (e.g. a `cancelled`
+     *   flag the subclass maintains independently of the state). Defaults to never.
+     */
+    protected deferredProving<S extends ProvingStateLike, T>(state: S, request: (signal: AbortSignal) => Promise<T>, callback: (result: T) => void | Promise<void>, isCancelled?: () => boolean): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmluZy1zY2hlZHVsZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvcHJvdmluZy1zY2hlZHVsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBSXZGOzs7O0dBSUc7QUFDSCxNQUFNLFdBQVcsZ0JBQWdCO0lBQy9CLGdGQUFnRjtJQUNoRixXQUFXLElBQUksT0FBTyxDQUFDO0lBQ3ZCLHFEQUFxRDtJQUNyRCxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxJQUFJLENBQUM7Q0FDOUI7QUFFRDs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILDhCQUFzQixnQkFBZ0I7SUFNbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxrQkFBa0I7SUFMckMsU0FBUyxDQUFDLGtCQUFrQixFQUFFLGVBQWUsRUFBRSxDQUFNO0lBQ3JELFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQ3pCLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBYztJQUV0QyxZQUNtQixrQkFBa0IsRUFBRSxNQUFNLEVBQzNDLFVBQVUsU0FBb0MsRUFDOUMsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUsxQjtJQUVELGlEQUFpRDtJQUMxQyx3QkFBd0IsSUFBSSxNQUFNLENBRXhDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsU0FBUyxDQUFDLG1CQUFtQixDQUFDLFNBQVMsRUFBRSxPQUFPLEdBQUcsSUFBSSxDQVN0RDtJQUVEOzs7O09BSUc7SUFDSCxTQUFTLENBQUMsUUFBUSxDQUFDLGNBQWMsSUFBSSxJQUFJLENBQUM7SUFFMUM7Ozs7T0FJRztJQUNVLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBSWpDO0lBRUQ7Ozs7Ozs7Ozs7O09BV0c7SUFDSCxTQUFTLENBQUMsZUFBZSxDQUFDLENBQUMsU0FBUyxnQkFBZ0IsRUFBRSxDQUFDLEVBQ3JELEtBQUssRUFBRSxDQUFDLEVBQ1IsT0FBTyxFQUFFLENBQUMsTUFBTSxFQUFFLFdBQVcsS0FBSyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQzVDLFFBQVEsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLEtBQUssSUFBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFDN0MsV0FBVyxHQUFFLE1BQU0sT0FBcUIsR0FDdkMsSUFBSSxDQStDTjtDQUNGIn0=

package/dest/orchestrator/proving-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proving-scheduler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/proving-scheduler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAIvF;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,WAAW,IAAI,OAAO,CAAC;IACvB,qDAAqD;IACrD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,gBAAgB;IAMlC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IALrC,SAAS,CAAC,kBAAkB,EAAE,eAAe,EAAE,CAAM;IACrD,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,gBAAgB,CAAc;IAEtC,YACmB,kBAAkB,EAAE,MAAM,EAC3C,UAAU,SAAoC,EAC9C,QAAQ,CAAC,EAAE,cAAc,EAK1B;IAED,iDAAiD;IAC1C,wBAAwB,IAAI,MAAM,CAExC;IAED;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAStD;IAED;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,IAAI,IAAI,CAAC;IAE1C;;;;OAIG;IACU,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAIjC;IAED;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,eAAe,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,EACrD,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5C,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC7C,WAAW,GAAE,MAAM,OAAqB,GACvC,IAAI,CA+CN;CACF"}

package/dest/orchestrator/proving-scheduler.js

@@ -0,0 +1,117 @@
+import { AbortError } from '@aztec/foundation/error';
+import { createLogger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
+import { sleep } from '@aztec/foundation/sleep';
+/**
+ * Common scheduling infrastructure shared by every orchestrator that drives broker
+ * proving jobs:
+ *
+ *   - One `SerialQueue` (`deferredJobQueue`) acting as the enqueue-throttle.
+ *   - 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
+ *     a broker request in the standard "submit, drop result if state invalidated, push
+ *     errors to state.reject" envelope.
+ *
+ * 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.
+ */ export class ProvingScheduler {
+    enqueueConcurrency;
+    pendingProvingJobs;
+    logger;
+    deferredJobQueue;
+    constructor(enqueueConcurrency, loggerName = 'prover-client:proving-scheduler', bindings){
+        this.enqueueConcurrency = enqueueConcurrency;
+        this.pendingProvingJobs = [];
+        this.logger = createLogger(loggerName, bindings);
+        this.deferredJobQueue = new SerialQueue();
+        this.deferredJobQueue.start(this.enqueueConcurrency);
+    }
+    /** Number of broker jobs currently in flight. */ getNumPendingProvingJobs() {
+        return this.pendingProvingJobs.length;
+    }
+    /**
+   * 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
+   * 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).
+   */ resetSchedulerState(abortJobs) {
+        void this.deferredJobQueue.cancel();
+        this.deferredJobQueue = new SerialQueue();
+        this.deferredJobQueue.start(this.enqueueConcurrency);
+        if (abortJobs) {
+            for (const controller of this.pendingProvingJobs){
+                controller.abort();
+            }
+        }
+    }
+    /**
+   * 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.
+   */ async stop() {
+        const oldQueue = this.deferredJobQueue;
+        this.cancelInternal();
+        await oldQueue.cancel();
+    }
+    /**
+   * Submits a broker request. The returned-via-callback result is dropped if the
+   * state has become invalid (re-org, cancellation) by the time it lands. Errors
+   * are routed to `state.reject` unless they are abort-driven or the state is
+   * already invalid (in which case they're a stale echo of the cancel).
+   *
+   * @param state - Object exposing `verifyState()` and `reject()`.
+   * @param request - The broker call. Receives the controller's signal.
+   * @param callback - Runs on success, after `verifyState()` is checked.
+   * @param isCancelled - Optional extra cancellation predicate (e.g. a `cancelled`
+   *   flag the subclass maintains independently of the state). Defaults to never.
+   */ deferredProving(state, request, callback, isCancelled = ()=>false) {
+        if (!state.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 state while keeping the
+        // event loop free of rejections.
+        const safeJob = async ()=>{
+            try {
+                if (controller.signal.aborted) {
+                    return;
+                }
+                const result = await request(controller.signal);
+                if (controller.signal.aborted || !state.verifyState() || isCancelled()) {
+                    this.logger.debug(`State no longer valid, discarding result`);
+                    return;
+                }
+                await callback(result);
+            } catch (err) {
+                if (err instanceof AbortError || isCancelled()) {
+                    return;
+                }
+                if (!state.verifyState()) {
+                    this.logger.debug(`State no longer valid, discarding error from proving job`, err);
+                    return;
+                }
+                this.logger.error(`Error thrown when proving job`, err);
+                state.reject(`${err}`);
+            } finally{
+                const idx = this.pendingProvingJobs.indexOf(controller);
+                if (idx > -1) {
+                    this.pendingProvingJobs.splice(idx, 1);
+                }
+            }
+        };
+        void this.deferredJobQueue.put(async ()=>{
+            void safeJob();
+            // Yield to the macrotask queue so Node has a chance to interleave other work
+            // between enqueues.
+            await sleep(0);
+        });
+    }
+}

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

@@ -0,0 +1,83 @@
+import { type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import type { BatchedBlob } from '@aztec/blob-lib/types';
+import { type ARCHIVE_HEIGHT, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { LoggerBindings } from '@aztec/foundation/log';
+import type { Tuple } from '@aztec/foundation/serialize';
+import type { EthAddress } from '@aztec/stdlib/block';
+import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { Proof } from '@aztec/stdlib/proofs';
+import { type BlockRollupPublicInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { TopTreeProvingScheduler } from './top-tree-proving-scheduler.js';
+import { TopTreeProvingState } from './top-tree-proving-state.js';
+/** Per-checkpoint data fed into the top tree. */
+export type CheckpointTopTreeData = {
+    /**
+     * Block-rollup proof outputs from the checkpoint's sub-tree. Passed as a Promise so the
+     * top tree can start (compute hints, pipeline merges) while sub-trees are still proving.
+     * The promise resolves to 1 entry for a single-block checkpoint, 2 for multi-block.
+     */
+    blockProofs: Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>[]>;
+    /** L2-to-L1 messages per block in the checkpoint, used to compute the out hash. */
+    l2ToL1MsgsPerBlock: Fr[][][];
+    /** Blob fields encoding the checkpoint's tx effects, used to compute the blob accumulator. */
+    blobFields: Fr[];
+    /** Header of the last block in the previous checkpoint (or the epoch's predecessor for index 0). */
+    previousBlockHeader: BlockHeader;
+    /** Sibling path of the archive tree before any block in this checkpoint landed. */
+    previousArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>;
+};
+/** Result of proving the top tree. */
+export type TopTreeResult = {
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+    batchedBlobInputs: BatchedBlob;
+};
+/**
+ * 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 declare class TopTreeCancelledError extends Error {
+    constructor(reason?: string);
+}
+/**
+ * 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 declare class TopTreeOrchestrator extends TopTreeProvingScheduler {
+    private readonly proverId;
+    private state;
+    private cancelled;
+    constructor(prover: ServerCircuitProver, proverId: EthAddress, enqueueConcurrency: number, _telemetryClient?: TelemetryClient, bindings?: LoggerBindings);
+    getProverId(): EthAddress;
+    /**
+     * 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.
+     */
+    prove(epochNumber: EpochNumber, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, checkpointData: CheckpointTopTreeData[]): Promise<TopTreeResult>;
+    /**
+     * 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 }: {
+        abortJobs: boolean;
+    }): void;
+    /** Standard shutdown — preserve the broker queue (`abortJobs: false`). */
+    protected cancelInternal(): void;
+    protected onRootRollupComplete(state: TopTreeProvingState): void;
+    private enqueueCheckpointRoot;
+    private buildCheckpointRootInputs;
+    private computeOutHashHints;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"top-tree-orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,yCAAyC,EAE/C,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAGnE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE1G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EACL,KAAK,uBAAuB,EAI5B,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAGnF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,iDAAiD;AACjD,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAClB,6BAA6B,CAAC,uBAAuB,EAAE,OAAO,yCAAyC,CAAC,EAAE,CAC3G,CAAC;IACF,mFAAmF;IACnF,kBAAkB,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;IAC7B,8FAA8F;IAC9F,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,oGAAoG;IACpG,mBAAmB,EAAE,WAAW,CAAC;IACjC,mFAAmF;IACnF,0BAA0B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,cAAc,CAAC,CAAC;CAC9D,CAAC;AAEF,sCAAsC;AACtC,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,EAAE,sBAAsB,CAAC;IACrC,KAAK,EAAE,KAAK,CAAC;IACb,iBAAiB,EAAE,WAAW,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,MAAM,SAA+B,EAGhD;CACF;AAOD;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,SAAQ,uBAAuB;IAM5D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAL3B,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,SAAS,CAAS;IAE1B,YACE,MAAM,EAAE,mBAAmB,EACV,QAAQ,EAAE,UAAU,EACrC,kBAAkB,EAAE,MAAM,EAC1B,gBAAgB,GAAE,eAAsC,EACxD,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAEM,WAAW,IAAI,UAAU,CAE/B;IAED;;;;OAIG;IACU,KAAK,CAChB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,EACxD,cAAc,EAAE,qBAAqB,EAAE,GACtC,OAAO,CAAC,aAAa,CAAC,CAqFxB;IAED;;;;;OAKG;IACI,MAAM,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,QAIlD;IAED,4EAA0E;IAC1E,UAAmB,cAAc,IAAI,IAAI,CAExC;IAID,UAAmB,oBAAoB,CAAC,KAAK,EAAE,mBAAmB,QAEjE;IAED,OAAO,CAAC,qBAAqB;YAiCf,yBAAyB;YA6BzB,mBAAmB;CAyBlC"}

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

@@ -0,0 +1,182 @@
+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 { TopTreeProvingScheduler } from './top-tree-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 TopTreeProvingScheduler {
+    proverId;
+    state;
+    cancelled;
+    constructor(prover, proverId, enqueueConcurrency, _telemetryClient = getTelemetryClient(), bindings){
+        super(prover, enqueueConcurrency, 'prover-client:top-tree-orchestrator', bindings), 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 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.
+        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}`);
+            });
+        }
+        try {
+            await completionPromise;
+            await this.state.finalizeBatchedBlob();
+            return this.state.getEpochProofResult();
+        } catch (err) {
+            if (this.cancelled) {
+                throw new TopTreeCancelledError();
+            }
+            throw err;
+        }
+    }
+    /**
+   * 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 ---
+    onRootRollupComplete(state) {
+        state.resolve();
+    }
+    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);
+                }
+            });
+        });
+    }
+    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);
+    }
+    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-scheduler.d.ts

@@ -0,0 +1,62 @@
+import type { NESTED_RECURSIVE_PROOF_LENGTH, 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 { TreeNodeLocation } from '@aztec/foundation/trees';
+import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, CheckpointRollupPublicInputs, RootRollupPrivateInputs, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import { ProvingScheduler, type ProvingStateLike } from './proving-scheduler.js';
+type CheckpointRollupProof = PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+type RootRollupProof = PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>;
+/**
+ * State interface required by the top-tree proving drivers (checkpoint-merge → padding →
+ * root-rollup). Both `EpochProvingState` and `TopTreeProvingState` satisfy it structurally;
+ * the per-checkpoint state in `EpochProvingState` (block/tx proving, world-state forks)
+ * is owned outside this surface.
+ */
+export interface TopTreeStateLike extends ProvingStateLike {
+    readonly epochNumber: EpochNumber;
+    readonly totalNumCheckpoints: number;
+    tryStartProvingCheckpointMerge(location: TreeNodeLocation): boolean;
+    setCheckpointMergeRollupProof(location: TreeNodeLocation, provingOutput: CheckpointRollupProof): void;
+    isReadyForCheckpointMerge(location: TreeNodeLocation): boolean;
+    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
+    getCheckpointMergeRollupInputs(location: TreeNodeLocation): CheckpointMergeRollupPrivateInputs;
+    tryStartProvingPaddingCheckpoint(): boolean;
+    setCheckpointPaddingProof(provingOutput: CheckpointRollupProof): void;
+    getPaddingCheckpointInputs(): CheckpointPaddingRollupPrivateInputs;
+    tryStartProvingRootRollup(): boolean;
+    setRootRollupProof(provingOutput: RootRollupProof): void;
+    isReadyForRootRollup(): boolean;
+    getRootRollupInputs(): RootRollupPrivateInputs;
+}
+/**
+ * Shared scheduling for the top-tree section of epoch proving — checkpoint-merge,
+ * padding (single-checkpoint case), and root rollup. Both `ProvingOrchestrator` and
+ * `TopTreeOrchestrator` extend this; their per-checkpoint-root drivers diverge (one
+ * drains state-derived inputs once block-merge is done, the other builds inputs from
+ * caller-supplied checkpoint data), but the rest of the tree is identical.
+ *
+ * Subclasses provide a `wrapCircuitCall` hook for telemetry (the orchestrator wraps
+ * each call in a span; the top-tree leaves it as identity), and an
+ * `onRootRollupComplete` hook to invoke the right shape of `state.resolve()` —
+ * `EpochProvingState.resolve` takes a `ProvingResult`, `TopTreeProvingState.resolve`
+ * is no-arg.
+ */
+export declare abstract class TopTreeProvingScheduler extends ProvingScheduler {
+    protected readonly prover: ServerCircuitProver;
+    constructor(prover: ServerCircuitProver, enqueueConcurrency: number, loggerName?: string, bindings?: LoggerBindings);
+    /**
+     * Wraps a circuit call for telemetry. Default is identity; the orchestrator overrides
+     * to wrap with `wrapCallbackInSpan`.
+     */
+    protected wrapCircuitCall<T>(_circuitName: string, fn: (signal: AbortSignal) => Promise<T>): (signal: AbortSignal) => Promise<T>;
+    /** Called once the root rollup proof has been set; subclasses call `state.resolve(...)` with the right shape. */
+    protected abstract onRootRollupComplete(state: TopTreeStateLike): void;
+    protected enqueueCheckpointMergeRollup(state: TopTreeStateLike, location: TreeNodeLocation): void;
+    protected enqueueEpochPadding(state: TopTreeStateLike): void;
+    protected enqueueRootRollup(state: TopTreeStateLike): void;
+    protected checkAndEnqueueNextCheckpointMergeRollup(state: TopTreeStateLike, currentLocation: TreeNodeLocation): void;
+    protected checkAndEnqueueRootRollup(state: TopTreeStateLike): void;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"top-tree-proving-scheduler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-proving-scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AACjH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC1G,OAAO,KAAK,EACV,kCAAkC,EAClC,oCAAoC,EACpC,4BAA4B,EAC5B,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAEjF,KAAK,qBAAqB,GAAG,6BAA6B,CACxD,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,CAAC;AAEF,KAAK,eAAe,GAAG,6BAA6B,CAAC,sBAAsB,EAAE,OAAO,6BAA6B,CAAC,CAAC;AAEnH;;;;;GAKG;AACH,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IAErC,8BAA8B,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;IACpE,6BAA6B,CAAC,QAAQ,EAAE,gBAAgB,EAAE,aAAa,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACtG,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAC/D,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,gBAAgB,CAAC;IAChE,8BAA8B,CAAC,QAAQ,EAAE,gBAAgB,GAAG,kCAAkC,CAAC;IAE/F,gCAAgC,IAAI,OAAO,CAAC;IAC5C,yBAAyB,CAAC,aAAa,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACtE,0BAA0B,IAAI,oCAAoC,CAAC;IAEnE,yBAAyB,IAAI,OAAO,CAAC;IACrC,kBAAkB,CAAC,aAAa,EAAE,eAAe,GAAG,IAAI,CAAC;IACzD,oBAAoB,IAAI,OAAO,CAAC;IAChC,mBAAmB,IAAI,uBAAuB,CAAC;CAChD;AAED;;;;;;;;;;;;GAYG;AACH,8BAAsB,uBAAwB,SAAQ,gBAAgB;IAElE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,mBAAmB;IADhD,YACqB,MAAM,EAAE,mBAAmB,EAC9C,kBAAkB,EAAE,MAAM,EAC1B,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED;;;OAGG;IACH,SAAS,CAAC,eAAe,CAAC,CAAC,EACzB,YAAY,EAAE,MAAM,EACpB,EAAE,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GACtC,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,CAErC;IAED,iHAAiH;IACjH,SAAS,CAAC,QAAQ,CAAC,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAEvE,SAAS,CAAC,4BAA4B,CAAC,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,gBAAgB,QAezF;IAED,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,QAepD;IAED,SAAS,CAAC,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,QAclD;IAED,SAAS,CAAC,wCAAwC,CAAC,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,QAU5G;IAED,SAAS,CAAC,yBAAyB,CAAC,KAAK,EAAE,gBAAgB,QAK1D;CACF"}

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

@@ -0,0 +1,73 @@
+import { ProvingScheduler } from './proving-scheduler.js';
+/**
+ * Shared scheduling for the top-tree section of epoch proving — checkpoint-merge,
+ * padding (single-checkpoint case), and root rollup. Both `ProvingOrchestrator` and
+ * `TopTreeOrchestrator` extend this; their per-checkpoint-root drivers diverge (one
+ * drains state-derived inputs once block-merge is done, the other builds inputs from
+ * caller-supplied checkpoint data), but the rest of the tree is identical.
+ *
+ * Subclasses provide a `wrapCircuitCall` hook for telemetry (the orchestrator wraps
+ * each call in a span; the top-tree leaves it as identity), and an
+ * `onRootRollupComplete` hook to invoke the right shape of `state.resolve()` —
+ * `EpochProvingState.resolve` takes a `ProvingResult`, `TopTreeProvingState.resolve`
+ * is no-arg.
+ */ export class TopTreeProvingScheduler extends ProvingScheduler {
+    prover;
+    constructor(prover, enqueueConcurrency, loggerName, bindings){
+        super(enqueueConcurrency, loggerName, bindings), this.prover = prover;
+    }
+    /**
+   * Wraps a circuit call for telemetry. Default is identity; the orchestrator overrides
+   * to wrap with `wrapCallbackInSpan`.
+   */ wrapCircuitCall(_circuitName, fn) {
+        return fn;
+    }
+    enqueueCheckpointMergeRollup(state, location) {
+        if (!state.verifyState() || !state.tryStartProvingCheckpointMerge(location)) {
+            return;
+        }
+        const inputs = state.getCheckpointMergeRollupInputs(location);
+        this.deferredProving(state, this.wrapCircuitCall('rollup-checkpoint-merge', (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, this.wrapCircuitCall('rollup-checkpoint-padding', (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, this.wrapCircuitCall('rollup-root', (signal)=>this.prover.getRootRollupProof(inputs, signal, state.epochNumber)), (result)=>{
+            this.logger.verbose(`Completed root rollup for epoch ${state.epochNumber}`);
+            state.setRootRollupProof(result);
+            this.onRootRollupComplete(state);
+        });
+    }
+    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);
+    }
+}