@aztec/stdlib 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/src/block/l2_block_source.ts

@@ -4,27 +4,92 @@ import {
   CheckpointNumber,
   CheckpointNumberSchema,
   type EpochNumber,
+  EpochNumberSchema,
   type SlotNumber,
+  SlotNumberSchema,
 } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import { schemas } from '@aztec/foundation/schemas';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import type { Checkpoint } from '../checkpoint/checkpoint.js';
+import type { CheckpointData, ProposedCheckpointData, ProposedCheckpointInput } from '../checkpoint/checkpoint_data.js';
+import type { CheckpointInfo } from '../checkpoint/checkpoint_info.js';
 import type { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import type { L2ToL1MembershipWitness } from '../messaging/l2_to_l1_membership.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
-import type { BlockHeader } from '../tx/block_header.js';
 import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
-import type { TxReceipt } from '../tx/tx_receipt.js';
-import type { BlockHash } from './block_hash.js';
-import type { CheckpointedL2Block } from './checkpointed_l2_block.js';
+import type { BlockData } from './block_data.js';
+import { BlockHash } from './block_hash.js';
+import { BlockTagWithoutLatestSchema, type NormalizedBlockParameter } from './block_parameter.js';
 import type { L2Block } from './l2_block.js';
 import type { ValidateCheckpointNegativeResult, ValidateCheckpointResult } from './validate_block_result.js';
 
+/** Lookup a single block by block number, hash, archive root, or chain-tip tag. */
+export type BlockQuery = NormalizedBlockParameter;
+
+/**
+ * Query a range of blocks by start/limit or by epoch.
+ *
+ * The `epoch` variant requires `onlyCheckpointed: true` because epoch boundaries are only
+ * meaningful for the checkpointed chain — the proposed chain may include uncheckpointed
+ * blocks past the epoch boundary that callers should not receive.
+ */
+export type BlocksQuery =
+  | { from: BlockNumber; limit: number; onlyCheckpointed?: boolean }
+  | { epoch: EpochNumber; onlyCheckpointed: true };
+
+export const BlockQuerySchema: z.ZodType<BlockQuery, unknown> = z.union([
+  z.object({ number: BlockNumberSchema }).strict(),
+  z.object({ hash: BlockHash.schema }).strict(),
+  z.object({ archive: schemas.Fr }).strict(),
+  z.object({ tag: BlockTagWithoutLatestSchema }).strict(),
+]);
+
+export const BlocksQuerySchema: z.ZodType<BlocksQuery, unknown> = z.union([
+  z
+    .object({ from: BlockNumberSchema, limit: z.number().int().min(1), onlyCheckpointed: z.boolean().optional() })
+    .strict(),
+  z.object({ epoch: EpochNumberSchema, onlyCheckpointed: z.literal(true) }).strict(),
+]);
+
+/** Lookup a single confirmed checkpoint by checkpoint number, slot, or chain-tip tag. */
+export type CheckpointQuery =
+  | { number: CheckpointNumber }
+  | { slot: SlotNumber }
+  | { tag: 'checkpointed' | 'proven' | 'finalized' };
+
+/** Query a range of confirmed checkpoints by start/limit or by epoch. */
+export type CheckpointsQuery = { from: CheckpointNumber; limit: number } | { epoch: EpochNumber };
+
+/**
+ * Lookup a proposed (archiver-internal, not-yet-L1-confirmed) checkpoint.
+ * Distinct from CheckpointQuery because proposed checkpoints have a different shape
+ * (no l1, no attestations, but carries totalManaUsed) and live in their own LMDB map.
+ */
+export type ProposedCheckpointQuery = { number: CheckpointNumber } | { slot: SlotNumber } | { tag: 'proposed' };
+
+export const CheckpointQuerySchema: z.ZodType<CheckpointQuery, unknown> = z.union([
+  z.object({ number: CheckpointNumberSchema }).strict(),
+  z.object({ slot: SlotNumberSchema }).strict(),
+  z.object({ tag: z.union([z.literal('checkpointed'), z.literal('proven'), z.literal('finalized')]) }).strict(),
+]);
+
+export const CheckpointsQuerySchema: z.ZodType<CheckpointsQuery, unknown> = z.union([
+  z.object({ from: CheckpointNumberSchema, limit: z.number().int().min(1) }).strict(),
+  z.object({ epoch: EpochNumberSchema }).strict(),
+]);
+
+export const ProposedCheckpointQuerySchema: z.ZodType<ProposedCheckpointQuery, unknown> = z.union([
+  z.object({ number: CheckpointNumberSchema }).strict(),
+  z.object({ slot: SlotNumberSchema }).strict(),
+  z.object({ tag: z.literal('proposed') }).strict(),
+]);
+
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
  */
@@ -48,90 +113,46 @@ export interface L2BlockSource {
   getBlockNumber(): Promise<BlockNumber>;
 
   /**
-   * Gets the number of the latest L2 block proven seen by the block source implementation.
-   * @returns The number of the latest L2 block proven seen by the block source implementation.
-   */
-  getProvenBlockNumber(): Promise<BlockNumber>;
-
-  /**
-   * Gets the number of the latest L2 block checkpointed seen by the block source implementation.
-   * @returns The number of the latest L2 block checkpointed seen by the block source implementation.
-   */
-  getCheckpointedL2BlockNumber(): Promise<BlockNumber>;
-
-  /**
-   * Computes the finalized block number based on the proven block number.
-   * A block is considered finalized when it's 2 epochs behind the proven block.
-   * TODO(#13569): Compute proper finalized block number based on L1 finalized block.
-   * @returns The finalized block number.
-   */
-  getFinalizedL2BlockNumber(): Promise<BlockNumber>;
-
-  /**
-   * Gets an l2 block header.
-   * @param number - The block number to return or 'latest' for the most recent one.
-   * @returns The requested L2 block header.
-   */
-  getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | undefined>;
-
-  /**
-   * Gets a checkpointed L2 block by block number.
-   * Returns undefined if the block doesn't exist or hasn't been checkpointed yet.
-   * @param number - The block number to retrieve.
-   * @returns The requested checkpointed L2 block (or undefined if not found or not checkpointed).
-   */
-  getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
-
-  getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]>;
-
-  /**
-   * Retrieves a collection of checkpoints.
-   * @param checkpointNumber The first checkpoint to be retrieved.
-   * @param limit The number of checkpoints to be retrieved.
-   * @returns The collection of complete checkpoints.
+   * Resolves a {@link BlockQuery} to its concrete L2 block number.
+   * @param query - Lookup by block number, hash, archive root, or chain-tip tag.
+   * @returns The block number, or undefined if no block matches the query.
    */
-  getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+  getBlockNumber(query: BlockQuery): Promise<BlockNumber | undefined>;
+  getBlockNumber(query?: BlockQuery): Promise<BlockNumber | undefined>;
 
   /**
-   * Gets the checkpoints for a given epoch
-   * @param epochNumber - Epoch for which we want checkpoint data
+   * Gets the number of the latest L2 checkpoint processed by the block source implementation.
+   * @returns The number of the latest L2 checkpoint processed by the block source implementation.
    */
-  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
+  getCheckpointNumber(): Promise<CheckpointNumber>;
 
   /**
-   * Gets a block header by its hash.
-   * @param blockHash - The block hash to retrieve.
-   * @returns The requested block header (or undefined if not found).
+   * Gets a single confirmed checkpoint matching the given query.
+   * Heavy shape: includes nested full `L2Block`s with transaction bodies.
+   * @param query - Lookup by checkpoint number, slot, or chain-tip tag.
    */
-  getBlockHeaderByHash(blockHash: BlockHash): Promise<BlockHeader | undefined>;
+  getCheckpoint(query: CheckpointQuery): Promise<PublishedCheckpoint | undefined>;
 
   /**
-   * Gets a block header by its archive root.
-   * @param archive - The archive root to retrieve.
-   * @returns The requested block header (or undefined if not found).
+   * Gets a collection of confirmed checkpoints matching the given query.
+   * Heavy shape: includes nested full `L2Block`s with transaction bodies.
+   * @param query - Range by start/limit or by epoch.
    */
-  getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
+  getCheckpoints(query: CheckpointsQuery): Promise<PublishedCheckpoint[]>;
 
   /**
-   * Gets an L2 block by block number.
-   * @param number - The block number to return.
-   * @returns The requested L2 block (or undefined if not found).
+   * Gets lightweight checkpoint metadata for a single checkpoint.
+   * Cheap passthrough for metadata-only queries (no block body reads).
+   * @param query - Lookup by checkpoint number, slot, or chain-tip tag.
    */
-  getL2Block(number: BlockNumber): Promise<L2Block | undefined>;
+  getCheckpointData(query: CheckpointQuery): Promise<CheckpointData | undefined>;
 
   /**
-   * Gets an L2 block by its hash.
-   * @param blockHash - The block hash to retrieve.
-   * @returns The requested L2 block (or undefined if not found).
+   * Gets a collection of lightweight checkpoint metadata entries matching the given query.
+   * Cheap passthrough for metadata-only queries (no block body reads).
+   * @param query - Range by start/limit or by epoch.
    */
-  getL2BlockByHash(blockHash: BlockHash): Promise<L2Block | undefined>;
-
-  /**
-   * Gets an L2 block by its archive root.
-   * @param archive - The archive root to retrieve.
-   * @returns The requested L2 block (or undefined if not found).
-   */
-  getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined>;
+  getCheckpointsData(query: CheckpointsQuery): Promise<CheckpointData[]>;
 
   /**
    * Gets a tx effect.
@@ -141,28 +162,35 @@ export interface L2BlockSource {
   getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined>;
 
   /**
-   * Gets a receipt of a settled tx.
-   * @param txHash - The hash of a tx we try to get the receipt for.
-   * @returns The requested tx receipt (or undefined if not found).
-   */
-  getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
-
-  /**
-   * Returns the current L2 slot number based on the currently synced L1 timestamp.
+   * Returns the L2-to-L1 membership witness for `message` emitted by tx `txHash`, built against the
+   * smallest partial-proof root on the Outbox that covers the tx's checkpoint.
+   *
+   * The Outbox roots are read lazily, pinned to the node's synced L1 block, so the witness reflects
+   * the node's synced view. Returns `undefined` if the tx isn't yet in a block/epoch or no covering
+   * root has landed on L1 as of the synced block.
+   *
+   * Caveat: cached roots that are sealed and L1-finalized are not re-validated. A reorg deeper than
+   * L1 finality could leave the node serving a witness against a no-longer-canonical root.
    */
-  getL2SlotNumber(): Promise<SlotNumber | undefined>;
+  getL2ToL1MembershipWitness(
+    txHash: TxHash,
+    message: Fr,
+    messageIndexInTx?: number,
+  ): Promise<L2ToL1MembershipWitness | undefined>;
 
   /**
-   * Returns the current L2 epoch number based on the currently synced L1 timestamp.
+   * Returns the last L2 slot number for which we have all L1 data needed to build the next checkpoint.
+   * Determined by the max of two signals: L1 block sync progress and latest synced checkpoint slot.
+   * The checkpoint signal handles missed L1 blocks, since a published checkpoint seals the message tree
+   * for the next checkpoint via the inbox LAG mechanism.
    */
-  getL2EpochNumber(): Promise<EpochNumber | undefined>;
+  getSyncedL2SlotNumber(): Promise<SlotNumber | undefined>;
 
   /**
-   * Returns all checkpointed block headers for a given epoch.
-   * @dev Use this method only with recent epochs, since it walks the block list backwards.
-   * @param epochNumber - The epoch number to return headers for.
+   * Returns the last L2 epoch number that has been fully synchronized from L1.
+   * An epoch is fully synced when all its L2 slots have been fully synced.
    */
-  getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
+  getSyncedL2EpochNumber(): Promise<EpochNumber | undefined>;
 
   /**
    * Returns whether the given epoch is completed on L1, based on the current L1 and L2 block numbers.
@@ -180,9 +208,22 @@ export interface L2BlockSource {
    */
   getL1Constants(): Promise<L1RollupConstants>;
 
+  /**
+   * Returns true iff `canPruneAtTime` would be true at the latest L1 timestamp inside
+   * the L2 slot's window. Computed entirely from local archiver state (no L1 RPC).
+   * @param slot - The L2 slot to check.
+   */
+  isPruneDueAtSlot(slot: SlotNumber): Promise<boolean>;
+
   /** Returns values for the genesis block */
   getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }>;
 
