@aztec/prover-node 5.0.0-rc.1 → 5.0.0

package/src/prover-node.ts

@@ -5,14 +5,16 @@ import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/br
 import { assertRequired, compact, pick } from '@aztec/foundation/collection';
 import { memoize } from '@aztec/foundation/decorators';
 import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
 import { DateProvider, executeTimeout } from '@aztec/foundation/timer';
 import type { EpochProverFactory } from '@aztec/prover-client';
 import { getLastSiblingPath } from '@aztec/prover-client/helpers';
 import { ChonkCache } from '@aztec/prover-client/orchestrator';
 import { PublicProcessorFactory } from '@aztec/simulator/server';
 import {
+  EventDrivenL2BlockStream,
+  type L2BlockId,
   type L2BlockSource,
-  L2BlockStream,
   type L2BlockStreamEvent,
   type L2BlockStreamEventHandler,
   L2TipsMemoryStore,
@@ -28,7 +30,6 @@ import {
   type ITxProvider,
   type ProverNodeApi,
   type Service,
-  type WorldStateSyncStatus,
   type WorldStateSynchronizer,
   tryStop,
 } from '@aztec/stdlib/interfaces/server';
@@ -86,7 +87,7 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
   /** In-memory store for the L2BlockStream's local data provider. */
   private tipsStore: L2TipsMemoryStore;
   /** Block stream for checkpoint and reorg detection. */
-  private blockStream: L2BlockStream | undefined;
+  private blockStream: EventDrivenL2BlockStream | undefined;
   /**
    * Highest epoch whose proof-submission window has passed. Monotonic high-water mark.
    * Seeded from the last fully-proven epoch at start(); advanced on every block-stream
@@ -95,6 +96,17 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
    */
   protected lastExpiredEpoch: EpochNumber | undefined;
 
+  /**
+   * Highest checkpoint number whose proving-side handling has completed (or that was legitimately skipped).
+   * The catch-up loop walks from here to each `chain-checkpointed` tip event. Seeded at start() from the last
+   * checkpoint of the last fully-proven epoch (or 0), so a restart reprocesses the partially-proven epoch rather
+   * than trusting a checkpointed tip that may sit ahead of unproven checkpoints. Clamped down on a prune.
+   */
+  protected lastProcessedCheckpoint: CheckpointNumber = CheckpointNumber.ZERO;
+
+  /** Periodic tick that runs the epoch-expiry sweep during idle periods when no block-stream events arrive. */
+  private expiryTicker: RunningPromise | undefined;
+
   public readonly tracer: Tracer;
 
   protected publishingService: ProofPublishingService | undefined;
@@ -157,7 +169,6 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
         txGatheringTimeoutMs: this.config.txGatheringTimeoutMs,
         deadline: undefined,
       },
-      { slotWatcherPollIntervalMs: this.config.proverNodePollingIntervalMs },
       this.log.getBindings(),
     );
   }
@@ -198,17 +209,6 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
     return this.sessionManager;
   }
 
-  /** Returns world state status. */
-  public async getWorldStateSyncStatus(): Promise<WorldStateSyncStatus> {
-    const { syncSummary } = await this.worldState.status();
-    return syncSummary;
-  }
-
-  /** Returns archiver status. */
-  public getL2Tips() {
-    return this.l2BlockSource.getL2Tips();
-  }
-
   /** Returns the underlying prover instance. */
   public getProver() {
     return this.prover;
@@ -219,17 +219,25 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
   public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
     switch (event.type) {
       case 'chain-checkpointed':
-        await this.handleCheckpointEvent(event.checkpoint);
+        await this.processCheckpointJump(event.checkpoint.number);
         break;
       case 'chain-pruned':
-        await this.handlePruneEvent(event.checkpointed.checkpoint);
+        await this.handlePruneEvent(event.block);
         break;
       case 'chain-proven':
         this.publishingService?.onChainProven(BlockNumber(event.block.number));
         break;
+      // The proposed tip drives only the tips store's walk-back history (recorded below); the prover-node
+      // tracks checkpoints, not proposed blocks. `blocks-added` is never emitted in tips-only mode, and
+      // `chain-finalized` carries nothing the prover-node acts on.
+      case 'chain-proposed':
       case 'chain-finalized':
       case 'blocks-added':
         break;
+      default: {
+        const _: never = event;
+        break;
+      }
     }
     // Expiry is driven by the archiver's latest synced L2 slot
     await this.checkEpochExpiry();
@@ -239,34 +247,92 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
     await this.tipsStore.handleBlockStreamEvent(event);
   }
 
