fix: archiver prune condition

Author: spalladino

yarn-project/archiver/src/archiver-sync.test.ts

@@ -20,6 +20,7 @@ import type { ProposedCheckpointInput } from '@aztec/stdlib/checkpoint';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { mockCheckpointAndMessages } from '@aztec/stdlib/testing';
 import { BlockHeader } from '@aztec/stdlib/tx';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
@@ -2172,6 +2173,7 @@ describe('Archiver Sync', () => {
 
     // Wall-clock time (seconds) at which the orphan tip becomes prunable: start(orphanSlot) + grace.
     const pruneDeadline = () => now + Number(orphanSlot) * l1Constants.slotDuration + graceSeconds;
+    const pruneDeadlineForSlot = (slot: SlotNumber) => now + Number(slot) * l1Constants.slotDuration + graceSeconds;
 
     // Syncs checkpoint 1 (slot 0), then writes uncheckpointed blocks for slot 1 (checkpoint 2) straight
     // into the store as a block-only tip with no matching proposed checkpoint. L1 is held at slot 1 so
@@ -2268,5 +2270,37 @@ describe('Archiver Sync', () => {
       expect(await archiver.getBlockNumber()).toEqual(lastProvisional);
       expect(await archiverStore.blocks.getLastProposedCheckpoint()).toBeDefined();
     }, 15_000);
+
+    it('prunes only the orphan suffix after a covered pending checkpoint', async () => {
+      const { lastBlockInCp1, provisionalBlocks: checkpointTwoBlocks } = await setupOrphanTip();
+
+      await archiver.addProposedCheckpoint(makeProposedCheckpoint(lastBlockInCp1, checkpointTwoBlocks.length));
+
+      const orphanSuffixSlot = SlotNumber(orphanSlot + 1);
+      const { checkpoint: orphanSuffixCheckpoint } = await mockCheckpointAndMessages(CheckpointNumber(3), {
+        startBlockNumber: BlockNumber(checkpointTwoBlocks.at(-1)!.number + 1),
+        numBlocks: 1,
+        previousArchive: checkpointTwoBlocks.at(-1)!.archive,
+        slotNumber: orphanSuffixSlot,
+      });
+      const orphanSuffixBlocks = orphanSuffixCheckpoint.blocks;
+      for (const block of orphanSuffixBlocks) {
+        await archiverStore.blocks.addProposedBlock(block);
+      }
+
+      dateProvider.setTime((pruneDeadlineForSlot(orphanSuffixSlot) + 1) * 1000);
+      await archiver.syncImmediate();
+
+      expect(pruneSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: L2BlockSourceEvents.L2PruneUncheckpointed,
+          slotNumber: orphanSuffixSlot,
+          blocks: expect.arrayContaining(orphanSuffixBlocks.map(b => expect.objectContaining({ number: b.number }))),
+        }),
+      );
+      expect(await archiver.getBlockNumber()).toEqual(checkpointTwoBlocks.at(-1)!.number);
+      expect(await archiverStore.blocks.getProposedCheckpointByNumber(CheckpointNumber(2))).toBeDefined();
+      expect(await archiverStore.blocks.getProposedCheckpointByNumber(CheckpointNumber(3))).toBeUndefined();
+    }, 15_000);
   });
 });

yarn-project/archiver/src/archiver.ts

