@aztec/prover-node 5.0.0-nightly.20260709 → 5.0.0-nightly.20260711

package/README.md

@@ -35,7 +35,6 @@ flowchart TB
   SessionManager --> EpochTicker[(periodic tick)]
   SessionManager --> FullSessions[(fullSessions)]
   SessionManager --> PartialSessions[(partialSessions)]
-  CheckpointStore --> SlotWatcher
   FullSessions -.referenced checkpoints.-> CheckpointStore
   PartialSessions -.referenced checkpoints.-> CheckpointStore
   FullSessions --> TopTreeJob
@@ -56,8 +55,9 @@ The prover-node splits responsibility between four classes:
 - **`CheckpointStore`** — a registry of `CheckpointProver` instances keyed by
   `(checkpointNumber, slot, archiveRoot)`. Each `CheckpointProver` runs its own sub-tree pipeline
   (tx gather → block processing → block-rollup proofs), starting eagerly the moment a
-  checkpoint is registered. The store is the single source of canonical-vs-pruned
-  checkpoint content that `EpochSession`s query when assembling their subsets.
+  checkpoint is registered. The store holds the canonical checkpoint content that
+  `EpochSession`s query when assembling their subsets; a prune cancels and removes the affected
+  provers, so every prover in the store is canonical.
 - **`SessionManager`** — owns every live `EpochSession`, the serial reconcile queue,
   the periodic tick, and all `EpochSession` lifecycle decisions. `ProverNode` calls into it
   via `onCheckpointAdded`, `onPrune`, and `startProof`. Every trigger it receives is
@@ -81,43 +81,38 @@ A `CheckpointProver` is content-addressed by `(checkpoint.number, slot, archiveR
 where `archiveRoot` is the checkpoint's own archive root (its post-state). Keying on the
 post-state makes the identity precise: two checkpoints are "the same" iff they produce
 the same archive — so a reorg branch, or a replacement built on the same predecessor but
-with different content, yields a different archive root and a distinct `CheckpointProver`, while an
-identical re-add collapses to the same `CheckpointProver` and reuses its in-flight work.
+with different content, yields a different archive root and a distinct `CheckpointProver`. A prune
+cancels and removes a prover — its sub-tree work forks world-state per block and cannot survive the
+prune — so a re-add, even of identical content, constructs a fresh `CheckpointProver` (block-rollup
+jobs already completed in the proving broker are still reused, as they are content-addressed).
 
 ```mermaid
 stateDiagram-v2
   [*] --> Created
   Created --> Proving: gather + execute
   Proving --> Proven: sub-tree resolves blockProofs
-  Proving --> Cancelled: cancel()
+  Proving --> Cancelled: cancel() (prune / shutdown / epoch-session error)
+  Proven --> Cancelled: cancel() (prune / reap)
   Proven --> Reaped: reapExpired(epoch)
   Cancelled --> [*]