-  /** Register a new checkpoint with the store and notify the session manager. */
-  private async handleCheckpointEvent(publishedCheckpoint: PublishedCheckpoint) {
-    const checkpoint = publishedCheckpoint.checkpoint;
-    const slotNumber = checkpoint.header.slotNumber;
-    const l1Constants = await this.getL1Constants();
-    const epochNumber = getEpochAtSlot(slotNumber, l1Constants);
-
-    if (await this.isEpochFullyProven(epochNumber, l1Constants)) {
-      this.log.debug(`Skipping checkpoint ${checkpoint.number} for already-proven epoch ${epochNumber}`);
+  /**
+   * Walks every checkpoint between the local cursor and the newly-reported checkpointed tip, registering
+   * each one that belongs to an epoch that can still be proven. The block stream now delivers a single thin
+   * `chain-checkpointed` tip event per pass rather than one fat event per checkpoint, so this drives the
+   * catch-up itself: light metadata first (`getCheckpointsData`) to decide relevance per epoch, then a heavy
+   * `getCheckpoints` fetch only for checkpoints in provable epochs.
+   *
+   * The cursor advances one checkpoint at a time and only after that checkpoint's proving-side handling has
+   * fully succeeded, preserving the A-1041 at-least-once semantics: a mid-jump failure leaves the cursor
+   * behind so the next pass retries from the first checkpoint that did not complete.
+   */
+  private async processCheckpointJump(targetCheckpoint: CheckpointNumber): Promise<void> {
+    if (targetCheckpoint <= this.lastProcessedCheckpoint) {
       return;
     }
+    const l1Constants = await this.getL1Constants();
 
-    if (await this.isEpochPastProofSubmissionWindow(epochNumber, l1Constants)) {
-      this.log.debug(
-        `Skipping checkpoint ${checkpoint.number} for epoch ${epochNumber} past its proof-submission window`,
-      );
-      return;
+    // Cap the catch-up at the `(proofSubmissionEpochs + 1) * epochDuration` most recent checkpoints.
+    // When the cursor is much further behind (e.g. resyncing after a long time offline), fetching the whole gap could
+    // load thousands of checkpoints we cannot act on: anything older than the last two epochs is already past
+    // its proof-submission window, so we skip it and jump the cursor forward to the start of the capped range.
+    const maxCheckpoints = (l1Constants.proofSubmissionEpochs + 1) * l1Constants.epochDuration;
+    let from = CheckpointNumber(this.lastProcessedCheckpoint + 1);
+    if (Number(targetCheckpoint - from) + 1 > maxCheckpoints) {
+      const cappedFrom = CheckpointNumber(targetCheckpoint - maxCheckpoints + 1);
+      this.log.warn(`Skipping unprovable checkpoints during catch-up; the prover node is far behind`, {
+        from,
+        cappedFrom,
+        targetCheckpoint,
+        maxCheckpoints,
+      });
+      // Advance the cursor past the skipped checkpoints so they are never retried.
+      this.lastProcessedCheckpoint = CheckpointNumber(cappedFrom - 1);
+      from = cappedFrom;
     }
+    const limit = Number(targetCheckpoint - from) + 1;
+    const metadatas = await this.l2BlockSource.getCheckpointsData({ from, limit });
+
+    // Per-epoch relevance is cached so a multi-checkpoint epoch resolves it once. Skipping is whole-epoch
+    // only: the SessionManager requires an epoch's checkpoints fully covered before it opens a session, so we
+    // never drop an individual checkpoint inside an epoch we will prove.
+    const epochSkippable = new Map<EpochNumber, boolean>();
+    for (const metadata of metadatas) {
+      const epochNumber = getEpochAtSlot(metadata.header.slotNumber, l1Constants);
+      let skippable = epochSkippable.get(epochNumber);
+      if (skippable === undefined) {
+        skippable =
+          (await this.isEpochFullyProven(epochNumber, l1Constants)) ||
+          (await this.isEpochPastProofSubmissionWindow(epochNumber, l1Constants));
+        epochSkippable.set(epochNumber, skippable);
+      }
+      if (skippable) {
+        this.log.debug(`Skipping checkpoint ${metadata.checkpointNumber} for unprovable epoch ${epochNumber}`);
+      } else {
+        await this.registerCheckpoint(metadata.checkpointNumber, epochNumber);
+      }
+      // Advance only after the checkpoint's handling succeeded (or it was legitimately skipped). registerCheckpoint
+      // throws on failure, which leaves the cursor here for the next pass to retry (A-1041).
+      this.lastProcessedCheckpoint = metadata.checkpointNumber;
+    }
+  }
 
+  /** Heavy-fetch a single checkpoint, register it with the store, and notify the session manager. */
+  private async registerCheckpoint(checkpointNumber: CheckpointNumber, epochNumber: EpochNumber): Promise<void> {
+    const published = await this.l2BlockSource.getCheckpoint({ number: checkpointNumber });
+    if (!published) {
+      throw new Error(`Checkpoint ${checkpointNumber} not found in block source during catch-up`);
+    }
+    const checkpoint = published.checkpoint;
     this.log.info(`New checkpoint ${checkpoint.number} for epoch ${epochNumber}`, {
       checkpointNumber: checkpoint.number,
       epochNumber,
-      slotNumber,
+      slotNumber: checkpoint.header.slotNumber,
     });
 
-    const registerData = await this.collectRegisterData(checkpoint, publishedCheckpoint.attestations);
+    const registerData = await this.collectRegisterData(checkpoint, published.attestations);
     await this.checkpointStore.addOrUpdate(checkpoint, registerData);
     await this.sessionManager?.onCheckpointAdded(epochNumber);
+
+    // Tips-only mode delivers no blocks, so record one witness per checkpointed block: a reorg into the checkpoint's
+    // range then prunes at the true divergence instead of the nearest sparse tip anchor.
+    await this.tipsStore.recordBlockHashes(
+      await Promise.all(
+        checkpoint.blocks.map(async block => ({ number: block.number, hash: (await block.header.hash()).toString() })),
+      ),
+    );
   }
 
   /**
@@ -295,10 +361,41 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
     };
   }
 
-  /** Mark every prover above the prune threshold as pruned and notify the session manager. */
-  private async handlePruneEvent(prunedCheckpoint: { number: CheckpointNumber; hash: string }) {
-    this.log.warn(`Chain pruned to checkpoint ${prunedCheckpoint.number}`, { prunedCheckpoint });
-    const affected = this.checkpointStore.markPrunedAfter(prunedCheckpoint.number);
+  /**
+   * Marks every prover orphaned by the prune as pruned, clamps the catch-up cursor below the prune target's
+   * checkpoint, and notifies the session manager. Keyed off the prune target block (the highest surviving block)
+   * rather than the source's checkpointed tip, which can sit above the target after a re-checkpoint and would leave
+   * orphaned provers canonical. Throws (rather than warning) if the cursor floor cannot be resolved, so the pass
+   * fails and the prune is retried next iteration.
+   */
+  private async handlePruneEvent(prunedToBlock: L2BlockId) {
+    this.log.warn(`Chain pruned to block ${prunedToBlock.number}`, { prunedToBlock });
+
+    // Resolve the cursor floor BEFORE removing provers: cancelAndRemoveAboveBlock returns only the provers it removed,
+    // so a throw after removing would leave a retry pass with nothing to act on. Resolving first means a throw leaves
+    // everything untouched and the next pass retries the whole handler (the tips cursor only advances on success).
+    let cursorFloor: CheckpointNumber;
+    if (prunedToBlock.number === 0) {
+      cursorFloor = CheckpointNumber.ZERO;
+    } else {
+      const targetData = await this.l2BlockSource.getBlockData({ number: prunedToBlock.number });
+      if (targetData === undefined) {
+        throw new Error(
+          `No block data found for prune target block ${prunedToBlock.number}; cannot clamp checkpoint cursor`,
+        );
+      }
+      // Clamp to `cpAtTarget - 1`: a mid-checkpoint target leaves that checkpoint partially orphaned and it must be
+      // reprocessed. Over-clamping merely re-registers a checkpoint (at-least-once by design — A-1041); under-clamping
+      // would permanently skip a rebuilt same-number checkpoint.
+      cursorFloor = CheckpointNumber(Math.max(0, Number(targetData.checkpointNumber) - 1));
+    }
+
+    const affected = this.checkpointStore.cancelAndRemoveAboveBlock(prunedToBlock.number);
+
+    if (this.lastProcessedCheckpoint > cursorFloor) {
+      this.lastProcessedCheckpoint = cursorFloor;
+    }
+
     if (affected.length === 0) {
       return;
     }
@@ -409,14 +506,24 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
     // Now that the store + manager exist, arm the live-state observable gauges.
     this.jobMetrics.observeState(this.checkpointStore, this.sessionManager);
 
-    const { startingBlock, lastFullyProvenEpoch } = await this.computeStartupState();
+    const { lastFullyProvenEpoch } = await this.resolveLastFullyProvenEpoch();
     this.lastExpiredEpoch = lastFullyProvenEpoch;
-    this.blockStream = new L2BlockStream(this.l2BlockSource, this.tipsStore, this, this.log, {
+    this.lastProcessedCheckpoint = await this.computeStartingCheckpoint(lastFullyProvenEpoch);
+    this.blockStream = new EventDrivenL2BlockStream(this.l2BlockSource, this.tipsStore, this, this.log, {
       pollIntervalMS: this.config.proverNodePollingIntervalMs,
-      startingBlock,
+      tipsOnly: true,
     });
     this.blockStream.start();
 
+    // With thin once-per-pass tip events, the expiry sweep no longer fires once per checkpoint; drive it
+    // from a periodic tick so epochs still expire during idle/no-event periods.
+    this.expiryTicker = new RunningPromise(
+      () => this.checkEpochExpiry(),
+      this.log,
+      this.config.proverNodePollingIntervalMs,
+    );
+    this.expiryTicker.start();
+
     await this.rewardsMetrics.start();
     this.l1Metrics.start();
     this.log.info(`Started Prover Node with prover id ${this.prover.getProverId().toString()}`, this.config);
@@ -426,6 +533,7 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
     this.log.info('Stopping ProverNode');
     this.jobMetrics.stopObservingState();
     await this.blockStream?.stop();
+    await this.expiryTicker?.stop();
     if (this.sessionManager) {
       await this.sessionManager.stop();
     }
@@ -552,38 +660,40 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
   }
 
   /**
-   * Resolves the L2BlockStream's starting block and the last fully-proven epoch in one
-   * pass. The starting block is the first block of the next unproven epoch (or the start
-   * of the partially-proven epoch if the proven tip falls mid-epoch). The fully-proven
-   * epoch is `provenEpoch` when the proven tip is the last block of its epoch, otherwise
-   * `provenEpoch - 1`, or `undefined` if no block is proven yet.
+   * Resolves the last fully-proven epoch from L1 proven state, used to seed the catch-up cursor (via
+   * `computeStartingCheckpoint`) and `lastExpiredEpoch`. The fully-proven epoch is `provenEpoch` when the
+   * proven tip is the last block of its epoch, otherwise `provenEpoch - 1`, or `undefined` if no block is
+   * proven yet (so a restart reprocesses the partially-proven epoch rather than trusting a stale tip).
    */
-  protected async computeStartupState(): Promise<{
-    startingBlock: BlockNumber;
-    lastFullyProvenEpoch: EpochNumber | undefined;
-  }> {
+  protected async resolveLastFullyProvenEpoch(): Promise<{ lastFullyProvenEpoch: EpochNumber | undefined }> {
     const provenBlockNumber = await this.l2BlockSource.getBlockNumber({ tag: 'proven' });
     if (!provenBlockNumber || provenBlockNumber <= 0) {
-      return { startingBlock: BlockNumber(1), lastFullyProvenEpoch: undefined };
+      return { lastFullyProvenEpoch: undefined };
     }
     const l1Constants = await this.getL1Constants();
     const provenHeader = (await this.l2BlockSource.getBlockData({ number: BlockNumber(provenBlockNumber) }))?.header;
     if (!provenHeader) {
-      return { startingBlock: BlockNumber(provenBlockNumber + 1), lastFullyProvenEpoch: undefined };
+      return { lastFullyProvenEpoch: undefined };
     }
     const provenEpoch = getEpochAtSlot(provenHeader.getSlot(), l1Constants);
     if (await this.isProvenBlockLastOfItsEpoch(BlockNumber(provenBlockNumber), provenEpoch, l1Constants)) {
-      return { startingBlock: BlockNumber(provenBlockNumber + 1), lastFullyProvenEpoch: provenEpoch };
+      return { lastFullyProvenEpoch: provenEpoch };
     }
-    const epochCheckpoints = await this.l2BlockSource.getCheckpointsData({ epoch: provenEpoch });
-    const firstBlockOfEpoch =
-      epochCheckpoints.length > 0 ? epochCheckpoints[0].startBlock : BlockNumber(provenBlockNumber);
-    this.log.info(
-      `Starting L2BlockStream at block ${firstBlockOfEpoch} (start of partially-proven epoch ${provenEpoch})`,
-      { provenBlockNumber, provenEpoch, firstBlockOfEpoch },
-    );
     const lastFullyProvenEpoch = provenEpoch > 0 ? EpochNumber(provenEpoch - 1) : undefined;
-    return { startingBlock: firstBlockOfEpoch, lastFullyProvenEpoch };
+    return { lastFullyProvenEpoch };
+  }
+
+  /**
+   * Resolves the catch-up cursor seed: the last checkpoint of the last fully-proven epoch, or 0 if none. Seeding
+   * from a checkpoint (rather than a checkpointed tip) guarantees a restart reprocesses every checkpoint of the
+   * partially-proven epoch, since the checkpointed tip can sit ahead of the last fully-proven checkpoint.
+   */
+  protected async computeStartingCheckpoint(lastFullyProvenEpoch: EpochNumber | undefined): Promise<CheckpointNumber> {
+    if (lastFullyProvenEpoch === undefined) {
+      return CheckpointNumber.ZERO;
+    }
+    const checkpoints = await this.l2BlockSource.getCheckpointsData({ epoch: lastFullyProvenEpoch });
+    return checkpoints.at(-1)?.checkpointNumber ?? CheckpointNumber.ZERO;
   }
 
   private async gatherPreviousBlockHeader(previousBlockNumber: number) {

package/src/session-manager.ts

@@ -185,7 +185,7 @@ export class SessionManager {
    * slot. Dedupes against any existing session covering the same range, returning its id.
    */
   public async startProof(epoch: EpochNumber): Promise<string> {
-    const canonical = await this.deps.checkpointStore.listCanonicalForEpoch(epoch);
+    const canonical = await this.deps.checkpointStore.listForEpoch(epoch);
     if (canonical.length === 0) {
       throw new EmptyEpochError(epoch);
     }
@@ -268,7 +268,7 @@ export class SessionManager {
         this.fullSessions.delete(key);
         continue;
       }
-      const canonical = this.canonicalCheckpointsForSpec(session.getSpec());
+      const canonical = this.checkpointsForSpec(session.getSpec());
       if (!this.checkpointsMatch(session.getCheckpoints(), canonical)) {
         this.fireAndForgetCancel(session, 'canonical content changed');
         this.fullSessions.delete(key);
@@ -284,7 +284,7 @@ export class SessionManager {
         this.partialSessions.delete(key);
         continue;
       }
-      const canonical = this.canonicalCheckpointsForSpec(session.getSpec());
+      const canonical = this.checkpointsForSpec(session.getSpec());
       if (!this.checkpointsMatch(session.getCheckpoints(), canonical)) {
         this.fireAndForgetCancel(session, 'canonical content changed');
         this.partialSessions.delete(key);
@@ -298,6 +298,8 @@ export class SessionManager {
   }
 
   private async openFullSessionIfReady(epoch: EpochNumber): Promise<void> {
+    // `recreateInvalidSessions` runs at the top of every reconcile and deletes terminal sessions
+    // before this is called, so a session present here is live and already covers the epoch.
     if (this.fullSessions.has(epoch)) {
       return;
     }
@@ -314,7 +316,7 @@ export class SessionManager {
       return;
     }
     const [fromSlot, toSlot] = getSlotRangeForEpoch(epoch, l1Constants);
-    const canonical = this.deps.checkpointStore.listCanonicalInSlotRange(fromSlot, toSlot);
+    const canonical = this.deps.checkpointStore.listInSlotRange(fromSlot, toSlot);
     if (!this.archiverFullyCovered(archiverCps, canonical)) {
       this.log.debug(`Skipping full-session open for epoch ${epoch}: archiver checkpoints not all in store`, {
         archiverCount: archiverCps.length,
@@ -329,7 +331,7 @@ export class SessionManager {
   }
 
   private openPartialSession(spec: SessionSpec): void {
-    const canonical = this.deps.checkpointStore.listCanonicalInSlotRange(spec.fromSlot, spec.toSlot);
+    const canonical = this.deps.checkpointStore.listInSlotRange(spec.fromSlot, spec.toSlot);
     if (canonical.length === 0) {
       return;
     }
@@ -403,6 +405,17 @@ export class SessionManager {
     const state = await session.start();
     this.log.info(`Session ${session.getId()} exited with state ${state}`);
     if (state === 'failed' && this.deps.onSessionFailed) {
+      // Best-effort suppression of the spurious post-mortem upload a prune produces: if the session's
+      // checkpoints no longer match the store's current set, the failure was caused by the content
+      // changing under it, not a genuine proving fault, so skip the upload. This is inherently racy —
+      // the store lags the world-state unwind, so a fault observed before the prune is reconciled here
+      // still uploads. The epoch is recovered regardless by recreating the session on re-add.
+      if (!this.checkpointsMatch(session.getCheckpoints(), this.checkpointsForSpec(session.getSpec()))) {
+        this.log.info(`Skipping failure upload for session ${session.getId()}: canonical content changed`, {
+          ...session.getSpec(),
+        });
+        return;
+      }
       try {
         await this.deps.onSessionFailed(session);
       } catch (err) {
@@ -447,6 +460,24 @@ export class SessionManager {
     return live >= max;
   }
 
+  /**
+   * Maps a reconcile trigger to the epochs whose full session should be (re)opened.
+   *
+   * This is where the "don't retry a genuinely-failed epoch, but do recover a pruned one" invariant
+   * lives — enforced by which triggers are gated by `lastTickEpoch`:
+   *
+   * - The periodic `tick` IS gated: once a tick has opened a session for an epoch, `lastTickEpoch`
+   *   advances to it and later ticks skip it (`epoch <= lastTickEpoch`). So a failed attempt is never
+   *   resubmitted on a loop by the tick.
+   * - `checkpoint` and `prune` are deliberately NOT gated. They only fire when the epoch's canonical
+   *   content actually changes — a checkpoint arrives, or a reorg prunes/replaces one — which is
+   *   exactly when re-attempting is correct.
+   *
+   * A genuine proving failure produces no content change, hence no checkpoint/prune event, so only
+   * the gated tick could reopen it — and it won't. A prune + re-add fires ungated events, so the
+   * epoch is reopened through this path (and `openFullSessionIfReady` rebuilds over the fresh
+   * provers). See the "onTick does not retry ... but recovers ... re-added" test.
+   */
   private async epochsForTrigger(trigger: ReconcileTrigger): Promise<EpochNumber[]> {
     switch (trigger.kind) {
       case 'checkpoint':
@@ -481,8 +512,8 @@ export class SessionManager {
     return getEpochAtSlot(header.getSlot(), await this.getL1Constants());
   }
 
-  private canonicalCheckpointsForSpec(spec: SessionSpec): CheckpointProver[] {
-    return this.deps.checkpointStore.listCanonicalInSlotRange(spec.fromSlot, spec.toSlot);
+  private checkpointsForSpec(spec: SessionSpec): CheckpointProver[] {
+    return this.deps.checkpointStore.listInSlotRange(spec.fromSlot, spec.toSlot);
   }
 
   private fireAndForgetCancel(session: EpochSession, reason: string): void {