@aztec/stdlib 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/block/test/l2_tips_store_test_suite.ts

@@ -1,92 +1,786 @@
-import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import {
+  type CheckpointId,
+  GENESIS_CHECKPOINT_HEADER_HASH,
+  L2Block,
+  type L2BlockId,
+  type L2BlockTag,
+  type L2TipId,
+} from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 
-import { jestExpect as expect } from '@jest/expect';
+import { expect } from 'vitest';
 
+import { GENESIS_BLOCK_HEADER_HASH } from '../block_hash.js';
 import type { L2TipsStore } from '../l2_block_stream/index.js';
 
 export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
   let tipsStore: L2TipsStore;
+  // Track blocks and their hashes for test assertions
+  const blockHashes: Map<number, string> = new Map();
+  // Track checkpoints and their hashes
+  const checkpointHashes: Map<number, string> = new Map();
+  // Track which blocks belong to which checkpoint
+  const blockToCheckpoint: Map<number, number> = new Map();
 
   beforeEach(async () => {
     tipsStore = await makeTipsStore();
+    blockHashes.clear();
+    checkpointHashes.clear();
+    blockToCheckpoint.clear();
   });
 
-  const makeBlock = (number: number): PublishedL2Block =>
-    PublishedL2Block.fromFields({
-      block: { number: BlockNumber(number), hash: () => Promise.resolve(new Fr(number)) } as L2Block,
-      l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
-      attestations: [],
-    });
+  const makeBlock = async (number: number): Promise<L2Block> => {
+    const block = await L2Block.random(BlockNumber(number));
+    blockHashes.set(number, (await block.hash()).toString());
+    return block;
+  };
 
   const makeBlockId = (number: number): L2BlockId => ({
     number: BlockNumber(number),
-    hash: new Fr(number).toString(),
+    hash: blockHashes.get(number) ?? new Fr(number).toString(),
   });
 
   const makeTip = (number: number): L2BlockId => ({
     number: BlockNumber(number),
-    hash: number === 0 ? GENESIS_BLOCK_HEADER_HASH.toString() : new Fr(number).toString(),
+    hash: number === 0 ? GENESIS_BLOCK_HEADER_HASH.toString() : (blockHashes.get(number) ?? new Fr(number).toString()),
+  });
+
+  const makeCheckpointIdForBlock = (blockNumber: number): CheckpointId => {
+    if (blockNumber === 0) {
+      return { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() };
+    }
+    const checkpointNum = blockToCheckpoint.get(blockNumber);
+    if (checkpointNum === undefined) {
+      return { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() };
+    }
+    const hash = checkpointHashes.get(checkpointNum);
+    if (!hash) {
+      return { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() };
+    }
+    return { number: CheckpointNumber(checkpointNum), hash };
+  };
+
+  const makeTipId = (blockNumber: number): L2TipId => ({
+    block: makeTip(blockNumber),
+    checkpoint: makeCheckpointIdForBlock(blockNumber),
   });
 