-
-  state "Pruned (side)" as Pruned
-  Proving --> Pruned: markPruned()
-  Pruned --> Proving: markCanonical()
-  Proven --> Pruned: markPruned()
-  Pruned --> Reaped: SlotWatcher (slot < syncedSlot)
 ```
 
-The **`Pruned`** state is a side flag, not a place in the main lifecycle: sub-tree
-proving keeps running underneath, so a brief reorg that prunes and immediately
-re-adds the same checkpoint avoids any re-proving.  The flag only gates *eligibility*
-to be included in an `EpochSession` — `EpochSession`s ask the store for *canonical* (non-pruned)
-checkpoints when assembling their subsets.
-
-### Reaping rules
-
-- **Pruned**: the `SlotWatcher` (a `RunningPromise` polling
-  `l2BlockSource.getSyncedL2SlotNumber`) reaps a pruned `CheckpointProver` when the chain's
-  synced slot has moved past the `CheckpointProver`'s slot.  Once the chain is past that slot,
-  a re-add with the same content is impossible.
-- **Canonical**: `CheckpointStore.reapExpired(expiredEpoch)` drops any canonical
-  `CheckpointProver` whose epoch is at or below the supplied expired epoch. Once an epoch's
-  proof-submission window has closed, its proof can no longer be accepted on L1,
-  so the `CheckpointProver` is no longer needed.
-- **Cancelled**: removed immediately by whichever path called `cancel()` (store
-  shutdown, prune past-slot, `EpochSession` error).
+A prune **cancels and removes** the affected `CheckpointProver`s from the store: a prover's
+sub-tree work forks world-state per block, and an L1 prune of a base block faults those reads,
+so there is nothing to preserve across a reorg. A re-add — even of identical content — therefore
+constructs a fresh `CheckpointProver`. `EpochSession`s ask the store for the checkpoints in a slot
+range; every prover in the store is canonical.
+
+### Removal rules
+
+- **Pruned**: `CheckpointStore.cancelAndRemoveAboveBlock(target)` cancels and removes every
+  `CheckpointProver` whose last block is above the prune target, the moment a `chain-pruned`
+  event arrives.
+- **Expired**: `CheckpointStore.reapExpired(expiredEpoch)` drops any `CheckpointProver` whose
+  epoch is at or below the supplied expired epoch. Once an epoch's proof-submission window has
+  closed, its proof can no longer be accepted on L1, so the `CheckpointProver` is no longer needed.
+- **Shutdown**: `CheckpointStore.stop()` cancels every remaining prover and awaits its teardown
+  (including teardowns still in flight for provers already removed by a prune or reap).
 
 ### Eager tx gathering
 
@@ -288,8 +283,8 @@ sequenceDiagram
   alt content key new
     CS->>CP: new CheckpointProver(args)
     CP->>CP: eager gather + sub-tree start
-  else content key matches
-    CS->>CP: markCanonical()
+  else content key already live
+    CS->>CP: reuse existing prover
   end
   PN->>SM: onCheckpointAdded(epoch)
   SM->>SM: queue reconcile({kind:'checkpoint', epoch})
@@ -306,9 +301,9 @@ sequenceDiagram
   participant CS as CheckpointStore
   participant SM as SessionManager
 
-  L2->>PN: chain-pruned{checkpoint}
-  PN->>CS: markPrunedAfter(checkpoint.number)
-  CS->>CS: flip every CheckpointProver above threshold to pruned (sub-tree keeps running)
+  L2->>PN: chain-pruned{block}
+  PN->>CS: cancelAndRemoveAboveBlock(prunedToBlock)
+  CS->>CS: cancel + remove every CheckpointProver whose last block is above the target
   PN->>SM: onPrune(affectedEpochs)
   SM->>SM: queue reconcile({kind:'prune', affectedEpochs})
   SM->>SM: walk EpochSessions, cancel-and-recreate those with shifted content
@@ -371,30 +366,28 @@ indexing) leave the mark in place and the next tick retries.
 
 ### checkpoint-added → prune → checkpoint-added (reorg resilience)
 
-State: epoch N has checkpoints c1..c4 all canonical (slots s1..s4).  `fullSessions[N]`
-holds `EpochSession` **A** with spec `{kind:'full', N, fromSlot:s1, toSlot:s4}`, referencing
-checkpoints `[c1, c2, c3, c4]`.
+State: epoch N has checkpoints c1..c4 (slots s1..s4).  `fullSessions[N]` holds `EpochSession`
+**A** with spec `{kind:'full', N, fromSlot:s1, toSlot:s4}`, referencing `[c1, c2, c3, c4]`.
 
-1. **chain-pruned arrives, target c3.**  Store flips c4 to pruned.  Reconcile fires:
-   for `EpochSession` A, canonical content for `(s1, s4)` is now `[c1, c2, c3]` (c4 pruned).
-   The frozen set `[c1, c2, c3, c4]` no longer matches → `A.cancel('canonical content
-   changed')`.  Epoch N still complete on L1 → reconcile constructs `EpochSession` **B** with
-   the same spec `{full, N, s1, s4}` but checkpoints `[c1, c2, c3]`.
+1. **chain-pruned arrives, target c3.**  The store cancels and removes c4 (its last block is
+   above the prune target).  Reconcile fires: `EpochSession` A's frozen set `[c1, c2, c3, c4]`
+   includes the now-cancelled c4, so it no longer matches the store's `[c1, c2, c3]` →
+   `A.cancel('canonical content changed')`.  Epoch N still complete on L1 → reconcile constructs
+   `EpochSession` **B** with the same spec `{full, N, s1, s4}` but checkpoints `[c1, c2, c3]`.
 
 2. **`EpochSession` B starts top-tree proving over [c1, c2, c3].**
 
-3. **chain-checkpointed arrives, target c4_re (same content key as old c4).**  The
-   store finds the existing `CheckpointProver` at `(c4.number, s4, c4.archive.root)`
-   and calls `markCanonical()`.  The sub-tree work that never stopped is visible to
-   `EpochSession`s again.  (A re-add with *different* content would have a different archive
-   root and so get a fresh `CheckpointProver` instead.)
+3. **chain-checkpointed arrives, target c4_re (same content key as old c4).**  The old c4
+   prover was removed on the prune, so the store constructs a **fresh** `CheckpointProver` for
+   c4_re and starts its sub-tree work from scratch.  (Its block-rollup jobs are content-addressed
+   in the proving broker, so any the old c4 already completed are reused rather than re-proved.)
 
-4. **Reconcile fires.**  `EpochSession` B's canonical content for `(s1, s4)` is now `[c1, c2,
-   c3, c4]`, doesn't match its frozen `[c1, c2, c3]` → `B.cancel(...)`.  Construct
-   `EpochSession` **C** with same spec but checkpoints `[c1, c2, c3, c4]`.
+4. **Reconcile fires.**  `EpochSession` B's content for `(s1, s4)` is now `[c1, c2, c3, c4_re]`,
+   doesn't match its frozen `[c1, c2, c3]` → `B.cancel(...)`.  Construct `EpochSession` **C** with
+   the same spec but checkpoints `[c1, c2, c3, c4_re]`.
 
-5. **`EpochSession` C reuses the long-lived c1..c4 `CheckpointProver` instances.**  Sub-tree
-   work may already be complete; only the top-tree is recomputed.  The chonk cache
+5. **`EpochSession` C reuses the long-lived c1..c3 `CheckpointProver` instances and the fresh
+   c4_re.**  Only c4_re's witnesses are regenerated; the top-tree is recomputed.  The chonk cache
    survived the reorg because no epoch in this range has expired yet.
 
 
@@ -466,19 +459,19 @@ Keying by tx hash makes the cache survive any reorg up to finality; releasing on
 finality means we don't grow the cache indefinitely while still keeping every
 reorg-relevant proof.
 
-### Why does the slot watcher only reap pruned `CheckpointProver`s?
+### Why is a pruned `CheckpointProver` removed rather than kept for a possible re-add?
 
-Canonical `CheckpointProver`s can't be reaped on a slot heuristic — they're still part of the
-proven-chain story.  Pruned `CheckpointProver`s, on the other hand, are only kept around in
-case the chain re-adds the same content; once the synced slot has moved past, that
-re-add is impossible, and the `CheckpointProver` can go.  Finality is the right signal for
-canonical reaping, because finality is the only state that rules out future reorgs.
+A prover's sub-tree work forks world-state per block, and an L1 prune of a base block faults
+those in-flight reads — so the work cannot survive the prune, and there is nothing to preserve
+by keeping the prover around.  Removing it on prune and rebuilding on re-add is therefore both
+correct and simpler; the expensive block-rollup proofs are still reused when content re-appears,
+because the proving broker is content-addressed independently of the prover's lifetime.
 
 ## Configuration
 
 | Env var | Description |
 |---|---|
-| `PROVER_NODE_POLLING_INTERVAL_MS` | Polling interval for the L2BlockStream, the checkpoint-store slot watcher, and the SessionManager periodic tick.  Default 1000 ms. |
+| `PROVER_NODE_POLLING_INTERVAL_MS` | Polling interval for the L2BlockStream and the SessionManager periodic tick.  Default 1000 ms. |
 | `PROVER_NODE_MAX_PENDING_JOBS` | Cap on the number of non-terminal `EpochSession`s (full + partial).  When at limit, reconcile defers opening new full `EpochSession`s; explicit `startProof` calls throw. |
 | `PROVER_NODE_EPOCH_PROVING_DELAY_MS` | Optional sleep at the start of each `EpochSession`, before the TopTreeJob is constructed.  Used in tests to give late events time to land. |
 | `TX_GATHERING_TIMEOUT_MS` | Per-block tx gather deadline used by each `CheckpointProver`. |

package/dest/checkpoint-store.d.ts

@@ -14,74 +14,75 @@ export type CheckpointProverFactory = (args: CheckpointProverArgs, deps: Checkpo
  *
  * The store survives every epoch / session boundary. A prover lives from its first
  * `addOrUpdate` call until either:
- *  - it has been pruned and the L2 chain has moved past its slot (no re-add possible), or
+ *  - its checkpoint is pruned by an L1 reorg (`cancelAndRemoveAboveBlock`), or
  *  - its epoch's proof-submission window has closed (`reapExpired`), so the proof could no
  *    longer be accepted on L1 even if produced.
  *
- * A re-add of a checkpoint that matches an existing prover's content key reuses the
- * existing prover (and flips it back to canonical); the in-flight sub-tree work never
- * stops, so a prune-then-re-add of the same content avoids re-proving entirely.
+ * A prover's sub-tree work forks world-state per block and does not survive a prune of a base
+ * block, so there is nothing to preserve across a reorg: a pruned prover is cancelled and
+ * dropped, and a re-add (even of identical content) constructs a fresh prover.
  */
 export declare class CheckpointStore {
     private readonly l2BlockSource;
     private readonly proverDeps;
-    private readonly options;
     private readonly proverFactoryFn;
     private readonly provers;
-    private readonly slotWatcher;
+    /**
+     * Teardowns of provers already removed from `provers` (by prune or reap), awaited on `stop()`.
+     * Keyed by a monotonic id rather than the prover's content id: a prune-then-re-add can leave two
+     * teardowns for the same content id in flight at once, which a content-id key would clobber.
+     */
+    private readonly pendingTeardowns;
+    private nextTeardownId;
     private readonly log;
-    constructor(l2BlockSource: Pick<L2BlockSource, 'getSyncedL2SlotNumber' | 'getL1Constants'>, proverDeps: Omit<CheckpointProverDeps, 'log'>, options: {
-        slotWatcherPollIntervalMs: number;
-    }, bindings?: LoggerBindings, proverFactoryFn?: CheckpointProverFactory);
+    constructor(l2BlockSource: Pick<L2BlockSource, 'getL1Constants'>, proverDeps: Omit<CheckpointProverDeps, 'log'>, bindings?: LoggerBindings, proverFactoryFn?: CheckpointProverFactory);
     start(): Promise<void>;
     stop(): Promise<void>;
+    /**
+     * Tracks the teardown of a prover just removed from the store so `stop()` can await it. The entry
+     * removes itself once teardown settles, so the map stays bounded by the number in flight.
+     */
+    private trackTeardown;
     /**
      * Registers a checkpoint with the store. If a prover already exists for the
-     * `(number, slot, archive root)` content key, it is reused and marked canonical;
-     * otherwise a new prover is constructed.
+     * `(number, slot, archive root)` content key it is reused (an at-least-once re-registration of
+     * still-canonical content); otherwise a new prover is constructed.
      */
     addOrUpdate(checkpoint: Checkpoint, data: RegisterCheckpointData): Promise<CheckpointProver>;
     /**
-     * Marks every canonical prover that holds a block above the prune target as pruned. A checkpoint is orphaned by a
-     * prune to block `targetBlockNumber` iff its last block sits above the target — including a checkpoint whose range
-     * straddles the target (partially orphaned), which block-range marking catches without boundary ambiguity. Keying
-     * off the surviving block number (rather than a checkpoint number) is correct even when the source has already
+     * Cancels and removes every prover that holds a block above the prune target. A checkpoint is orphaned by a prune to
+     * block `targetBlockNumber` iff its last block sits above the target — including a checkpoint whose range straddles
+     * the target (partially orphaned), which block-range marking catches without boundary ambiguity. Keying off the
+     * surviving block number (rather than a checkpoint number) is correct even when the source has already
      * re-checkpointed past the divergence: the prune event reports the highest surviving block, which by construction
      * survives on the source, whereas the source's current checkpointed tip can sit above the prune target.
-     * Sub-tree work keeps running so a re-add of the same content can pick it up. Returns the affected provers.
+     *
+     * The prover's in-flight sub-tree work forks world-state per block and faults once its base block is pruned, so it
+     * cannot be reused; it is cancelled (aborting the fork reads) and dropped. A subsequent re-add constructs a fresh
+     * prover. Returns the removed provers.
      */
-    markPrunedAboveBlock(targetBlockNumber: BlockNumber): CheckpointProver[];
+    cancelAndRemoveAboveBlock(targetBlockNumber: BlockNumber): CheckpointProver[];
     /**
-     * Drops canonical (non-pruned) provers whose epoch is at or below the supplied expired
-     * epoch. Once an epoch's proof-submission window has closed, its proof can no longer be
-     * accepted on L1, so the prover is no longer needed.
+     * Drops provers whose epoch is at or below the supplied expired epoch. Once an epoch's
+     * proof-submission window has closed, its proof can no longer be accepted on L1, so the
+     * prover is no longer needed.
      */
     reapExpired(expiredEpoch: EpochNumber): void;
     /** Returns the prover with the supplied id, or undefined. */
     get(id: string): CheckpointProver | undefined;
     /** Returns the prover for the supplied checkpoint (by its content-addressed id), or undefined. */
     getByCheckpoint(checkpoint: Checkpoint): CheckpointProver | undefined;
-    /** Every prover currently in the store (canonical and pruned), in insertion order. */
+    /** Every prover currently in the store, in insertion order. */
     listAll(): CheckpointProver[];
-    /** Canonical (non-pruned) provers in the store, sorted by checkpoint number. */
-    listCanonical(): CheckpointProver[];
-    /**
-     * Canonical provers whose slot is in the supplied epoch's slot range, sorted by
-     * checkpoint number.
-     */
-    listCanonicalForEpoch(epoch: EpochNumber): Promise<CheckpointProver[]>;
-    /** Canonical provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */
-    listCanonicalInSlotRange(fromSlot: SlotNumber, toSlot: SlotNumber): CheckpointProver[];
+    /** Provers in the store, sorted by checkpoint number. */
+    list(): CheckpointProver[];
     /**
-     * SlotWatcher tick: reap pruned provers whose slot has passed the chain's synced
-     * slot. Once the chain has moved past, no re-add can revive the prover and its
-     * content key is unique enough that an actual re-add would create a new entry.
-     *
-     * Protected so unit tests can drive a single tick without spinning up the
-     * `RunningPromise` and waiting on its interval.
+     * Provers whose slot is in the supplied epoch's slot range, sorted by checkpoint number.
      */
-    protected reapPrunedPastSlot(): Promise<void>;
+    listForEpoch(epoch: EpochNumber): Promise<CheckpointProver[]>;
+    /** Provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */
+    listInSlotRange(fromSlot: SlotNumber, toSlot: SlotNumber): CheckpointProver[];
 }
 /** Sub-set of `L1RollupConstants` actually consumed by the store's slot helpers. */
 export type CheckpointStoreL1Constants = Pick<L1RollupConstants, 'epochDuration'>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2twb2ludC1zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NoZWNrcG9pbnQtc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFvQixXQUFXLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDOUcsT0FBTyxFQUFlLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBRXZGLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzNELE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUF3QyxNQUFNLDZCQUE2QixDQUFDO0FBRTNHLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxLQUFLLG9CQUFvQixFQUFFLEtBQUssb0JBQW9CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUVwSCw4R0FBOEc7QUFDOUcsTUFBTSxNQUFNLHNCQUFzQixHQUFHLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxZQUFZLEdBQUcsYUFBYSxDQUFDLENBQUM7QUFFOUYsbUZBQW1GO0FBQ25GLE1BQU0sTUFBTSx1QkFBdUIsR0FBRyxDQUFDLElBQUksRUFBRSxvQkFBb0IsRUFBRSxJQUFJLEVBQUUsb0JBQW9CLEtBQUssZ0JBQWdCLENBQUM7QUFFbkg7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNILHFCQUFhLGVBQWU7SUFNeEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxhQUFhO0lBQzlCLE9BQU8sQ0FBQyxRQUFRLENBQUMsVUFBVTtJQUMzQixPQUFPLENBQUMsUUFBUSxDQUFDLE9BQU87SUFFeEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxlQUFlO0lBVGxDLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUF1QztJQUMvRCxPQUFPLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBaUI7SUFDN0MsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQVM7SUFFN0IsWUFDbUIsYUFBYSxFQUFFLElBQUksQ0FBQyxhQUFhLEVBQUUsdUJBQXVCLEdBQUcsZ0JBQWdCLENBQUMsRUFDOUUsVUFBVSxFQUFFLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxLQUFLLENBQUMsRUFDN0MsT0FBTyxFQUFFO1FBQUUseUJBQXlCLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFDL0QsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUNSLGVBQWUsR0FBRSx1QkFBMEUsRUFRN0c7SUFFTSxLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUc1QjtJQUVZLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBU2pDO0lBRUQ7Ozs7T0FJRztJQUNVLFdBQVcsQ0FBQyxVQUFVLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxzQkFBc0IsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0EwQnhHO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSSxvQkFBb0IsQ0FBQyxpQkFBaUIsRUFBRSxXQUFXLEdBQUcsZ0JBQWdCLEVBQUUsQ0FVOUU7SUFFRDs7OztPQUlHO0lBQ0ksV0FBVyxDQUFDLFlBQVksRUFBRSxXQUFXLEdBQUcsSUFBSSxDQW9CbEQ7SUFFRCw2REFBNkQ7SUFDdEQsR0FBRyxDQUFDLEVBQUUsRUFBRSxNQUFNLEdBQUcsZ0JBQWdCLEdBQUcsU0FBUyxDQUVuRDtJQUVELGtHQUFrRztJQUMzRixlQUFlLENBQUMsVUFBVSxFQUFFLFVBQVUsR0FBRyxnQkFBZ0IsR0FBRyxTQUFTLENBRTNFO0lBRUQsc0ZBQXNGO0lBQy9FLE9BQU8sSUFBSSxnQkFBZ0IsRUFBRSxDQUVuQztJQUVELGdGQUFnRjtJQUN6RSxhQUFhLElBQUksZ0JBQWdCLEVBQUUsQ0FJekM7SUFFRDs7O09BR0c7SUFDVSxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDLENBSWxGO0lBRUQsbUdBQW1HO0lBQzVGLHdCQUF3QixDQUFDLFFBQVEsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLFVBQVUsR0FBRyxnQkFBZ0IsRUFBRSxDQUU1RjtJQUVEOzs7Ozs7O09BT0c7SUFDSCxVQUFnQixrQkFBa0IsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBc0JsRDtDQUNGO0FBRUQsb0ZBQW9GO0FBQ3BGLE1BQU0sTUFBTSwwQkFBMEIsR0FBRyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsZUFBZSxDQUFDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dest/checkpoint-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkpoint-store.d.ts","sourceRoot":"","sources":["../src/checkpoint-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAoB,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC9G,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,6BAA6B,CAAC;AAE3G,OAAO,EAAE,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEpH,8GAA8G;AAC9G,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,oBAAoB,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC;AAE9F,mFAAmF;AACnF,MAAM,MAAM,uBAAuB,GAAG,CAAC,IAAI,EAAE,oBAAoB,EAAE,IAAI,EAAE,oBAAoB,KAAK,gBAAgB,CAAC;AAEnH;;;;;;;;;;;;;GAaG;AACH,qBAAa,eAAe;IAMxB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,eAAe;IATlC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiB;IAC7C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,uBAAuB,GAAG,gBAAgB,CAAC,EAC9E,UAAU,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,EAC7C,OAAO,EAAE;QAAE,yBAAyB,EAAE,MAAM,CAAA;KAAE,EAC/D,QAAQ,CAAC,EAAE,cAAc,EACR,eAAe,GAAE,uBAA0E,EAQ7G;IAEM,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAG5B;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CASjC;IAED;;;;OAIG;IACU,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0BxG;IAED;;;;;;;;OAQG;IACI,oBAAoB,CAAC,iBAAiB,EAAE,WAAW,GAAG,gBAAgB,EAAE,CAU9E;IAED;;;;OAIG;IACI,WAAW,CAAC,YAAY,EAAE,WAAW,GAAG,IAAI,CAoBlD;IAED,6DAA6D;IACtD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEnD;IAED,kGAAkG;IAC3F,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAE3E;IAED,sFAAsF;IAC/E,OAAO,IAAI,gBAAgB,EAAE,CAEnC;IAED,gFAAgF;IACzE,aAAa,IAAI,gBAAgB,EAAE,CAIzC;IAED;;;OAGG;IACU,qBAAqB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAIlF;IAED,mGAAmG;IAC5F,wBAAwB,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,gBAAgB,EAAE,CAE5F;IAED;;;;;;;OAOG;IACH,UAAgB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAsBlD;CACF;AAED,oFAAoF;AACpF,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC"}
+{"version":3,"file":"checkpoint-store.d.ts","sourceRoot":"","sources":["../src/checkpoint-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAoB,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC9G,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,6BAA6B,CAAC;AAE3G,OAAO,EAAE,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEpH,8GAA8G;AAC9G,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,oBAAoB,EAAE,YAAY,GAAG,aAAa,CAAC,CAAC;AAE9F,mFAAmF;AACnF,MAAM,MAAM,uBAAuB,GAAG,CAAC,IAAI,EAAE,oBAAoB,EAAE,IAAI,EAAE,oBAAoB,KAAK,gBAAgB,CAAC;AAEnH;;;;;;;;;;;;;GAaG;AACH,qBAAa,eAAe;IAYxB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAE3B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAdlC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoC;IACrE,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YACmB,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,gBAAgB,CAAC,EACpD,UAAU,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,EAC9D,QAAQ,CAAC,EAAE,cAAc,EACR,eAAe,GAAE,uBAA0E,EAG7G;IAEM,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5B;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CASjC;IAED;;;OAGG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;OAIG;IACU,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0BxG;IAED;;;;;;;;;;;OAWG;IACI,yBAAyB,CAAC,iBAAiB,EAAE,WAAW,GAAG,gBAAgB,EAAE,CAYnF;IAED;;;;OAIG;IACI,WAAW,CAAC,YAAY,EAAE,WAAW,GAAG,IAAI,CAiBlD;IAED,6DAA6D;IACtD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEnD;IAED,kGAAkG;IAC3F,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAE3E;IAED,+DAA+D;IACxD,OAAO,IAAI,gBAAgB,EAAE,CAEnC;IAED,yDAAyD;IAClD,IAAI,IAAI,gBAAgB,EAAE,CAEhC;IAED;;OAEG;IACU,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAIzE;IAED,yFAAyF;IAClF,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,gBAAgB,EAAE,CAEnF;CACF;AAED,oFAAoF;AACpF,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC"}

package/dest/checkpoint-store.js

@@ -1,5 +1,4 @@
 import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/promise';
 import { getEpochAtSlot, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { CheckpointProver } from './job/checkpoint-prover.js';
 /**
@@ -8,63 +7,78 @@ import { CheckpointProver } from './job/checkpoint-prover.js';
  *
  * The store survives every epoch / session boundary. A prover lives from its first
  * `addOrUpdate` call until either:
- *  - it has been pruned and the L2 chain has moved past its slot (no re-add possible), or
+ *  - its checkpoint is pruned by an L1 reorg (`cancelAndRemoveAboveBlock`), or
  *  - its epoch's proof-submission window has closed (`reapExpired`), so the proof could no
  *    longer be accepted on L1 even if produced.
  *
- * A re-add of a checkpoint that matches an existing prover's content key reuses the
- * existing prover (and flips it back to canonical); the in-flight sub-tree work never
- * stops, so a prune-then-re-add of the same content avoids re-proving entirely.
+ * A prover's sub-tree work forks world-state per block and does not survive a prune of a base
+ * block, so there is nothing to preserve across a reorg: a pruned prover is cancelled and
+ * dropped, and a re-add (even of identical content) constructs a fresh prover.
  */ export class CheckpointStore {
     l2BlockSource;
     proverDeps;
-    options;
     proverFactoryFn;
     provers;
-    slotWatcher;
+    /**
+   * Teardowns of provers already removed from `provers` (by prune or reap), awaited on `stop()`.
+   * Keyed by a monotonic id rather than the prover's content id: a prune-then-re-add can leave two
+   * teardowns for the same content id in flight at once, which a content-id key would clobber.
+   */ pendingTeardowns;
+    nextTeardownId;
     log;
-    constructor(l2BlockSource, proverDeps, options, bindings, proverFactoryFn = (args, deps)=>new CheckpointProver(args, deps)){
+    constructor(l2BlockSource, proverDeps, bindings, proverFactoryFn = (args, deps)=>new CheckpointProver(args, deps)){
         this.l2BlockSource = l2BlockSource;
         this.proverDeps = proverDeps;
-        this.options = options;
         this.proverFactoryFn = proverFactoryFn;
         this.provers = new Map();
+        this.pendingTeardowns = new Map();
+        this.nextTeardownId = 0;
         this.log = createLogger('prover-node:checkpoint-store', bindings);
-        this.slotWatcher = new RunningPromise(()=>this.reapPrunedPastSlot(), this.log, this.options.slotWatcherPollIntervalMs);
     }
     start() {
-        this.slotWatcher.start();
         return Promise.resolve();
     }
     async stop() {
-        await this.slotWatcher.stop();
-        // Cancel every live prover; await teardown.
+        // Cancel every live prover, then await both their teardown and any still in flight for provers
+        // already removed by a prune or reap.
         const provers = Array.from(this.provers.values());
         this.provers.clear();
         for (const prover of provers){
             prover.cancel();
         }
-        await Promise.allSettled(provers.map((p)=>p.whenDone()));
+        await Promise.allSettled([
+            ...provers.map((p)=>p.whenDone()),
+            ...this.pendingTeardowns.values()
+        ]);
+    }
+    /**
+   * Tracks the teardown of a prover just removed from the store so `stop()` can await it. The entry
+   * removes itself once teardown settles, so the map stays bounded by the number in flight.
+   */ trackTeardown(prover) {
+        const id = this.nextTeardownId++;
+        const done = prover.whenDone();
+        this.pendingTeardowns.set(id, done);
+        void done.finally(()=>this.pendingTeardowns.delete(id));
     }
     /**
    * Registers a checkpoint with the store. If a prover already exists for the
-   * `(number, slot, archive root)` content key, it is reused and marked canonical;
-   * otherwise a new prover is constructed.
+   * `(number, slot, archive root)` content key it is reused (an at-least-once re-registration of
+   * still-canonical content); otherwise a new prover is constructed.
    */ async addOrUpdate(checkpoint, data) {
         const l1Constants = await this.l2BlockSource.getL1Constants();
         const epochNumber = getEpochAtSlot(checkpoint.header.slotNumber, l1Constants);
         const id = CheckpointProver.idFor(checkpoint);
         const existing = this.provers.get(id);
         if (existing) {
-            existing.markCanonical();
             return existing;
         }
-        // At most one canonical checkpoint per slot. A different canonical checkpoint at the
-        // same slot means the caller forgot to prune the old chain before adding the replacement
-        // — surface it rather than silently creating a parallel canonical chain.
+        // At most one canonical checkpoint per slot. A different checkpoint at the same slot means the
+        // caller forgot to prune the old chain before adding the replacement — surface it rather than
+        // silently creating a parallel canonical chain. A pruned checkpoint has already been removed,
+        // so every prover still in the store is canonical.
         for (const prover of this.provers.values()){
-            if (prover.slotNumber === checkpoint.header.slotNumber && !prover.isPruned()) {
-                throw new Error(`Cannot add checkpoint ${checkpoint.number} (archive ${checkpoint.archive.root}) at slot ${checkpoint.header.slotNumber}: ` + `a different canonical checkpoint already occupies this slot. Prune it first.`);
+            if (prover.slotNumber === checkpoint.header.slotNumber) {
+                throw new Error(`Cannot add checkpoint ${checkpoint.number} (archive ${checkpoint.archive.root}) at slot ${checkpoint.header.slotNumber}: ` + `a different checkpoint already occupies this slot. Prune it first.`);
             }
         }
         const prover = this.proverFactoryFn({
@@ -79,34 +93,36 @@ import { CheckpointProver } from './job/checkpoint-prover.js';
         return prover;
     }
     /**
-   * Marks every canonical prover that holds a block above the prune target as pruned. A checkpoint is orphaned by a
-   * prune to block `targetBlockNumber` iff its last block sits above the target — including a checkpoint whose range
-   * straddles the target (partially orphaned), which block-range marking catches without boundary ambiguity. Keying
-   * off the surviving block number (rather than a checkpoint number) is correct even when the source has already
+   * Cancels and removes every prover that holds a block above the prune target. A checkpoint is orphaned by a prune to
+   * block `targetBlockNumber` iff its last block sits above the target — including a checkpoint whose range straddles
+   * the target (partially orphaned), which block-range marking catches without boundary ambiguity. Keying off the
+   * surviving block number (rather than a checkpoint number) is correct even when the source has already
    * re-checkpointed past the divergence: the prune event reports the highest surviving block, which by construction
    * survives on the source, whereas the source's current checkpointed tip can sit above the prune target.
-   * Sub-tree work keeps running so a re-add of the same content can pick it up. Returns the affected provers.
-   */ markPrunedAboveBlock(targetBlockNumber) {
+   *
+   * The prover's in-flight sub-tree work forks world-state per block and faults once its base block is pruned, so it
+   * cannot be reused; it is cancelled (aborting the fork reads) and dropped. A subsequent re-add constructs a fresh
+   * prover. Returns the removed provers.
+   */ cancelAndRemoveAboveBlock(targetBlockNumber) {
         const affected = [];
-        for (const prover of this.provers.values()){
+        for (const [id, prover] of Array.from(this.provers.entries())){
             const lastBlockNumber = prover.checkpoint.blocks.at(-1).number;
-            if (lastBlockNumber > targetBlockNumber && !prover.isPruned()) {
-                prover.markPruned();
+            if (lastBlockNumber > targetBlockNumber) {
+                prover.cancel();
+                this.trackTeardown(prover);
+                this.provers.delete(id);
                 affected.push(prover);
             }
         }
         return affected;
     }
     /**
-   * Drops canonical (non-pruned) provers whose epoch is at or below the supplied expired
-   * epoch. Once an epoch's proof-submission window has closed, its proof can no longer be
-   * accepted on L1, so the prover is no longer needed.
+   * Drops provers whose epoch is at or below the supplied expired epoch. Once an epoch's
+   * proof-submission window has closed, its proof can no longer be accepted on L1, so the
+   * prover is no longer needed.
    */ reapExpired(expiredEpoch) {
         const reaped = [];
         for (const [id, prover] of Array.from(this.provers.entries())){
-            if (prover.isPruned()) {
-                continue;
-            }
             if (prover.epochNumber <= expiredEpoch) {
                 reaped.push({
                     id,
@@ -116,7 +132,7 @@ import { CheckpointProver } from './job/checkpoint-prover.js';
                 prover.cancel({
                     routine: true
                 });
-                void prover.whenDone();
+                this.trackTeardown(prover);
                 this.provers.delete(id);
             }
         }
@@ -134,53 +150,20 @@ import { CheckpointProver } from './job/checkpoint-prover.js';
     /** Returns the prover for the supplied checkpoint (by its content-addressed id), or undefined. */ getByCheckpoint(checkpoint) {
         return this.provers.get(CheckpointProver.idFor(checkpoint));
     }
-    /** Every prover currently in the store (canonical and pruned), in insertion order. */ listAll() {
+    /** Every prover currently in the store, in insertion order. */ listAll() {
         return Array.from(this.provers.values());
     }
-    /** Canonical (non-pruned) provers in the store, sorted by checkpoint number. */ listCanonical() {
-        return Array.from(this.provers.values()).filter((p)=>!p.isPruned()).sort((a, b)=>a.checkpoint.number - b.checkpoint.number);
+    /** Provers in the store, sorted by checkpoint number. */ list() {
+        return Array.from(this.provers.values()).sort((a, b)=>a.checkpoint.number - b.checkpoint.number);
     }
     /**
-   * Canonical provers whose slot is in the supplied epoch's slot range, sorted by
-   * checkpoint number.
-   */ async listCanonicalForEpoch(epoch) {
+   * Provers whose slot is in the supplied epoch's slot range, sorted by checkpoint number.
+   */ async listForEpoch(epoch) {
         const l1Constants = await this.l2BlockSource.getL1Constants();
         const [fromSlot, toSlot] = getSlotRangeForEpoch(epoch, l1Constants);
-        return this.listCanonicalInSlotRange(fromSlot, toSlot);
+        return this.listInSlotRange(fromSlot, toSlot);
     }
-    /** Canonical provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */ listCanonicalInSlotRange(fromSlot, toSlot) {
-        return this.listCanonical().filter((p)=>p.slotNumber >= fromSlot && p.slotNumber <= toSlot);
-    }
-    /**
-   * SlotWatcher tick: reap pruned provers whose slot has passed the chain's synced
-   * slot. Once the chain has moved past, no re-add can revive the prover and its
-   * content key is unique enough that an actual re-add would create a new entry.
-   *
-   * Protected so unit tests can drive a single tick without spinning up the
-   * `RunningPromise` and waiting on its interval.
-   */ async reapPrunedPastSlot() {
-        let syncedSlot;
-        try {
-            syncedSlot = await this.l2BlockSource.getSyncedL2SlotNumber();
-        } catch (err) {
-            this.log.debug(`SlotWatcher could not read synced slot`, {
-                error: `${err}`
-            });
-            return;
-        }
-        if (syncedSlot === undefined) {
-            return;
-        }
-        for (const [id, prover] of Array.from(this.provers.entries())){
-            if (prover.isPruned() && prover.slotNumber < syncedSlot) {
-                this.log.info(`Reaping pruned CheckpointProver ${id}: slot ${prover.slotNumber} < synced ${syncedSlot}`, {
-                    checkpointNumber: prover.checkpoint.number,
-                    slotNumber: prover.slotNumber
-                });
-                prover.cancel();
-                void prover.whenDone();
-                this.provers.delete(id);
-            }
-        }
+    /** Provers whose slot falls within `[fromSlot, toSlot]`, sorted by checkpoint number. */ listInSlotRange(fromSlot, toSlot) {
+        return this.list().filter((p)=>p.slotNumber >= fromSlot && p.slotNumber <= toSlot);
     }
 }