@aztec/stdlib 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -1,10 +1,15 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 
+import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
 import { type L2BlockId, type L2BlockSource, makeL2BlockId } from '../l2_block_source.js';
 import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
 
+/** Maximum number of checkpoints to prefetch at once during sync. Matches MAX_RPC_CHECKPOINTS_LEN. */
+export const CHECKPOINT_PREFETCH_LIMIT = 50;
+
 /** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
 export class L2BlockStream {
   private readonly runningPromise: RunningPromise;
@@ -12,19 +17,29 @@ export class L2BlockStream {
   private hasStarted = false;
 
   constructor(
-    private l2BlockSource: Pick<L2BlockSource, 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'>,
+    private l2BlockSource: Pick<
+      L2BlockSource,
+      'getBlocks' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpoints' | 'getCheckpointedBlocks'
+    >,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
     private opts: {
-      proven?: boolean;
       pollIntervalMS?: number;
       batchSize?: number;
       startingBlock?: number;
       /** Instead of downloading all blocks, only fetch the smallest subset that results in reliable reorg detection. */
       skipFinalized?: boolean;
+      /** When true, checkpoint events will not be emitted. Blocks are still fetched via checkpoints but only blocks-added events are emitted. */
+      ignoreCheckpoints?: boolean;
+      /** Maximum number of checkpoints to prefetch at once during sync. Defaults to CHECKPOINT_PREFETCH_LIMIT (50). */
+      checkpointPrefetchLimit?: number;
     } = {},
   ) {
+    // Note that RunningPromise is in stopped state by default. This promise won't run until someone invokes `start`,
+    // which makes it run periodically, or `sync`, which triggers it once.
+    // Users of L2BlockStream decide what mode to run it in (_periodically_ vs _manually triggered_).
+    // The default is _manually triggered_.
     this.runningPromise = new RunningPromise(() => this.work(), log, this.opts.pollIntervalMS ?? 1000);
   }
 
@@ -41,6 +56,11 @@ export class L2BlockStream {
     return this.runningPromise.isRunning();
   }
 