-  const makeTips = (latest: number, proven: number, finalized: number) => ({
-    latest: makeTip(latest),
-    proven: makeTip(proven),
-    finalized: makeTip(finalized),
+  const makeTips = (proposed: number, proven: number, finalized: number, checkpointed: number = 0) => ({
+    proposed: makeTip(proposed),
+    proven: makeTipId(proven),
+    finalized: makeTipId(finalized),
+    checkpointed: makeTipId(checkpointed),
   });
 
+  const makeCheckpoint = async (checkpointNumber: number, blocks: L2Block[]): Promise<PublishedCheckpoint> => {
+    const checkpoint = await Checkpoint.random(CheckpointNumber(checkpointNumber), {
+      numBlocks: blocks.length,
+      startBlockNumber: blocks[0].number,
+    });
+    // Override the blocks with our actual blocks (to keep hashes consistent)
+    (checkpoint as any).blocks = blocks;
+
+    const checkpointHash = checkpoint.hash().toString();
+    checkpointHashes.set(checkpointNumber, checkpointHash);
+
+    // Track which blocks belong to this checkpoint
+    for (const block of blocks) {
+      blockToCheckpoint.set(block.number, checkpointNumber);
+    }
+
+    return new PublishedCheckpoint(checkpoint, L1PublishedData.random(), []);
+  };
+
+  /** Creates a thin chain-checkpointed event carrying the block + checkpoint ids of the checkpoint's last block. */
+  const makeCheckpointedEvent = async (published: PublishedCheckpoint) => {
+    const lastBlock = published.checkpoint.blocks.at(-1)!;
+    const blockId: L2BlockId = {
+      number: lastBlock.number,
+      hash: (await lastBlock.hash()).toString(),
+    };
+    const checkpointId = {
+      number: published.checkpoint.number,
+      hash: published.checkpoint.hash().toString(),
+    };
+    return { type: 'chain-checkpointed' as const, checkpoint: checkpointId, block: blockId };
+  };
+
   it('returns zero if no tips are stored', async () => {
     const tips = await tipsStore.getL2Tips();
     expect(tips).toEqual(makeTips(0, 0, 0));
   });
 
-  it('stores chain tips', async () => {
-    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: times(20, i => makeBlock(i + 1)) });
+  it('sets proposed tip from blocks added', async () => {
+    await tipsStore.handleBlockStreamEvent({
+      type: 'blocks-added',
+      blocks: await Promise.all(times(3, i => makeBlock(i + 1))),
+    });
 
-    await tipsStore.handleBlockStreamEvent({ type: 'chain-finalized', block: makeBlockId(5) });
-    await tipsStore.handleBlockStreamEvent({ type: 'chain-proven', block: makeBlockId(8) });
-    await tipsStore.handleBlockStreamEvent({ type: 'chain-pruned', block: makeBlockId(10) });
+    const tips = await tipsStore.getL2Tips();
+    expect(tips).toEqual(makeTips(3, 0, 0));
+
+    expect(await tipsStore.getL2BlockHash(1)).toEqual(blockHashes.get(1));
+    expect(await tipsStore.getL2BlockHash(2)).toEqual(blockHashes.get(2));
+    expect(await tipsStore.getL2BlockHash(3)).toEqual(blockHashes.get(3));
+  });
+
+  it('records the proposed tip number and hash from a chain-proposed event', async () => {
+    // chain-proposed is the sole writer of proposed-tip history in tips-only mode: no preceding blocks-added.
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proposed',
+      block: { number: BlockNumber(5), hash: new Fr(500).toString() },
+    });
 
     const tips = await tipsStore.getL2Tips();
-    expect(tips).toEqual(makeTips(10, 8, 5));
+    expect(tips.proposed).toEqual({ number: BlockNumber(5), hash: new Fr(500).toString() });
+    // The hash is recorded in the same index the walk-back reads, so it resolves as a sparse anchor.
+    expect(await tipsStore.getL2BlockHash(5)).toEqual(new Fr(500).toString());
   });
 
-  it('sets latest tip from blocks added', async () => {
-    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: times(3, i => makeBlock(i + 1)) });
+  it('serves sparse proposed anchors from chain-proposed events for the walk-back', async () => {
+    // Two tip-moving polls in tips-only mode, with no blocks in between (sparse history).
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proposed',
+      block: { number: BlockNumber(4), hash: new Fr(400).toString() },
+    });
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proposed',
+      block: { number: BlockNumber(9), hash: new Fr(900).toString() },
+    });
+
+    // Both recorded heights resolve; the heights between them were never seen and stay undefined.
+    expect(await tipsStore.getL2BlockHash(4)).toEqual(new Fr(400).toString());
+    expect(await tipsStore.getL2BlockHash(9)).toEqual(new Fr(900).toString());
+    expect(await tipsStore.getL2BlockHash(6)).toBeUndefined();
 
     const tips = await tipsStore.getL2Tips();
-    expect(tips).toEqual(makeTips(3, 0, 0));
+    expect(tips.proposed).toEqual({ number: BlockNumber(9), hash: new Fr(900).toString() });
+  });
+
+  it('records block-hash witnesses without moving any tip cursor', async () => {
+    // Establish a proposed tip at 9 in tips-only fashion (sole writer of proposed history).
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proposed',
+      block: { number: BlockNumber(9), hash: new Fr(900).toString() },
+    });
+
+    // Record sparse witnesses at heights below the tip (e.g. a consumer materializing per-height state).
+    await tipsStore.recordBlockHashes([
+      { number: BlockNumber(4), hash: new Fr(404).toString() },
+      { number: BlockNumber(6), hash: new Fr(606).toString() },
+    ]);
+
+    // Each recorded height resolves; an unrecorded gap stays undefined.
+    expect(await tipsStore.getL2BlockHash(4)).toEqual(new Fr(404).toString());
+    expect(await tipsStore.getL2BlockHash(6)).toEqual(new Fr(606).toString());
+    expect(await tipsStore.getL2BlockHash(5)).toBeUndefined();
 
