@aztec/prover-client 0.0.1-commit.7b97ef96e → 0.0.1-commit.7cbc774

package/dest/orchestrator/orchestrator.js

@@ -371,16 +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 { assertLength } from '@aztec/foundation/serialize';
 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';
@@ -388,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
@@ -409,9 +407,8 @@ _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;
     static{
@@ -444,22 +441,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         ], []));
     }
     provingState;
-    pendingProvingJobs;
     provingPromise;
     metrics;
-    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
     dbs;
-    logger;
-    constructor(dbProvider, prover, proverId, cancelJobsOnStop = false, telemetryClient = getTelemetryClient(), bindings){
-        this.dbProvider = dbProvider;
-        this.prover = prover;
-        this.proverId = proverId;
-        this.cancelJobsOnStop = cancelJobsOnStop;
-        this.provingState = (_initProto(this), undefined);
-        this.pendingProvingJobs = [];
-        this.provingPromise = undefined;
-        this.dbs = new Map();
-        this.logger = createLogger('prover-client:orchestrator', bindings);
+    constructor(dbProvider, prover, proverId, cancelJobsOnStop = false, enqueueConcurrency, telemetryClient = getTelemetryClient(), 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');
     }
     get tracer() {
@@ -471,9 +457,18 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     getNumActiveForks() {
         return this.dbs.size;
     }
-    stop() {
+    cancelInternal() {
         this.cancel();
-        return Promise.resolve();
+    }
+    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()) {
@@ -733,11 +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() {
-        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));
@@ -769,61 +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);
-                }
-            }
-        };
-        // let the callstack unwind before adding the job to the queue
-        setImmediate(()=>void safeJob());
-    }
     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 {
@@ -902,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
@@ -977,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
@@ -1049,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);
         });
@@ -1081,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) {
@@ -1091,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;
@@ -1181,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

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"}