+  /**
+   * Returns the precomputed hash of the genesis block header. Synchronous because the hash
+   * is derived from the initial block header at construction time and cached by implementers.
+   */
+  getGenesisBlockHash(): BlockHash;
+
   /** Latest synced L1 timestamp. */
   getL1Timestamp(): Promise<bigint | undefined>;
 
@@ -198,53 +239,47 @@ export interface L2BlockSource {
    */
   getPendingChainValidationStatus(): Promise<ValidateCheckpointResult>;
 
-  /** Force a sync. */
-  syncImmediate(): Promise<void>;
-
-  /* Legacy APIS */
-
   /**
-   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
+   * Looks up a proposed (archiver-internal, not-yet-L1-confirmed) checkpoint.
+   * Returns the latest proposed entry when called with no args or `{ tag: 'proposed' }`.
+   * With `{ number }` or `{ slot }`, returns the matching entry or undefined.
+   * Never falls back to confirmed checkpoints.
    */
-  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
+  getProposedCheckpointData(query?: ProposedCheckpointQuery): Promise<ProposedCheckpointData | undefined>;
+
+  /** Force a sync. */
+  syncImmediate(): Promise<void>;
 
   /**
-   * Returns all checkpointed blocks for a given epoch.
-   * @dev Use this method only with recent epochs, since it walks the block list backwards.
-   * @param epochNumber - The epoch number to return blocks for.
+   * Gets an L2 block matching the given query.
+   * @param query - Lookup by block number, hash, or archive root.
    */
-  getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]>;
+  getBlock(query: BlockQuery): Promise<L2Block | undefined>;
 
   /**
-   * Returns all blocks for a given slot.
-   * @dev Use this method only with recent slots, since it walks the block list backwards.
-   * @param slotNumber - The slot number to return blocks for.
+   * Gets a collection of L2 blocks matching the given query.
+   * @param query - Range by start/limit or by epoch; optionally restricted to checkpointed blocks.
    */