-    expect(await tipsStore.getL2BlockHash(1)).toEqual(new Fr(1).toString());
-    expect(await tipsStore.getL2BlockHash(2)).toEqual(new Fr(2).toString());
-    expect(await tipsStore.getL2BlockHash(3)).toEqual(new Fr(3).toString());
+    // No tip cursor moved: the proposed tip is still 9, and every other tier is at genesis.
+    const tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual({ number: BlockNumber(9), hash: new Fr(900).toString() });
+    expect(tips.checkpointed.block).toEqual(makeTip(0));
+    expect(tips.proven.block).toEqual(makeTip(0));
+    expect(tips.finalized.block).toEqual(makeTip(0));
   });
 
-  it('clears block hashes when setting finalized chain', async () => {
-    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: times(5, i => makeBlock(i + 1)) });
-    await tipsStore.handleBlockStreamEvent({ type: 'chain-proven', block: makeBlockId(3) });
-    await tipsStore.handleBlockStreamEvent({ type: 'chain-finalized', block: makeBlockId(3) });
+  it('skips witnesses with no hash and tolerates an empty list', async () => {
+    await tipsStore.recordBlockHashes([]);
+    await tipsStore.recordBlockHashes([{ number: BlockNumber(3), hash: '' }]);
+    expect(await tipsStore.getL2BlockHash(3)).toBeUndefined();
+  });
+
+  it('checkpoints all proposed blocks', async () => {
+    // Propose blocks 1-5
+    const blocks = await Promise.all(times(5, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks });
+
+    // Checkpoint all proposed blocks (1-5)
+    const checkpoint1 = await makeCheckpoint(1, blocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    const tips = await tipsStore.getL2Tips();
+    // Proposed and checkpointed should be the same
+    expect(tips.proposed).toEqual(makeTip(5));
+    expect(tips.checkpointed.block).toEqual(makeTip(5));
+    expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(1));
+  });
+
+  it('advances proven chain with checkpoint info', async () => {
+    // Propose and checkpoint blocks 1-5
+    const blocks = await Promise.all(times(5, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks });
+    const checkpoint1 = await makeCheckpoint(1, blocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    // Prove up to block 5
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proven',
+      block: makeBlockId(5),
+      checkpoint: makeCheckpointIdForBlock(5),
+    });
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(5));
+    expect(tips.checkpointed.block).toEqual(makeTip(5));
+    expect(tips.proven.block).toEqual(makeTip(5));
+
+    // Proven tip should have the checkpoint info
+    expect(tips.proven.checkpoint.number).toEqual(CheckpointNumber(1));
+    expect(tips.proven.checkpoint.hash).toEqual(checkpointHashes.get(1));
+  });
+
+  it('advances finalized chain with checkpoint info', async () => {
+    // Propose and checkpoint blocks 1-5
+    const blocks = await Promise.all(times(5, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks });
+    const checkpoint1 = await makeCheckpoint(1, blocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    // Prove and finalize
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proven',
+      block: makeBlockId(5),
+      checkpoint: makeCheckpointIdForBlock(5),
+    });
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-finalized',
+      block: makeBlockId(5),
+      checkpoint: makeCheckpointIdForBlock(5),
+    });
 
     const tips = await tipsStore.getL2Tips();