+  /**
+   * Runs the synchronization process once.
+   *
+   * If you want to run this process continuously use `start` and `stop` instead.
+   */
   public async sync() {
     this.isSyncing = true;
     await this.runningPromise.trigger();
@@ -51,41 +71,34 @@ export class L2BlockStream {
     try {
       const sourceTips = await this.l2BlockSource.getL2Tips();
       const localTips = await this.localData.getL2Tips();
-      this.log.trace(`Running L2 block stream`, {
-        sourceLatest: sourceTips.latest.number,
-        localLatest: localTips.latest.number,
-        sourceFinalized: sourceTips.finalized.number,
-        localFinalized: localTips.finalized.number,
-        sourceProven: sourceTips.proven.number,
-        localProven: localTips.proven.number,
-        sourceLatestHash: sourceTips.latest.hash,
-        localLatestHash: localTips.latest.hash,
-        sourceProvenHash: sourceTips.proven.hash,
-        localProvenHash: localTips.proven.hash,
-        sourceFinalizedHash: sourceTips.finalized.hash,
-        localFinalizedHash: localTips.finalized.hash,
-      });
+      this.log.trace(`Running L2 block stream`, { sourceTips, localTips });
 
       // Check if there was a reorg and emit a chain-pruned event if so.
-      let latestBlockNumber = localTips.latest.number;
-      const sourceCache = new BlockHashCache([sourceTips.latest]);
+      let latestBlockNumber = localTips.proposed.number;
+      const sourceCache = new BlockHashCache([sourceTips.proposed]);
       while (!(await this.areBlockHashesEqualAt(latestBlockNumber, { sourceCache }))) {
         latestBlockNumber--;
       }
 
-      if (latestBlockNumber < localTips.latest.number) {
-        latestBlockNumber = Math.min(latestBlockNumber, sourceTips.latest.number); // see #13471
+      if (latestBlockNumber < localTips.proposed.number) {
+        latestBlockNumber = BlockNumber(Math.min(latestBlockNumber, sourceTips.proposed.number)); // see #13471
         const hash = sourceCache.get(latestBlockNumber) ?? (await this.getBlockHashFromSource(latestBlockNumber));
         if (latestBlockNumber !== 0 && !hash) {
           throw new Error(`Block hash not found in block source for block number ${latestBlockNumber}`);
         }
-        this.log.verbose(`Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.latest.number}.`);
-        await this.emitEvent({ type: 'chain-pruned', block: makeL2BlockId(latestBlockNumber, hash) });
+        this.log.verbose(
+          `Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.proposed.number}.`,
+        );
+        await this.emitEvent({
+          type: 'chain-pruned',
+          block: makeL2BlockId(latestBlockNumber, hash),
+          checkpoint: sourceTips.checkpointed.checkpoint,
+        });
       }
 
       // If we are just starting, use the starting block number from the options.
       if (latestBlockNumber === 0 && this.opts.startingBlock !== undefined) {
-        latestBlockNumber = Math.max(this.opts.startingBlock - 1, 0);
+        latestBlockNumber = BlockNumber(Math.max(this.opts.startingBlock - 1, 0));
       }
 
       // Only log this entry once (for sanity)
@@ -95,36 +108,128 @@ export class L2BlockStream {
       }
 
       let nextBlockNumber = latestBlockNumber + 1;
+      let nextCheckpointToEmit = CheckpointNumber(localTips.checkpointed.checkpoint.number + 1);
       if (this.opts.skipFinalized) {
         // When skipping finalized blocks we need to provide reliable reorg detection while fetching as few blocks as
         // possible. Finalized blocks cannot be reorged by definition, so we can skip most of them. We do need the very
         // last finalized block however in order to guarantee that we will eventually find a block in which our local
         // store matches the source.
         // If the last finalized block is behind our local tip, there is nothing to skip.
-        nextBlockNumber = Math.max(sourceTips.finalized.number, nextBlockNumber);
+        nextBlockNumber = Math.max(sourceTips.finalized.block.number, nextBlockNumber);
+        // If the next checkpoint to emit is behind the finalized tip then skip forward
+        nextCheckpointToEmit = CheckpointNumber(Math.max(nextCheckpointToEmit, sourceTips.finalized.checkpoint.number));
+      }
+
+      // Loop 1: Emit checkpoint events for checkpoints whose blocks are already in local storage.
+      // This handles the case where blocks were synced as uncheckpointed and later became checkpointed.
+      // The guard `lastBlockInCheckpoint.number > localTips.proposed.number` ensures we don't emit
+      // checkpoints for blocks we don't have (e.g., when startingBlock skips earlier blocks).
+      // Since only one checkpoint can ever be uncheckpointed, this loop should iterate at most once.
+      if (!this.opts.ignoreCheckpoints) {
+        let loop1Iterations = 0;
+        while (nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number) {
+          const checkpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointToEmit, 1);
+          if (checkpoints.length === 0) {
+            break;
+          }
+          const lastBlockInCheckpoint = checkpoints[0].checkpoint.blocks.at(-1)!;
+          // If this checkpoint has blocks we haven't seen yet, stop - they need to be fetched first
+          if (lastBlockInCheckpoint.number > localTips.proposed.number) {
+            break;
+          }
+          loop1Iterations++;
+          if (loop1Iterations > 1) {
+            this.log.warn(
+              `Emitting multiple checkpoints (${loop1Iterations}) for already-local blocks. ` +
+                `Next checkpoint: ${nextCheckpointToEmit}, source checkpointed: ${sourceTips.checkpointed.checkpoint.number}`,
+            );
+          }
+          const lastBlockHash = await lastBlockInCheckpoint.hash();
+          await this.emitEvent({
+            type: 'chain-checkpointed',
+            checkpoint: checkpoints[0],
+            block: makeL2BlockId(lastBlockInCheckpoint.number, lastBlockHash.toString()),
+          });
+          nextCheckpointToEmit = CheckpointNumber(nextCheckpointToEmit + 1);
+        }
+      }
+
+      // Loop 2: Fetch new checkpointed blocks. For each checkpoint, emit all blocks
+      // from that checkpoint that we need, then emit the checkpoint event.
+      // We prefetch multiple checkpoints, then process them one by one.
+      let prefetchedCheckpoints: PublishedCheckpoint[] = [];
+      let prefetchIdx = 0;
+      let nextCheckpointNumber: CheckpointNumber | undefined;
+
+      // Find the starting checkpoint number
+      if (nextBlockNumber <= sourceTips.checkpointed.block.number) {
+        const blocks = await this.l2BlockSource.getCheckpointedBlocks(BlockNumber(nextBlockNumber), 1);
+        if (blocks.length > 0) {
+          nextCheckpointNumber = blocks[0].checkpointNumber;
+        }
+      }
+
+      while (nextBlockNumber <= sourceTips.checkpointed.block.number && nextCheckpointNumber !== undefined) {
+        // Refill the prefetch buffer when exhausted
+        if (prefetchIdx >= prefetchedCheckpoints.length) {
+          const prefetchLimit = this.opts.checkpointPrefetchLimit ?? CHECKPOINT_PREFETCH_LIMIT;
+          prefetchedCheckpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointNumber, prefetchLimit);
+          prefetchIdx = 0;
+          if (prefetchedCheckpoints.length === 0) {
+            break;
+          }
+        }
+
+        const checkpoint = prefetchedCheckpoints[prefetchIdx]!;
+
+        // Get all blocks from this checkpoint that we need, respecting batchSize
+        const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.checkpointed.block.number - nextBlockNumber + 1);
+        const blocksForCheckpoint = checkpoint.checkpoint.blocks
+          .filter(b => b.number >= nextBlockNumber)
+          .slice(0, limit);
+        if (blocksForCheckpoint.length === 0) {
+          break;
+        }
+        await this.emitEvent({ type: 'blocks-added', blocks: blocksForCheckpoint });
+        nextBlockNumber = blocksForCheckpoint.at(-1)!.number + 1;
+
+        // If we've reached the end of this checkpoint, emit the checkpoint event and move to next
+        const lastBlockInCheckpoint = checkpoint.checkpoint.blocks.at(-1)!;
+        if (nextBlockNumber > lastBlockInCheckpoint.number) {
+          if (!this.opts.ignoreCheckpoints) {
+            const lastBlockHash = await lastBlockInCheckpoint.hash();
+            await this.emitEvent({
+              type: 'chain-checkpointed',
+              checkpoint,
+              block: makeL2BlockId(lastBlockInCheckpoint.number, lastBlockHash.toString()),
+            });
+          }
+          prefetchIdx++;
+          nextCheckpointNumber = CheckpointNumber(nextCheckpointNumber + 1);
+        }
       }
 
-      // Request new blocks from the source.
-      while (nextBlockNumber <= sourceTips.latest.number) {
-        const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.latest.number - nextBlockNumber + 1);
-        this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getPublishedBlocks(nextBlockNumber, limit, this.opts.proven);
+      // Loop 3: Fetch any remaining uncheckpointed (proposed) blocks.
+      while (nextBlockNumber <= sourceTips.proposed.number) {
+        const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.proposed.number - nextBlockNumber + 1);
+        this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit}`);
+        const blocks = await this.l2BlockSource.getBlocks(BlockNumber(nextBlockNumber), BlockNumber(limit));
         if (blocks.length === 0) {
           break;
         }
         await this.emitEvent({ type: 'blocks-added', blocks });
-        nextBlockNumber = blocks.at(-1)!.block.number + 1;
+        nextBlockNumber = blocks.at(-1)!.number + 1;
       }
 
       // Update the proven and finalized tips.
-      if (localTips.proven !== undefined && sourceTips.proven.number !== localTips.proven.number) {
+      if (localTips.proven !== undefined && sourceTips.proven.block.number !== localTips.proven.block.number) {
         await this.emitEvent({
           type: 'chain-proven',
-          block: sourceTips.proven,
+          block: sourceTips.proven.block,
         });
       }
-      if (localTips.finalized !== undefined && sourceTips.finalized.number !== localTips.finalized.number) {
-        await this.emitEvent({ type: 'chain-finalized', block: sourceTips.finalized });
+      if (localTips.finalized !== undefined && sourceTips.finalized.block.number !== localTips.finalized.block.number) {
+        await this.emitEvent({ type: 'chain-finalized', block: sourceTips.finalized.block });
       }
     } catch (err: any) {
       if (err.name === 'AbortError') {
@@ -139,7 +244,7 @@ export class L2BlockStream {
    * @param blockNumber - The block number to test.
    * @param args - A cache of data already requested from source, to avoid re-requesting it.
    */
-  private async areBlockHashesEqualAt(blockNumber: number, args: { sourceCache: BlockHashCache }) {
+  private async areBlockHashesEqualAt(blockNumber: BlockNumber, args: { sourceCache: BlockHashCache }) {
     if (blockNumber === 0) {
       return true;
     }
@@ -163,7 +268,7 @@ export class L2BlockStream {
     return localBlockHash === sourceBlockHash;
   }
 
-  private getBlockHashFromSource(blockNumber: number) {
+  private getBlockHashFromSource(blockNumber: BlockNumber) {
     return this.l2BlockSource
       .getBlockHeader(blockNumber)
       .then(h => h?.hash())
@@ -172,7 +277,7 @@ export class L2BlockStream {
 
   private async emitEvent(event: L2BlockStreamEvent) {
     this.log.debug(
-      `Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.block.number})`,
+      `Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.type === 'chain-checkpointed' ? event.checkpoint.checkpoint.number : event.block.number})`,
     );
     await this.handler.handleBlockStreamEvent(event);
     if (!this.isRunning() && !this.isSyncing) {

package/src/block/l2_block_stream/l2_tips_memory_store.ts

@@ -1,75 +1,84 @@
-import type { L2Block } from '../l2_block.js';
-import type { L2BlockId, L2BlockTag, L2Tips } from '../l2_block_source.js';
-import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+
+import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import type { L2BlockTag } from '../l2_block_source.js';
+import { L2TipsStoreBase } from './l2_tips_store_base.js';
 
 /**
- * Stores currently synced L2 tips and unfinalized block hashes.
- * @dev tests in kv-store/src/stores/l2_tips_memory_store.test.ts
+ * In-memory implementation of L2 tips store. Useful for testing and lightweight clients.
+ * @dev Tests in kv-store/src/stores/l2_tips_memory_store.test.ts
  */
-export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider {
-  protected readonly l2TipsStore: Map<L2BlockTag, number> = new Map();
-  protected readonly l2BlockHashesStore: Map<number, string> = new Map();
+export class L2TipsMemoryStore extends L2TipsStoreBase {
+  private readonly tips = new Map<L2BlockTag, BlockNumber>();
+  private readonly blockHashes = new Map<number, string>();
+  private readonly blockToCheckpoint = new Map<number, CheckpointNumber>();
+  private readonly checkpoints = new Map<number, PublishedCheckpoint>();
 
-  public getL2BlockHash(number: number): Promise<string | undefined> {
-    return Promise.resolve(this.l2BlockHashesStore.get(number));
+  protected getTip(tag: L2BlockTag): Promise<BlockNumber | undefined> {
+    return Promise.resolve(this.tips.get(tag));
   }
 
-  public getL2Tips(): Promise<L2Tips> {
-    return Promise.resolve({
-      latest: this.getL2Tip('latest'),
-      finalized: this.getL2Tip('finalized'),
-      proven: this.getL2Tip('proven'),
-    });
+  protected setTip(tag: L2BlockTag, blockNumber: BlockNumber): Promise<void> {
+    this.tips.set(tag, blockNumber);
+    return Promise.resolve();
   }
 
-  private getL2Tip(tag: L2BlockTag): L2BlockId {
-    const blockNumber = this.l2TipsStore.get(tag);
-    if (blockNumber === undefined || blockNumber === 0) {
-      return { number: 0, hash: undefined };
-    }
-    const blockHash = this.l2BlockHashesStore.get(blockNumber);
-    if (!blockHash) {
-      throw new Error(`Block hash not found for block number ${blockNumber}`);
+  protected getStoredBlockHash(blockNumber: BlockNumber): Promise<string | undefined> {
+    return Promise.resolve(this.blockHashes.get(blockNumber));
+  }
+
+  protected setBlockHash(blockNumber: BlockNumber, hash: string): Promise<void> {
+    this.blockHashes.set(blockNumber, hash);
+    return Promise.resolve();
+  }
+
+  protected deleteBlockHashesBefore(blockNumber: BlockNumber): Promise<void> {
+    for (const key of this.blockHashes.keys()) {
+      if (key < blockNumber) {
+        this.blockHashes.delete(key);
+      }
     }
+    return Promise.resolve();
+  }
 
-    return { number: blockNumber, hash: blockHash };
+  protected getCheckpointNumberForBlock(blockNumber: BlockNumber): Promise<CheckpointNumber | undefined> {
+    return Promise.resolve(this.blockToCheckpoint.get(blockNumber));
   }
 
-  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
-    switch (event.type) {
-      case 'blocks-added': {
-        const blocks = event.blocks.map(b => b.block);
-        for (const block of blocks) {
-          this.l2BlockHashesStore.set(block.number, await this.computeBlockHash(block));
-        }
-        this.l2TipsStore.set('latest', blocks.at(-1)!.number);
-        break;
+  protected setCheckpointNumberForBlock(blockNumber: BlockNumber, checkpointNumber: CheckpointNumber): Promise<void> {
+    this.blockToCheckpoint.set(blockNumber, checkpointNumber);
+    return Promise.resolve();
+  }
+
+  protected deleteBlockToCheckpointBefore(blockNumber: BlockNumber): Promise<void> {
+    for (const key of this.blockToCheckpoint.keys()) {
+      if (key < blockNumber) {
+        this.blockToCheckpoint.delete(key);
       }
-      case 'chain-pruned':
-        this.saveTag('latest', event.block);
-        break;
-      case 'chain-proven':
-        this.saveTag('proven', event.block);
-        break;
-      case 'chain-finalized':
-        this.saveTag('finalized', event.block);
-        for (const key of this.l2BlockHashesStore.keys()) {
-          if (key < event.block.number) {
-            this.l2BlockHashesStore.delete(key);
-          }
-        }
-        break;
     }
+    return Promise.resolve();
+  }
+
+  protected getCheckpoint(checkpointNumber: CheckpointNumber): Promise<PublishedCheckpoint | undefined> {
+    return Promise.resolve(this.checkpoints.get(checkpointNumber));
   }
 
-  protected saveTag(name: L2BlockTag, block: L2BlockId) {
-    this.l2TipsStore.set(name, block.number);
-    if (block.hash) {
-      this.l2BlockHashesStore.set(block.number, block.hash);
+  protected saveCheckpointData(checkpoint: PublishedCheckpoint): Promise<void> {
+    this.checkpoints.set(checkpoint.checkpoint.number, checkpoint);
+    return Promise.resolve();
+  }
+
+  protected deleteCheckpointsBefore(checkpointNumber: CheckpointNumber): Promise<void> {
+    for (const key of this.checkpoints.keys()) {
+      if (key < checkpointNumber) {
+        this.checkpoints.delete(key);
+      }
     }
+    return Promise.resolve();
   }
 
-  protected computeBlockHash(block: L2Block) {
-    return block.hash().then(hash => hash.toString());
+  protected runInTransaction<T>(fn: () => Promise<T>): Promise<T> {
+    // Memory store doesn't need transactions - just execute immediately
+    return fn();
   }
 }

package/src/block/l2_block_stream/l2_tips_store_base.ts

@@ -0,0 +1,226 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+
+import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import type { L2Block } from '../l2_block.js';
+import {
+  type CheckpointId,
+  GENESIS_CHECKPOINT_HEADER_HASH,
+  type L2BlockId,
+  type L2BlockTag,
+  type L2Tips,
+} from '../l2_block_source.js';
+import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
+
+/**
+ * Abstract base class for L2 tips stores. Provides common event handling logic
+ * while delegating storage operations to subclasses.
+ */
+export abstract class L2TipsStoreBase implements L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider {
+  // Abstract storage primitives - subclasses implement these based on their backing store
+
+  /** Gets the block number for a given tag. */
+  protected abstract getTip(tag: L2BlockTag): Promise<BlockNumber | undefined>;
+
+  /** Sets the block number for a given tag. */
+  protected abstract setTip(tag: L2BlockTag, blockNumber: BlockNumber): Promise<void>;
+
+  /** Gets the block hash for a given block number. */
+  protected abstract getStoredBlockHash(blockNumber: BlockNumber): Promise<string | undefined>;
+
+  /** Sets the block hash for a given block number. */
+  protected abstract setBlockHash(blockNumber: BlockNumber, hash: string): Promise<void>;
+
+  /** Deletes all block hashes for blocks before the given block number. */
+  protected abstract deleteBlockHashesBefore(blockNumber: BlockNumber): Promise<void>;
+
+  /** Gets the checkpoint number for a given block number. */
+  protected abstract getCheckpointNumberForBlock(blockNumber: BlockNumber): Promise<CheckpointNumber | undefined>;
+
+  /** Sets the checkpoint number for a given block number. */
+  protected abstract setCheckpointNumberForBlock(
+    blockNumber: BlockNumber,
+    checkpointNumber: CheckpointNumber,
+  ): Promise<void>;
+
+  /** Deletes all block-to-checkpoint mappings for blocks before the given block number. */
+  protected abstract deleteBlockToCheckpointBefore(blockNumber: BlockNumber): Promise<void>;
+
+  /** Gets a checkpoint by its number. */
+  protected abstract getCheckpoint(checkpointNumber: CheckpointNumber): Promise<PublishedCheckpoint | undefined>;
+
+  /** Saves a checkpoint. */
+  protected abstract saveCheckpointData(checkpoint: PublishedCheckpoint): Promise<void>;
+
+  /** Deletes all checkpoints before the given checkpoint number. */
+  protected abstract deleteCheckpointsBefore(checkpointNumber: CheckpointNumber): Promise<void>;
+
+  /** Runs the given function in a transaction. Memory stores can just execute immediately. */
+  protected abstract runInTransaction<T>(fn: () => Promise<T>): Promise<T>;
+
+  // Public interface implementation
+
+  public getL2BlockHash(number: BlockNumber): Promise<string | undefined> {
+    return this.getStoredBlockHash(number);
+  }
+
+  public getL2Tips(): Promise<L2Tips> {
+    return this.runInTransaction(async () => {
+      const [proposedBlockId, finalizedBlockId, provenBlockId, checkpointedBlockId] = await Promise.all([
+        this.getBlockId('proposed'),
+        this.getBlockId('finalized'),
+        this.getBlockId('proven'),
+        this.getBlockId('checkpointed'),
+      ]);
+
+      const [finalizedCheckpointId, provenCheckpointId, checkpointedCheckpointId] = await Promise.all([
+        this.getCheckpointId('finalized'),
+        this.getCheckpointId('proven'),
+        this.getCheckpointId('checkpointed'),
+      ]);
+
+      return {
+        proposed: proposedBlockId,
+        finalized: { block: finalizedBlockId, checkpoint: finalizedCheckpointId },
+        proven: { block: provenBlockId, checkpoint: provenCheckpointId },
+        checkpointed: { block: checkpointedBlockId, checkpoint: checkpointedCheckpointId },
+      };
+    });
+  }
+
+  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+    switch (event.type) {
+      case 'blocks-added':
+        await this.handleBlocksAdded(event);
+        break;
+      case 'chain-checkpointed':
+        await this.handleChainCheckpointed(event);
+        break;
+      case 'chain-pruned':
+        await this.handleChainPruned(event);
+        break;
+      case 'chain-proven':
+        await this.handleChainProven(event);
+        break;
+      case 'chain-finalized':
+        await this.handleChainFinalized(event);
+        break;
+    }
+  }
+
+  // Protected helper that subclasses can override for block hash computation
+  protected computeBlockHash(block: L2Block): Promise<string> {
+    return block.hash().then(hash => hash.toString());
+  }
+
+  // Private implementation
+
+  private async getBlockId(tag: L2BlockTag): Promise<L2BlockId> {
+    const blockNumber = await this.getTip(tag);
+    if (blockNumber === undefined || blockNumber === 0) {
+      return { number: BlockNumber.ZERO, hash: GENESIS_BLOCK_HEADER_HASH.toString() };
+    }
+    const blockHash = await this.getStoredBlockHash(blockNumber);
+    if (!blockHash) {
+      throw new Error(`Block hash not found for block number ${blockNumber}`);
+    }
+    return { number: blockNumber, hash: blockHash };
+  }
+
+  private async getCheckpointId(tag: L2BlockTag): Promise<CheckpointId> {
+    const blockNumber = await this.getTip(tag);
+    if (blockNumber === undefined || blockNumber === 0) {
+      return { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() };
+    }
+    const checkpointNumber = await this.getCheckpointNumberForBlock(blockNumber);
+    if (checkpointNumber === undefined) {
+      // No checkpoint associated with this block yet
+      return { number: CheckpointNumber.ZERO, hash: GENESIS_CHECKPOINT_HEADER_HASH.toString() };
+    }
+    const checkpoint = await this.getCheckpoint(checkpointNumber);
+    if (!checkpoint) {
+      throw new Error(`Checkpoint not found for checkpoint number ${checkpointNumber}`);
+    }
+    return { number: checkpointNumber, hash: checkpoint.checkpoint.hash().toString() };
+  }
+
+  private async handleBlocksAdded(event: L2BlockStreamEvent): Promise<void> {
+    if (event.type !== 'blocks-added') {
+      return;
+    }
+    await this.runInTransaction(async () => {
+      const blocks = event.blocks;
+      for (const block of blocks) {
+        await this.setBlockHash(block.number, await this.computeBlockHash(block));
+      }
+      await this.setTip('proposed', blocks.at(-1)!.number);
+    });
+  }
+
+  private async handleChainCheckpointed(event: L2BlockStreamEvent): Promise<void> {
+    if (event.type !== 'chain-checkpointed') {
+      return;
+    }
+    await this.runInTransaction(async () => {
+      await this.saveTag('checkpointed', event.block);
+      await this.saveCheckpoint(event.checkpoint);
+    });
+  }
+
+  private async handleChainPruned(event: L2BlockStreamEvent): Promise<void> {
+    if (event.type !== 'chain-pruned') {
+      return;
+    }
+    await this.runInTransaction(async () => {
+      await this.saveTag('proposed', event.block);
+      await this.saveTag('checkpointed', event.block);
+      const storeProven = await this.getBlockId('proven');
+      if (storeProven.number > event.block.number) {
+        await this.saveTag('proven', event.block);
+      }
+    });
+  }
+
+  private async handleChainProven(event: L2BlockStreamEvent): Promise<void> {
+    if (event.type !== 'chain-proven') {
+      return;
+    }
+    await this.runInTransaction(async () => {
+      await this.saveTag('proven', event.block);
+    });
+  }
+
+  private async handleChainFinalized(event: L2BlockStreamEvent): Promise<void> {
+    if (event.type !== 'chain-finalized') {
+      return;
+    }
+    await this.runInTransaction(async () => {
+      await this.saveTag('finalized', event.block);
+      const finalizedCheckpointNumber = await this.getCheckpointNumberForBlock(event.block.number);
+
+      await this.deleteBlockHashesBefore(event.block.number);
+      await this.deleteBlockToCheckpointBefore(event.block.number);
+
+      if (finalizedCheckpointNumber !== undefined) {
+        await this.deleteCheckpointsBefore(finalizedCheckpointNumber);
+      }
+    });
+  }
+
+  private async saveTag(name: L2BlockTag, block: L2BlockId): Promise<void> {
+    await this.setTip(name, block.number);
+    if (block.hash) {
+      await this.setBlockHash(block.number, block.hash);
+    }
+  }
+
+  private async saveCheckpoint(publishedCheckpoint: PublishedCheckpoint): Promise<void> {
+    const checkpoint = publishedCheckpoint.checkpoint;
+    const lastBlock = checkpoint.blocks.at(-1)!;
+    // Only store the mapping for the last block since tips only point to checkpoint boundaries
+    await Promise.all([
+      this.setCheckpointNumberForBlock(lastBlock.number, checkpoint.number),
+      this.saveCheckpointData(publishedCheckpoint),
+    ]);
+  }
+}

package/src/block/proposal/attestations_and_signers.ts

@@ -1,4 +1,4 @@
-import type { ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import { encodeAbiParameters, parseAbiParameters } from 'viem';

package/src/block/proposal/committee_attestation.ts

@@ -1,4 +1,4 @@
-import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';