@@ -14,14 +14,19 @@ import { RunningPromise, makeLoggingErrorHandler } from '@aztec/foundation/runni
 import { DateProvider, elapsed } from '@aztec/foundation/timer';
 import {
   type ArchiverEmitter,
+  type BlockData,
   type BlockHash,
   L2Block,
   type L2BlockSink,
   L2BlockSourceEvents,
   type L2Tips,
   type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
-import { type ProposedCheckpointInput, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import {
+  type ProposedCheckpointData,
+  type ProposedCheckpointInput,
+  PublishedCheckpoint,
+} from '@aztec/stdlib/checkpoint';
 import {
   type L1RollupConstants,
   getEpochAtSlot,
@@ -346,12 +351,12 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
   private async sync() {
     // Process any queued blocks first, before doing L1 sync
     await this.processInboundQueue();
+    // Now perform L1 sync
+    await this.syncFromL1();
     // Prune orphan proposed blocks (block-only tips with no matching proposed checkpoint) on wall-clock
     // time. Runs after the queue is drained so freshly-arrived proposed checkpoints are seen first, and
-    // before L1 sync so it fires even when L1 has not advanced.
+    // after L1 sync so a canonical checkpoint that already landed on L1 is promoted before local rollback.
     await this.pruneOrphanProposedBlocks();
-    // Now perform L1 sync
-    await this.syncFromL1();
   }
 
   /**
@@ -364,9 +369,8 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
    * should have arrived. This runs on wall-clock time (not L1 block advancement) so it fires during
    * quiet L1 periods, and is the liveness counterpart to the sequencer's checkSync guard.
    *
-   * Only the first uncheckpointed block is inspected: if its checkpoint is backed by a proposed
-   * checkpoint, the tip is legitimate and left for promotion (or for the L1-sync prune to clear if it
-   * later goes stale); if not, every uncheckpointed block chains off the orphan and is pruned.
+   * The uncheckpointed suffix is scanned in order. Blocks covered by proposed checkpoints are left in
+   * place; the first block not covered by a proposed checkpoint starts the orphan suffix to prune.
    */
   private async pruneOrphanProposedBlocks(): Promise<void> {
     const [lastCheckpointedBlockNumber, lastProposedBlockNumber] = await Promise.all([
@@ -379,39 +383,30 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       return;
     }
 
-    const firstUncheckpointedBlockNumber = BlockNumber(lastCheckpointedBlockNumber + 1);
-    const firstUncheckpointedBlockData = await this.stores.blocks.getBlockData({
-      number: firstUncheckpointedBlockNumber,
+    const uncheckpointedBlockData = await this.stores.blocks.getBlocksData({
+      from: BlockNumber(lastCheckpointedBlockNumber + 1),
+      limit: lastProposedBlockNumber - lastCheckpointedBlockNumber,
     });
-    if (firstUncheckpointedBlockData === undefined) {
+    if (uncheckpointedBlockData.length === 0) {
       return;
     }
 
-    const blockCheckpointNumber = firstUncheckpointedBlockData.checkpointNumber;
-    const blockSlot = firstUncheckpointedBlockData.header.getSlot();
-
-    // A proposed checkpoint covering this block's checkpoint means the tip is not an orphan.
-    const proposedCheckpoint = await this.stores.blocks.getProposedCheckpointByNumber(blockCheckpointNumber);
-    if (proposedCheckpoint !== undefined) {
+    const candidate = await this.findOrphanProposedBlockPruneCandidate(
+      uncheckpointedBlockData,
+      lastCheckpointedBlockNumber,
+    );
+    if (candidate === undefined) {
       return;
     }
 
-    // The proposed checkpoint should have landed by the start of the slot after the block's build slot
-    // (build slot = blockSlot - pipeliningOffset). Wait a grace period beyond that to tolerate propagation.
-    const pipeliningOffset = this.epochCache.pipeliningOffset();
-    const deadlineSlot = SlotNumber(Number(blockSlot) - pipeliningOffset + 1);
-    const pruneAfter =
-      getTimestampForSlot(deadlineSlot, this.l1Constants) + BigInt(this.config.orphanProposedBlockPruneGraceSeconds);
-    const now = BigInt(this.dateProvider.nowInSeconds());
-    if (now < pruneAfter) {
-      return;
-    }
+    const { blockCheckpointNumber, blockSlot, deadlineSlot, pruneAfter, now, pipeliningOffset, pruneAfterBlockNumber } =
+      candidate;
 
     this.log.warn(
-      `Pruning orphan blocks after block ${lastCheckpointedBlockNumber}: block at slot ${blockSlot} belongs to ` +
+      `Pruning orphan blocks after block ${pruneAfterBlockNumber}: block at slot ${blockSlot} belongs to ` +
         `checkpoint ${blockCheckpointNumber} which has no matching proposed checkpoint`,
       {
-        firstUncheckpointedBlockHeader: firstUncheckpointedBlockData.header.toInspect(),
+        firstUncheckpointedBlockHeader: candidate.blockData.header.toInspect(),
         blockCheckpointNumber,
         blockSlot,
         pipeliningOffset,
@@ -421,7 +416,7 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       },
     );
 
-    const prunedBlocks = await this.updater.removeUncheckpointedBlocksAfter(lastCheckpointedBlockNumber);
+    const prunedBlocks = await this.updater.removeUncheckpointedBlocksAfter(pruneAfterBlockNumber);
     if (prunedBlocks.length > 0) {
       this.events.emit(L2BlockSourceEvents.L2PruneUncheckpointed, {
         type: L2BlockSourceEvents.L2PruneUncheckpointed,
@@ -431,6 +426,59 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
     }
   }
 
+  private async findOrphanProposedBlockPruneCandidate(
+    uncheckpointedBlockData: BlockData[],
+    lastCheckpointedBlockNumber: BlockNumber,
+  ) {
+    const proposedCheckpoints = new Map<number, ProposedCheckpointData | undefined>();
+    let pruneAfterBlockNumber = lastCheckpointedBlockNumber;
+
+    for (const blockData of uncheckpointedBlockData) {
+      const blockNumber = blockData.header.getBlockNumber();
+      const blockCheckpointNumber = blockData.checkpointNumber;
+      const checkpointKey = Number(blockCheckpointNumber);
+      let proposedCheckpoint = proposedCheckpoints.get(checkpointKey);
+      if (!proposedCheckpoints.has(checkpointKey)) {
+        proposedCheckpoint = await this.stores.blocks.getProposedCheckpointByNumber(blockCheckpointNumber);
+        proposedCheckpoints.set(checkpointKey, proposedCheckpoint);
+      }
+
+      if (
+        proposedCheckpoint !== undefined &&
+        blockNumber >= proposedCheckpoint.startBlock &&
+        blockNumber < proposedCheckpoint.startBlock + proposedCheckpoint.blockCount
+      ) {
+        pruneAfterBlockNumber = blockNumber;
+        continue;
+      }
+
+      // The proposed checkpoint should have landed by the start of the slot after the block's build slot
+      // (build slot = blockSlot - pipeliningOffset). Wait a grace period beyond that to tolerate propagation.
+      const blockSlot = blockData.header.getSlot();
+      const pipeliningOffset = this.epochCache.pipeliningOffset();
+      const deadlineSlot = SlotNumber(Number(blockSlot) - pipeliningOffset + 1);
+      const pruneAfter =
+        getTimestampForSlot(deadlineSlot, this.l1Constants) + BigInt(this.config.orphanProposedBlockPruneGraceSeconds);
+      const now = BigInt(this.dateProvider.nowInSeconds());
+      if (now < pruneAfter) {
+        return undefined;
+      }
+
+      return {
+        blockData,
+        blockCheckpointNumber,
+        blockSlot,
+        deadlineSlot,
+        pruneAfter,
+        now,
+        pipeliningOffset,
+        pruneAfterBlockNumber,
+      };
+    }
+
+    return undefined;
+  }
+
   private async syncFromL1() {
     // Delegate to the L1 synchronizer
     await this.synchronizer.syncFromL1(this.initialSyncComplete);

yarn-project/archiver/src/modules/data_store_updater.ts

@@ -262,12 +262,10 @@ export class ArchiverDataStoreUpdater {
         );
       }
 
-      const result = await this.removeBlocksAfter(blockNumber);
+      const prunedBlocks = await this.removeBlocksAfter(blockNumber);
+      await this.evictProposedCheckpointsForPrunedBlocks(prunedBlocks);
 
-      // Clear all pending proposed checkpoints since their blocks have been pruned
-      await this.stores.blocks.deleteProposedCheckpoints();
-
-      return result;
+      return prunedBlocks;
     });
     await this.l2TipsCache?.refresh();
     return result;