-    expect(tips).toEqual(makeTips(5, 3, 3));
+    expect(tips.proposed).toEqual(makeTip(5));
+    expect(tips.checkpointed.block).toEqual(makeTip(5));
+    expect(tips.proven.block).toEqual(makeTip(5));
+    expect(tips.finalized.block).toEqual(makeTip(5));
+
+    // Finalized tip should have checkpoint info
+    expect(tips.finalized.checkpoint.number).toEqual(CheckpointNumber(1));
+    expect(tips.finalized.checkpoint.hash).toEqual(checkpointHashes.get(1));
+  });
+
+  it('handles multiple checkpoints advancing the chain', async () => {
+    // Propose blocks 1-5
+    const blocks1 = await Promise.all(times(5, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks1 });
+
+    // Checkpoint 1: all proposed blocks 1-5
+    const checkpoint1 = await makeCheckpoint(1, blocks1);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    // Propose more blocks 6-10
+    const blocks2 = await Promise.all(times(5, i => makeBlock(i + 6)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks2 });
+
+    // Checkpoint 2: all remaining proposed blocks 6-10
+    const checkpoint2 = await makeCheckpoint(2, blocks2);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint2));
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(10));
+    expect(tips.checkpointed.block).toEqual(makeTip(10));
+    expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(2));
+    expect(tips.checkpointed.checkpoint.hash).toEqual(checkpointHashes.get(2));
+  });
+
+  it('clears block hashes when setting finalized chain', async () => {
+    // Propose blocks 1-3
+    const blocks1to3 = await Promise.all(times(3, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks1to3 });
+
+    // Checkpoint all proposed blocks (1-3)
+    const checkpoint1 = await makeCheckpoint(1, blocks1to3);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    // Propose more blocks 4-5
+    const blocks4to5 = await Promise.all(times(2, i => makeBlock(i + 4)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks4to5 });
+
+    // Checkpoint all remaining proposed blocks (4-5)
+    const checkpoint2 = await makeCheckpoint(2, blocks4to5);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint2));
+
+    // Prove and finalize up to block 3 (checkpoint 1)
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proven',
+      block: makeBlockId(3),
+      checkpoint: makeCheckpointIdForBlock(3),
+    });
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-finalized',
+      block: makeBlockId(3),
+      checkpoint: makeCheckpointIdForBlock(3),
+    });
 
+    // Blocks before finalized should be cleared
     expect(await tipsStore.getL2BlockHash(1)).toBeUndefined();
     expect(await tipsStore.getL2BlockHash(2)).toBeUndefined();
 