-  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]>;
+  getBlocks(query: BlocksQuery): Promise<L2Block[]>;
 
   /**
-   * Gets a checkpointed block by its block hash.
-   * @param blockHash - The block hash to retrieve.
-   * @returns The requested block (or undefined if not found).
+   * Gets block metadata (without tx data) matching the given query.
+   * @param query - Lookup by block number, hash, or archive root.
    */
-  getCheckpointedBlockByHash(blockHash: BlockHash): Promise<CheckpointedL2Block | undefined>;
+  getBlockData(query: BlockQuery): Promise<BlockData | undefined>;
 
   /**
-   * Gets a checkpointed block by its archive root.
-   * @param archive - The archive root to retrieve.
-   * @returns The requested block (or undefined if not found).
+   * Gets a collection of block metadata entries matching the given query.
+   * @param query - Range by start/limit or by epoch; optionally restricted to checkpointed blocks.
    */
-  getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined>;
+  getBlocksData(query: BlocksQuery): Promise<BlockData[]>;
 
   /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param from - Number of the first block to return (inclusive).
-   * @param limit - The maximum number of blocks to return.
-   * @returns The requested L2 blocks.
+   * Returns all blocks for a given slot.
+   * @dev Use this method only with recent slots, since it walks the block list backwards.
+   * @param slotNumber - The slot number to return blocks for.
    */