-    expect(await tipsStore.getL2BlockHash(3)).toEqual(new Fr(3).toString());
-    expect(await tipsStore.getL2BlockHash(4)).toEqual(new Fr(4).toString());
-    expect(await tipsStore.getL2BlockHash(5)).toEqual(new Fr(5).toString());
+    // Finalized and later blocks should remain
+    expect(await tipsStore.getL2BlockHash(3)).toEqual(blockHashes.get(3));
+    expect(await tipsStore.getL2BlockHash(4)).toEqual(blockHashes.get(4));
+    expect(await tipsStore.getL2BlockHash(5)).toEqual(blockHashes.get(5));
+  });
+
+  it('handles chain pruning by updating proposed tip', async () => {
+    const blocks = await Promise.all(times(10, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks });
+
+    // Prune to block 5
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-pruned',
+      block: makeBlockId(5),
+      checkpointed: makeTipId(0),
+      proven: makeTipId(0),
+    });
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(5));
+  });
+
+  it('handles pruning proposed chain to genesis, re-proposing, and checkpointing', async () => {
+    // Propose blocks 1-3
+    const firstBlocks = await Promise.all(times(3, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: firstBlocks });
+
+    let tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(3));
+
+    // Store original hashes
+    const originalHash1 = blockHashes.get(1);
+    const originalHash2 = blockHashes.get(2);
+    const originalHash3 = blockHashes.get(3);
+
+    // Prune back to genesis (block 0)
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-pruned',
+      block: makeTip(0),
+      checkpointed: makeTipId(0),
+      proven: makeTipId(0),
+    });
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(0));
+    expect(tips.checkpointed.block).toEqual(makeTip(0));
+
+    // Clear hashes and propose new blocks 1-3 (different from original)
+    blockHashes.delete(1);
+    blockHashes.delete(2);
+    blockHashes.delete(3);
+    const newBlocks = await Promise.all(times(3, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: newBlocks });
+
+    // Verify new blocks have different hashes
+    expect(blockHashes.get(1)).not.toEqual(originalHash1);
+    expect(blockHashes.get(2)).not.toEqual(originalHash2);
+    expect(blockHashes.get(3)).not.toEqual(originalHash3);
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(3));
+    expect(tips.checkpointed.block).toEqual(makeTip(0)); // Not yet checkpointed
+
+    // Checkpoint all the new proposed blocks (1-3)
+    const checkpoint1 = await makeCheckpoint(1, newBlocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(3));
+    expect(tips.checkpointed.block).toEqual(makeTip(3));
+    expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(1));
+
+    // Verify block hashes in store are the new ones
+    expect(await tipsStore.getL2BlockHash(1)).toEqual(blockHashes.get(1));
+    expect(await tipsStore.getL2BlockHash(2)).toEqual(blockHashes.get(2));
+    expect(await tipsStore.getL2BlockHash(3)).toEqual(blockHashes.get(3));
+  });
+
+  it('handles reorg: prune proposed blocks back to checkpoint, then re-propose with different blocks', async () => {
+    // Propose blocks 1-5
+    const firstBlocks = await Promise.all(times(5, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: firstBlocks });
+
+    // Checkpoint all proposed blocks (1-5) - these are now committed
+    const checkpoint1 = await makeCheckpoint(1, firstBlocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    // Propose more blocks 6-10 (not yet checkpointed, can be pruned)
+    const originalBlocks6to10 = await Promise.all(times(5, i => makeBlock(i + 6)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: originalBlocks6to10 });
+
+    let tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(10));
+    expect(tips.checkpointed.block).toEqual(makeTip(5)); // Only blocks 1-5 are checkpointed
+
+    // Store original hashes for proposed (non-checkpointed) blocks 6-8
+    const originalHash6 = blockHashes.get(6);
+    const originalHash7 = blockHashes.get(7);
+    const originalHash8 = blockHashes.get(8);
+
+    // Prune proposed blocks back to checkpoint (block 5)
+    // This removes proposed blocks 6-10, but checkpoint remains at 5
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-pruned',
+      block: makeBlockId(5),
+      checkpointed: makeTipId(5),
+      proven: makeTipId(0),
+    });
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(5));
+    expect(tips.checkpointed.block).toEqual(makeTip(5)); // Checkpoint unchanged
+
+    // Propose new blocks 6-8 (different from original 6-10)
+    blockHashes.delete(6);
+    blockHashes.delete(7);
+    blockHashes.delete(8);
+    const newBlocks = await Promise.all(times(3, i => makeBlock(i + 6)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: newBlocks });
+
+    // Verify the new blocks have different hashes than the original ones
+    expect(blockHashes.get(6)).not.toEqual(originalHash6);
+    expect(blockHashes.get(7)).not.toEqual(originalHash7);
+    expect(blockHashes.get(8)).not.toEqual(originalHash8);
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(8));
+    expect(tips.checkpointed.block).toEqual(makeTip(5)); // Still at checkpoint 1
+
+    // Checkpoint all the new proposed blocks (6-8)
+    const checkpoint2 = await makeCheckpoint(2, newBlocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint2));
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(8));
+    expect(tips.checkpointed.block).toEqual(makeTip(8));
+    expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(2));
+
+    // Block hashes in the store should reflect the new blocks
+    expect(await tipsStore.getL2BlockHash(6)).toEqual(blockHashes.get(6));
+    expect(await tipsStore.getL2BlockHash(7)).toEqual(blockHashes.get(7));
+    expect(await tipsStore.getL2BlockHash(8)).toEqual(blockHashes.get(8));
+
+    // And should NOT equal the original hashes
+    expect(await tipsStore.getL2BlockHash(6)).not.toEqual(originalHash6);
+    expect(await tipsStore.getL2BlockHash(7)).not.toEqual(originalHash7);
+    expect(await tipsStore.getL2BlockHash(8)).not.toEqual(originalHash8);
+  });
+
+  it('handles reorg with different chain length after prune', async () => {
+    // Propose blocks 1-3
+    const firstBlocks = await Promise.all(times(3, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: firstBlocks });
+
+    // Checkpoint all proposed blocks (1-3) - these are now committed
+    const checkpoint1 = await makeCheckpoint(1, firstBlocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    // Propose more blocks 4-10 (not yet checkpointed, can be pruned)
+    const originalBlocks4to10 = await Promise.all(times(7, i => makeBlock(i + 4)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: originalBlocks4to10 });
+
+    let tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(10));
+    expect(tips.checkpointed.block).toEqual(makeTip(3)); // Only blocks 1-3 are checkpointed
+
+    // Prune proposed blocks back to checkpoint (block 3)
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-pruned',
+      block: makeBlockId(3),
+      checkpointed: makeTipId(3),
+      proven: makeTipId(0),
+    });
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(3));
+    expect(tips.checkpointed.block).toEqual(makeTip(3)); // Checkpoint unchanged
+
+    // Now propose only 2 new blocks (4-5) instead of the original 7 blocks (4-10)
+    blockHashes.delete(4);
+    blockHashes.delete(5);
+    const newBlocks = await Promise.all(times(2, i => makeBlock(i + 4)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: newBlocks });
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(5));
+    expect(tips.checkpointed.block).toEqual(makeTip(3)); // Still at checkpoint 1
+
+    // Checkpoint all the new proposed blocks (4-5)
+    const checkpoint2 = await makeCheckpoint(2, newBlocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint2));
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(5));
+    expect(tips.checkpointed.block).toEqual(makeTip(5));
+    expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(2));
+  });
+
+  it('handles reorg: prune back to proven tip (including checkpointed blocks), then re-propose and checkpoint', async () => {
+    // Propose blocks 1-3
+    const firstBlocks = await Promise.all(times(3, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: firstBlocks });
+
+    // Checkpoint all proposed blocks (1-3)
+    const checkpoint1 = await makeCheckpoint(1, firstBlocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+
+    // Prove up to block 3
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proven',
+      block: makeBlockId(3),
+      checkpoint: makeCheckpointIdForBlock(3),
+    });
+
+    let tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(3));
+    expect(tips.checkpointed.block).toEqual(makeTip(3));
+    expect(tips.proven.block).toEqual(makeTip(3));
+
+    // Propose more blocks 4-6
+    const blocks4to6 = await Promise.all(times(3, i => makeBlock(i + 4)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks4to6 });
+
+    // Checkpoint blocks 4-6 (now checkpointed is ahead of proven)
+    const checkpoint2 = await makeCheckpoint(2, blocks4to6);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint2));
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(6));
+    expect(tips.checkpointed.block).toEqual(makeTip(6));
+    expect(tips.proven.block).toEqual(makeTip(3)); // Proven is behind checkpointed
+
+    // Propose even more blocks 7-10 (proposed is now ahead of checkpointed)
+    const originalBlocks7to10 = await Promise.all(times(4, i => makeBlock(i + 7)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: originalBlocks7to10 });
+
+    tips = await tipsStore.getL2Tips();
+    // Now all three tips are different: proposed=10, checkpointed=6, proven=3
+    expect(tips.proposed).toEqual(makeTip(10));
+    expect(tips.checkpointed.block).toEqual(makeTip(6));
+    expect(tips.proven.block).toEqual(makeTip(3));
+
+    // Store original hashes for blocks 4-7
+    const originalHash4 = blockHashes.get(4);
+    const originalHash5 = blockHashes.get(5);
+    const originalHash6 = blockHashes.get(6);
+    const originalHash7 = blockHashes.get(7);
+
+    // Prune all the way back to proven tip (block 3)
+    // This prunes both proposed blocks (7-10) AND checkpointed blocks (4-6)
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-pruned',
+      block: makeBlockId(3),
+      checkpointed: makeTipId(3),
+      proven: makeTipId(3),
+    });
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(3));
+    expect(tips.checkpointed.block).toEqual(makeTip(3)); // Checkpointed also pruned back
+    expect(tips.proven.block).toEqual(makeTip(3));
+
+    // Propose new blocks 4-7 (different from original)
+    blockHashes.delete(4);
+    blockHashes.delete(5);
+    blockHashes.delete(6);
+    blockHashes.delete(7);
+    const newBlocks = await Promise.all(times(4, i => makeBlock(i + 4)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: newBlocks });
+
+    // Verify the new blocks have different hashes than the original ones
+    expect(blockHashes.get(4)).not.toEqual(originalHash4);
+    expect(blockHashes.get(5)).not.toEqual(originalHash5);
+    expect(blockHashes.get(6)).not.toEqual(originalHash6);
+    expect(blockHashes.get(7)).not.toEqual(originalHash7);
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(7));
+    expect(tips.proven.block).toEqual(makeTip(3));
+
+    // Checkpoint all the new proposed blocks (4-7)
+    const checkpoint3 = await makeCheckpoint(3, newBlocks);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint3));
+
+    tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(7));
+    expect(tips.checkpointed.block).toEqual(makeTip(7));
+    expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(3));
+    expect(tips.proven.block).toEqual(makeTip(3)); // Proven hasn't moved yet
+
+    // Block hashes in the store should reflect the new blocks
+    expect(await tipsStore.getL2BlockHash(4)).toEqual(blockHashes.get(4));
+    expect(await tipsStore.getL2BlockHash(5)).toEqual(blockHashes.get(5));
+    expect(await tipsStore.getL2BlockHash(6)).toEqual(blockHashes.get(6));
+    expect(await tipsStore.getL2BlockHash(7)).toEqual(blockHashes.get(7));
+
+    // And should NOT equal the original hashes
+    expect(await tipsStore.getL2BlockHash(4)).not.toEqual(originalHash4);
+    expect(await tipsStore.getL2BlockHash(5)).not.toEqual(originalHash5);
+    expect(await tipsStore.getL2BlockHash(6)).not.toEqual(originalHash6);
+    expect(await tipsStore.getL2BlockHash(7)).not.toEqual(originalHash7);
   });
 