-  getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]>;
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]>;
 }
 
 /**
@@ -259,6 +294,19 @@ export interface L2BlockSink {
   addBlock(block: L2Block): Promise<void>;
 }
 
+/**
+ * Interface for classes that can receive and store proposed (not-yet-L1-confirmed) checkpoints.
+ */
+export interface ProposedCheckpointSink {
+  /**
+   * Adds a proposed checkpoint to the store. The archive and checkpointOutHash are computed
+   * internally from the already-stored blocks, so every block in the checkpoint must be added
+   * (via {@link L2BlockSink.addBlock}) before calling this.
+   * @param checkpoint - The proposed checkpoint metadata.
+   */
+  addProposedCheckpoint(checkpoint: ProposedCheckpointInput): Promise<void>;
+}
+
 /**
  * L2BlockSource that emits events upon pending / proven chain changes.
  * see L2BlockSourceEvents for the events emitted.
@@ -269,24 +317,36 @@ export type ArchiverEmitter = TypedEventEmitter<{
   [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockProvenEvent) => void;
   [L2BlockSourceEvents.InvalidAttestationsCheckpointDetected]: (args: InvalidCheckpointDetectedEvent) => void;
   [L2BlockSourceEvents.L2BlocksCheckpointed]: (args: L2CheckpointEvent) => void;
+  [L2BlockSourceEvents.CheckpointEquivocationDetected]: (args: CheckpointEquivocationDetectedEvent) => void;
+  [L2BlockSourceEvents.DescendentOfInvalidAttestationsCheckpointDetected]: (
+    args: DescendentOfInvalidAttestationsCheckpointEvent,
+  ) => void;
 }>;
 export interface L2BlockSourceEventEmitter extends L2BlockSource {
   events: ArchiverEmitter;
 }
 
 /**
- * Identifier for L2 block tags.
+ * Identifier for L2 block tags. Internal counterpart to {@link BlockTag} that exposes
+ * the additional `proposedCheckpoint` value (used for the optimistic chain tip on the
+ * archiver side) and omits `latest` (which is an alias for `proposed` accepted only at
+ * the public RPC surface).
+ *
  * - proposed: Latest block proposed on L2.
- * - checkpointed: Checkpointed block on L1.
- * - proven: Proven block on L1.
- * - finalized: Proven block on a finalized L1 block (not implemented, set to proven for now).
+ * - proposedCheckpoint: Latest block in the most recent proposed checkpoint (archiver-internal).
+ * - checkpointed: Latest block whose enclosing checkpoint has been published on L1.
+ * - proven: Latest block whose enclosing checkpoint has been proven on L1.
+ * - finalized: Latest block whose proving L1 transaction has reached L1 finality.
+ *
+ * TODO(palla): Remove `proposedCheckpoint` and unify with `proposed`.
  */
-export type L2BlockTag = 'proposed' | 'checkpointed' | 'proven' | 'finalized';
+export type L2BlockTag = 'proposed' | 'proposedCheckpoint' | 'checkpointed' | 'proven' | 'finalized';
 
 /** Tips of the L2 chain. */
 export type L2Tips = {
   proposed: L2BlockId;
   checkpointed: L2TipId;
+  proposedCheckpoint: L2TipId;
   proven: L2TipId;
   finalized: L2TipId;
 };
@@ -331,6 +391,7 @@ const L2TipIdSchema = z.object({
 export const L2TipsSchema = z.object({
   proposed: L2BlockIdSchema,
   checkpointed: L2TipIdSchema,
+  proposedCheckpoint: L2TipIdSchema,
   proven: L2TipIdSchema,
   finalized: L2TipIdSchema,
 });
@@ -341,6 +402,8 @@ export enum L2BlockSourceEvents {
   L2BlockProven = 'l2BlockProven',
   L2BlocksCheckpointed = 'l2BlocksCheckpointed',
   InvalidAttestationsCheckpointDetected = 'invalidCheckpointDetected',
+  CheckpointEquivocationDetected = 'checkpointEquivocationDetected',
+  DescendentOfInvalidAttestationsCheckpointDetected = 'descendentOfInvalidAttestationsCheckpointDetected',
 }
 
 export type L2BlockProvenEvent = {
@@ -371,3 +434,31 @@ export type InvalidCheckpointDetectedEvent = {
   type: 'invalidCheckpointDetected';
   validationResult: ValidateCheckpointNegativeResult;
 };
+
+/**
+ * Emitted when a local proposed checkpoint is found to disagree with the L1-confirmed
+ * checkpoint at the same slot. The slot proposer signed both — equivocation.
+ */
+export type CheckpointEquivocationDetectedEvent = {
+  type: 'checkpointEquivocationDetected';
+  slotNumber: SlotNumber;
+  checkpointNumber: CheckpointNumber;
+  l1ArchiveRoot: Fr;
+  proposedArchiveRoot: Fr;
+};
+
+/**
+ * Emitted when the archiver observes a checkpoint that builds on a previously-rejected
+ * ancestor (typically one with insufficient/invalid attestations). The descendant itself may
+ * have valid attestations, but it cannot be ingested because the chain it extends was
+ * skipped. The slasher uses this to slash the proposer of the descendant.
+ */
+export type DescendentOfInvalidAttestationsCheckpointEvent = {
+  type: 'descendentOfInvalidAttestationsCheckpointDetected';
+  /** The descendant checkpoint being rejected. */
+  checkpoint: CheckpointInfo;
+  /** Archive root of the rejected ancestor this descendant builds on. */
+  ancestorArchiveRoot: Fr;
+  /** Checkpoint number of the rejected ancestor. */
+  ancestorCheckpointNumber: CheckpointNumber;
+};

package/src/block/l2_block_stream/interfaces.ts

@@ -2,10 +2,14 @@ import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.
 import type { L2Block } from '../l2_block.js';
 import type { CheckpointId, L2BlockId, L2Tips } from '../l2_block_source.js';
 
+/** Provides the current chain tips. Implemented by world-state, l2-tips-store, and AztecNode. */
+export interface L2TipsProvider {
+  getL2Tips(): Promise<L2Tips>;
+}
+
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
-export interface L2BlockStreamLocalDataProvider {
+export interface L2BlockStreamLocalDataProvider extends L2TipsProvider {
   getL2BlockHash(number: number): Promise<string | undefined>;
-  getL2Tips(): Promise<L2Tips>;
 }
 
 /** Interface to a handler of events emitted. */

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -17,10 +17,7 @@ export class L2BlockStream {
   private hasStarted = false;
 
   constructor(
-    private l2BlockSource: Pick<
-      L2BlockSource,
-      'getBlocks' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpoints' | 'getCheckpointedBlocks'
-    >,
+    private l2BlockSource: Pick<L2BlockSource, 'getBlocks' | 'getBlockData' | 'getL2Tips' | 'getCheckpoints'>,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
@@ -77,6 +74,22 @@ export class L2BlockStream {
       let latestBlockNumber = localTips.proposed.number;
       const sourceCache = new BlockHashCache([sourceTips.proposed]);
       while (!(await this.areBlockHashesEqualAt(latestBlockNumber, { sourceCache }))) {
+        if (latestBlockNumber === 0) {
+          // We walked all the way back to genesis and the hashes still differ. This means the
+          // local store and the source disagree on the genesis block itself — typically because
+          // they were configured with different `genesisTimestamp`/prefilled state. Continuing
+          // would underflow into negative block numbers and surface as "block hash not found
+          // for -1" further down. Fail loudly with a meaningful error instead.
+          this.log.error(`Genesis block hash mismatch between local store and source`, {
+            localBlockHash: await this.localData.getL2BlockHash(BlockNumber.ZERO),
+            sourceBlockHash: sourceCache.get(0) ?? (await this.getBlockHashFromSource(BlockNumber.ZERO)),
+          });
+          throw new Error(
+            'Genesis block hash mismatch between local store and source: refusing to walk past block 0. ' +
+              'This usually indicates the two sides were configured with different genesis values ' +
+              '(e.g. genesisTimestamp or prefilled public data).',
+          );
+        }
         latestBlockNumber--;
       }
 
@@ -97,8 +110,9 @@ export class L2BlockStream {
       }
 
       // If we are just starting, use the starting block number from the options.
-      if (latestBlockNumber === 0 && this.opts.startingBlock !== undefined) {
-        latestBlockNumber = BlockNumber(Math.max(this.opts.startingBlock - 1, 0));
+      const startingBlock = this.opts.startingBlock !== undefined ? BlockNumber(this.opts.startingBlock) : undefined;
+      if (latestBlockNumber === 0 && startingBlock !== undefined) {
+        latestBlockNumber = BlockNumber(Math.max(startingBlock - 1, 0));
       }
 
       // Only log this entry once (for sanity)
@@ -109,6 +123,24 @@ export class L2BlockStream {
 
       let nextBlockNumber = latestBlockNumber + 1;
       let nextCheckpointToEmit = CheckpointNumber(localTips.checkpointed.checkpoint.number + 1);
+
+      // When startingBlock is set, also skip ahead for checkpoints.
+      if (
+        startingBlock !== undefined &&
+        startingBlock >= 1 &&
+        nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number
+      ) {
+        if (startingBlock > sourceTips.checkpointed.block.number) {
+          // startingBlock is past all checkpointed blocks; skip Loop 1 entirely.
+          nextCheckpointToEmit = CheckpointNumber(sourceTips.checkpointed.checkpoint.number + 1);
+        } else {
+          const startingBlockData = await this.l2BlockSource.getBlockData({ number: startingBlock });
+          if (startingBlockData) {
+            nextCheckpointToEmit = CheckpointNumber(Math.max(nextCheckpointToEmit, startingBlockData.checkpointNumber));
+          }
+        }
+      }
+
       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
@@ -128,7 +160,7 @@ export class L2BlockStream {
       if (!this.opts.ignoreCheckpoints) {
         let loop1Iterations = 0;
         while (nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number) {
-          const checkpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointToEmit, 1);
+          const checkpoints = await this.l2BlockSource.getCheckpoints({ from: nextCheckpointToEmit, limit: 1 });
           if (checkpoints.length === 0) {
             break;
           }
@@ -163,9 +195,9 @@ export class L2BlockStream {
 
       // 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;
+        const blockData = await this.l2BlockSource.getBlockData({ number: BlockNumber(nextBlockNumber) });
+        if (blockData) {
+          nextCheckpointNumber = blockData.checkpointNumber;
         }
       }
 
@@ -173,7 +205,10 @@ export class L2BlockStream {
         // 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);
+          prefetchedCheckpoints = await this.l2BlockSource.getCheckpoints({
+            from: nextCheckpointNumber,
+            limit: prefetchLimit,
+          });
           prefetchIdx = 0;
           if (prefetchedCheckpoints.length === 0) {
             break;
@@ -213,7 +248,7 @@ export class L2BlockStream {
       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));
+        const blocks = await this.l2BlockSource.getBlocks({ from: BlockNumber(nextBlockNumber), limit });
         if (blocks.length === 0) {
           break;
         }
@@ -245,9 +280,6 @@ export class L2BlockStream {
    * @param args - A cache of data already requested from source, to avoid re-requesting it.
    */
   private async areBlockHashesEqualAt(blockNumber: BlockNumber, args: { sourceCache: BlockHashCache }) {
-    if (blockNumber === 0) {
-      return true;
-    }
     const localBlockHash = await this.localData.getL2BlockHash(blockNumber);
     if (!localBlockHash && this.opts.skipFinalized) {
       // Failing to find a block hash when skipping finalized blocks can be highly problematic as we'd potentially need
@@ -270,8 +302,8 @@ export class L2BlockStream {
 
   private getBlockHashFromSource(blockNumber: BlockNumber) {
     return this.l2BlockSource
-      .getBlockHeader(blockNumber)
-      .then(h => h?.hash())
+      .getBlockData({ number: blockNumber })
+      .then(d => d?.header.hash())
       .then(hash => hash?.toString());
   }
 

package/src/block/l2_block_stream/l2_tips_memory_store.ts

@@ -1,6 +1,7 @@
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 
 import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import type { BlockHash } from '../block_hash.js';
 import type { L2BlockTag } from '../l2_block_source.js';
 import { L2TipsStoreBase } from './l2_tips_store_base.js';
 
@@ -9,6 +10,10 @@ import { L2TipsStoreBase } from './l2_tips_store_base.js';
  * @dev Tests in kv-store/src/stores/l2_tips_memory_store.test.ts
  */
 export class L2TipsMemoryStore extends L2TipsStoreBase {
+  constructor(initialBlockHash: BlockHash) {
+    super(initialBlockHash);
+  }
+
   private readonly tips = new Map<L2BlockTag, BlockNumber>();
   private readonly blockHashes = new Map<number, string>();
   private readonly blockToCheckpoint = new Map<number, CheckpointNumber>();