-  // Regression test for #13142
-  it('does not blow up when setting proven chain on an unseen block number', async () => {
-    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: [makeBlock(5)] });
-    await tipsStore.handleBlockStreamEvent({ type: 'chain-proven', block: makeBlockId(3) });
+  // Regression test for #13142: proving an unseen block number (one with no local block->checkpoint
+  // mapping) must not blow up. With per-cursor checkpoint ids, the proven tip resolves to the
+  // checkpoint id carried by the event rather than falling back to checkpoint zero.
+  it('resolves the proven checkpoint from the carried id when setting proven on an unseen block number', async () => {
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: [await makeBlock(5)] });
+    // Block 3 has no local block->checkpoint mapping, but the event carries a real checkpoint id.
+    const carriedCheckpoint: CheckpointId = { number: CheckpointNumber(1), hash: new Fr(42).toString() };
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proven',
+      block: makeBlockId(3),
+      checkpoint: carriedCheckpoint,
+    });
 
     const tips = await tipsStore.getL2Tips();
-    expect(tips).toEqual(makeTips(5, 3, 0));
+    expect(tips.proposed).toEqual(makeTip(5));
+    expect(tips.proven.block).toEqual(makeTip(3));
+    // Resolved from the carried id, not the (missing) local mapping.
+    expect(tips.proven.checkpoint).toEqual(carriedCheckpoint);
+  });
+
+  // proven/finalized resolve to the carried checkpoint id even when the block has no local
+  // block->checkpoint mapping (the cursor legitimately leads the locally-checkpointed frontier).
+  it('resolves proven and finalized checkpoints from carried ids without a local mapping', async () => {
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: [await makeBlock(7)] });
+    const provenCheckpoint: CheckpointId = { number: CheckpointNumber(2), hash: new Fr(101).toString() };
+    const finalizedCheckpoint: CheckpointId = { number: CheckpointNumber(1), hash: new Fr(100).toString() };
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proven',
+      block: makeBlockId(5),
+      checkpoint: provenCheckpoint,
+    });
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-finalized',
+      block: makeBlockId(3),
+      checkpoint: finalizedCheckpoint,
+    });
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips.proven.checkpoint).toEqual(provenCheckpoint);
+    expect(tips.finalized.checkpoint).toEqual(finalizedCheckpoint);
+  });
+
+  // Genuine corruption: a cursor points at a real (non-genesis) block that has a block hash but
+  // neither a stored per-cursor checkpoint id nor a block->checkpoint mapping. getL2Tips must throw
+  // loudly rather than silently report checkpoint zero. We reach this state by reaching past the
+  // event API to place the tip directly, since the normal writers always record an id.
+  it('throws when a cursor points at a real block with neither a stored id nor a mapping', async () => {
+    // blocks-added records the block hash for block 5 (so getBlockId succeeds) but no checkpoint id.
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: [await makeBlock(5)] });
+    // Corrupt the proven cursor to point at block 5 without any id or mapping.
+    const internal = tipsStore as unknown as { setTip(tag: L2BlockTag, blockNumber: BlockNumber): Promise<void> };
+    await internal.setTip('proven', BlockNumber(5));
+
+    await expect(tipsStore.getL2Tips()).rejects.toThrow(/checkpoint/i);
+  });
+
+  // Backward prune of a leading cursor: a checkpoint-bearing cursor that legitimately leads the source's
+  // confirmed checkpointed tip is clamped down to that tip, resolving to the id the prune event carries
+  // (never genesis, never a throw). This is the skipped-history shape where the cursor sits on a block
+  // ahead of the checkpointed frontier.
+  it('clamps a leading checkpoint cursor down to the source checkpointed tip carried by the prune event', async () => {
+    // Checkpoint blocks 1-5 (checkpointed = block 5 / ckpt 1), then add uncheckpointed blocks 6-10.
+    const blocks1to5 = await Promise.all(times(5, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks1to5 });
+    const checkpoint1 = await makeCheckpoint(1, blocks1to5);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1));
+    const blocks6to10 = await Promise.all(times(5, i => makeBlock(i + 6)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks6to10 });
+
+    // Advance the proven cursor onto an uncheckpointed block (8) via a carried id, so it LEADS the
+    // source checkpointed tip (block 5) and will be clamped down to it on prune.
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proven',
+      block: makeBlockId(8),
+      checkpoint: { number: CheckpointNumber(2), hash: new Fr(202).toString() },
+    });
+
+    // Prune to block 7, carrying the source's confirmed checkpointed and proven tips (both block 5 / ckpt 1
+    // here, the source's proven tip having rolled back together with its checkpointed tip).
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-pruned',
+      block: makeBlockId(7),
+      checkpointed: makeTipId(5),
+      proven: makeTipId(5),
+    });
+
+    // Must not throw; the proven cursor is clamped to the carried proven tip, resolving to ckpt 1.
+    const tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(7));
+    expect(tips.proven.block).toEqual(makeTip(5));
+    expect(tips.proven.checkpoint.number).toEqual(CheckpointNumber(1));
+  });
+
+  it('keeps the checkpointed tip when pruning to an uncheckpointed block ahead of it', async () => {
+    const blocks1to5 = await Promise.all(times(5, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks1to5 });
+    const checkpoint1 = await makeCheckpoint(1, blocks1to5);
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(checkpoint1)); // checkpointed = block 5 / ckpt 1
+
+    const blocks6to7 = await Promise.all(times(2, i => makeBlock(i + 6)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks6to7 }); // proposed = 7
+
+    // Prune to block 6: an uncheckpointed block AHEAD of the checkpointed tip (block 5). The source
+    // checkpointed tip is still block 5 / ckpt 1, so the checkpointed cursor must not move.
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-pruned',
+      block: makeBlockId(6),
+      checkpointed: makeTipId(5),
+      proven: makeTipId(0),
+    });
+
+    const tips = await tipsStore.getL2Tips();
+    expect(tips.proposed).toEqual(makeTip(6));
+    expect(tips.checkpointed.block).toEqual(makeTip(5));
+    expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(1)); // must NOT be zero
+  });
+
+  // Per-cursor clamping on prune: when the source rolls back its proven tip below its checkpointed tip
+  // (e.g. a proof tx dropped by an L1 reorg), the prune event carries both source tips and each local
+  // cursor must clamp to its OWN source tip. Clamping the proven cursor onto the (higher) checkpointed
+  // tip would transiently report unproven blocks as proven until the corrective chain-proven event lands.
+  it('clamps the proven cursor to the source proven tip, separately from the checkpointed cursor, on prune', async () => {
+    // Checkpoint blocks 1-15 across three checkpoints (ckpt 1 = 1-5, ckpt 2 = 6-10, ckpt 3 = 11-15).
+    const blocks1to5 = await Promise.all(times(5, i => makeBlock(i + 1)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks1to5 });
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(await makeCheckpoint(1, blocks1to5)));
+    const blocks6to10 = await Promise.all(times(5, i => makeBlock(i + 6)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks6to10 });
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(await makeCheckpoint(2, blocks6to10)));
+    const blocks11to15 = await Promise.all(times(5, i => makeBlock(i + 11)));
+    await tipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: blocks11to15 });
+    await tipsStore.handleBlockStreamEvent(await makeCheckpointedEvent(await makeCheckpoint(3, blocks11to15)));
+
+    // Prove the whole chain up to block 15 (ckpt 3), so the local proven cursor leads both source tips below.
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-proven',
+      block: makeBlockId(15),
+      checkpoint: makeCheckpointIdForBlock(15),
+    });
+
+    let tips = await tipsStore.getL2Tips();
+    expect(tips.checkpointed.block).toEqual(makeTip(15));
+    expect(tips.proven.block).toEqual(makeTip(15));
+
+    // Prune arrives with the source's proven tip (block 5 / ckpt 1) BELOW its checkpointed tip (block 10 /
+    // ckpt 2) and below the local proven cursor (block 15). Each cursor must clamp to its own source tip.
+    await tipsStore.handleBlockStreamEvent({
+      type: 'chain-pruned',
+      block: makeBlockId(10),
+      checkpointed: makeTipId(10),
+      proven: makeTipId(5),
+    });
+
+    tips = await tipsStore.getL2Tips();
+    // The proven cursor lands exactly on the source proven tip, NOT on the (higher) checkpointed tip.
+    expect(tips.proven.block).toEqual(makeTip(5));
+    expect(tips.proven.checkpoint.number).toEqual(CheckpointNumber(1));
+    // The checkpointed cursor lands on the source checkpointed tip.
+    expect(tips.checkpointed.block).toEqual(makeTip(10));
+    expect(tips.checkpointed.checkpoint.number).toEqual(CheckpointNumber(2));
   });
 }