@aztec/stdlib 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

package/src/block/attestation_info.ts

@@ -60,9 +60,14 @@ export function getAttestationInfoFromPayload(
       return { address: attestation.address, status: 'provided-as-address' as const };
     }
 
-    // Try to recover address from signature
+    // Try to recover address from signature. Recover with default opts (no allowYParityAsV): a slot
+    // whose recovery byte is in yParity form (v ∈ {0, 1}) is judged invalid here, matching L1 proving
+    // (ValidatorSelectionLib.verifyAttestations → ECDSA.recover only accepts v ∈ {27, 28}). A malicious
+    // proposer that lands such a slot cannot have it silently treated as valid off-chain; it is routed to
+    // invalid-attestation and invalidated. The gossip receipt path (recoverCoordinationSigner) stays
+    // lenient with allowYParityAsV; A-1351 normalizes on pool ingress and before the L1 bundle.
     try {
-      const recoveredAddress = recoverAddress(hashedPayload, attestation.signature, { allowYParityAsV: true });
+      const recoveredAddress = recoverAddress(hashedPayload, attestation.signature);
       return { address: recoveredAddress, status: 'recovered-from-signature' as const };
     } catch {
       // Signature present but recovery failed

package/src/block/l2_block_source.ts

@@ -63,8 +63,18 @@ export type CheckpointQuery =
   | { 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 };
+/**
+ * Query a range of confirmed checkpoints by start/limit, by slot anchor, or by epoch.
+ *
+ * The `fromSlot` variant walks the slot index: it returns up to `limit` checkpoints anchored at
+ * `fromSlot`, ordered nearest-first. With `reverse` it takes the checkpoints at or before the slot
+ * (descending); otherwise the checkpoints at or after it (ascending). Use `limit: 1, reverse: true`
+ * to find the latest checkpoint at or before a slot in a single range scan.
+ */
+export type CheckpointsQuery =
+  | { from: CheckpointNumber; limit: number }
+  | { fromSlot: SlotNumber; limit: number; reverse?: boolean }
+  | { epoch: EpochNumber };
 
 /**
  * Lookup a proposed (archiver-internal, not-yet-L1-confirmed) checkpoint.
@@ -81,6 +91,7 @@ export const CheckpointQuerySchema: z.ZodType<CheckpointQuery, unknown> = z.unio
 
 export const CheckpointsQuerySchema: z.ZodType<CheckpointsQuery, unknown> = z.union([
   z.object({ from: CheckpointNumberSchema, limit: z.number().int().min(1) }).strict(),
+  z.object({ fromSlot: SlotNumberSchema, limit: z.number().int().min(1), reverse: z.boolean().optional() }).strict(),
   z.object({ epoch: EpochNumberSchema }).strict(),
 ]);
 
@@ -241,7 +252,10 @@ export interface L2BlockSource {
 
   /**
    * Looks up a proposed (archiver-internal, not-yet-L1-confirmed) checkpoint.
-   * Returns the latest proposed entry when called with no args or `{ tag: 'proposed' }`.
+   * Returns the latest proposed entry when called with no args or `{ tag: 'proposed' }`; since a
+   * proposed entry can only be stored with a checkpoint number beyond the confirmed frontier (and is
+   * deleted on confirmation), the latest entry is always the leading one. Callers derive the proposed
+   * tip from the payload (checkpoint number, and last block `startBlock + blockCount - 1`).
    * With `{ number }` or `{ slot }`, returns the matching entry or undefined.
    * Never falls back to confirmed checkpoints.
    */
@@ -321,36 +335,37 @@ export type ArchiverEmitter = TypedEventEmitter<{
   [L2BlockSourceEvents.DescendentOfInvalidAttestationsCheckpointDetected]: (
     args: DescendentOfInvalidAttestationsCheckpointEvent,
   ) => void;
+  [L2BlockSourceEvents.L2BlockSourceUpdated]: (args: L2BlockSourceUpdatedEvent) => void;
 }>;
 export interface L2BlockSourceEventEmitter extends L2BlockSource {
   events: ArchiverEmitter;
 }
 
 /**
- * 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).
+ * Identifier for L2 block tags. Internal counterpart to {@link BlockTag} that omits `latest`
+ * (which is an alias for `proposed` accepted only at the public RPC surface).
  *
  * - proposed: Latest block proposed on L2.
- * - 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' | 'proposedCheckpoint' | 'checkpointed' | 'proven' | 'finalized';
+export type L2BlockTag = 'proposed' | 'checkpointed' | 'proven' | 'finalized';
 
 /** Tips of the L2 chain. */
 export type L2Tips = {
   proposed: L2BlockId;
   checkpointed: L2TipId;
-  proposedCheckpoint: L2TipId;
   proven: L2TipId;
   finalized: L2TipId;
 };
 
+/**
+ * Tips of the L2 chain as tracked by a local provider (world-state, l2-tips-store). Identical to
+ * {@link L2Tips}; the alias is retained for call sites that document a local-only provenance.
+ */
+export type LocalL2Tips = L2Tips;
+
 export const GENESIS_CHECKPOINT_HEADER_HASH = CheckpointHeader.empty().hash();
 
 /** Identifies a block by number and hash. */
@@ -373,6 +388,28 @@ export function makeL2CheckpointId(number: CheckpointNumber, hash: string): Chec
   return { number, hash };
 }
 
+function l2BlockIdEquals(a: L2BlockId, b: L2BlockId): boolean {
+  return a.number === b.number && a.hash === b.hash;
+}
+
+function l2TipIdEquals(a: L2TipId, b: L2TipId): boolean {
+  return (
+    l2BlockIdEquals(a.block, b.block) &&
+    a.checkpoint.number === b.checkpoint.number &&
+    a.checkpoint.hash === b.checkpoint.hash
+  );
+}
+
+/** Returns whether two {@link L2Tips} snapshots agree on every tier (proposed, checkpointed, proven, finalized). */
+export function l2TipsEqual(a: L2Tips, b: L2Tips): boolean {
+  return (
+    l2BlockIdEquals(a.proposed, b.proposed) &&
+    l2TipIdEquals(a.checkpointed, b.checkpointed) &&
+    l2TipIdEquals(a.proven, b.proven) &&
+    l2TipIdEquals(a.finalized, b.finalized)
+  );
+}
+
 const L2BlockIdSchema = z.object({
   number: BlockNumberSchema,
   hash: z.string(),
@@ -391,7 +428,6 @@ const L2TipIdSchema = z.object({
 export const L2TipsSchema = z.object({
   proposed: L2BlockIdSchema,
   checkpointed: L2TipIdSchema,
-  proposedCheckpoint: L2TipIdSchema,
   proven: L2TipIdSchema,
   finalized: L2TipIdSchema,
 });
@@ -404,8 +440,26 @@ export enum L2BlockSourceEvents {
   InvalidAttestationsCheckpointDetected = 'invalidCheckpointDetected',
   CheckpointEquivocationDetected = 'checkpointEquivocationDetected',
   DescendentOfInvalidAttestationsCheckpointDetected = 'descendentOfInvalidAttestationsCheckpointDetected',
+  L2BlockSourceUpdated = 'l2BlockSourceUpdated',
 }
 
+/**
+ * Aggregate event emitted once per committed archiver sync pass that mutated local state. Carries the chain tips
+ * before and after the pass, and the blocks added during it. Consumers compare `fromTips` and `toTips` to learn what
+ * moved; there is no separate `changed` section.
+ *
+ * This is an optimization signal that lets a block stream reconcile immediately on an archiver update rather than
+ * waiting for its next poll. Polling remains the correctness fallback, so a missed event only affects latency.
+ * `blocksAdded` are hydrated blocks already in hand from the sync pass, so a triggered sync that is caught up to
+ * `fromTips` can reuse them (and `toTips`) instead of re-reading the store.
+ */
+export type L2BlockSourceUpdatedEvent = {
+  type: 'l2BlockSourceUpdated';
+  fromTips: L2Tips;
+  toTips: L2Tips;
+  blocksAdded: readonly L2Block[];
+};
+
 export type L2BlockProvenEvent = {
   type: 'l2BlockProven';
   blockNumber: BlockNumber;

package/src/block/l2_block_stream/event_driven_l2_block_stream.ts

@@ -0,0 +1,207 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+
+import type { BlockData } from '../block_data.js';
+import type { L2Block } from '../l2_block.js';
+import {
+  type ArchiverEmitter,
+  type BlockQuery,
+  type BlocksQuery,
+  type L2BlockSource,
+  type L2BlockSourceEventEmitter,
+  L2BlockSourceEvents,
+  type L2BlockSourceUpdatedEvent,
+  type L2Tips,
+} from '../l2_block_source.js';
+import { type L2BlockStreamEventHandler, type L2BlockStreamLocalDataProvider, localTipsMatch } from './interfaces.js';
+import { L2BlockStream, type L2BlockStreamOptions, type L2BlockStreamSource } from './l2_block_stream.js';
+
+/** Derives the metadata-only {@link BlockData} view of a hydrated {@link L2Block}. */
+async function l2BlockToBlockData(block: L2Block): Promise<BlockData> {
+  return {
+    header: block.header,
+    archive: block.archive,
+    blockHash: await block.hash(),
+    checkpointNumber: block.checkpointNumber,
+    indexWithinCheckpoint: block.indexWithinCheckpoint,
+  };
+}
+
+/** Returns the event emitter of a source that exposes one, or undefined for plain (e.g. RPC-backed) sources. */
+function getEmitter(source: L2BlockSource | L2BlockSourceEventEmitter): ArchiverEmitter | undefined {
+  return 'events' in source ? source.events : undefined;
+}
+
+/** Fast-path context for a single sync pass: blocks to serve by number, plus the tips to report as the source's. */
+type ActiveUpdate = { byNumber: Map<number, L2Block>; toTips: L2Tips };
+
+/**
+ * Wraps a block source so a single sync pass can be served from blocks delivered by an aggregate update event,
+ * avoiding round-trips to archiver storage. The fast path is only armed (via {@link activate}) for a pass that is
+ * confirmed caught up to the event's pre-pass tips: in that case the event's `blocksAdded` contiguously cover the
+ * pass's download range and `toTips` is the exact post-pass tip, so `getL2Tips` can report it without querying the
+ * source. When the fast path is not armed, every read delegates to the source, so a stale or partial cache never
+ * changes the sync outcome.
+ */
+class HotBlockSourceAdapter implements L2BlockStreamSource {
+  /** Set for the duration of one fast-path pass; undefined when reads must delegate to the source. */
+  private active: ActiveUpdate | undefined;
+
+  constructor(
+    private readonly source: L2BlockStreamSource,
+    private readonly log: Logger,
+  ) {}
+
+  /** Arms the fast path for the current pass: serve these blocks and report `toTips` as the source tips. */
+  public activate(blocks: readonly L2Block[], toTips: L2Tips): void {
+    const byNumber = new Map<number, L2Block>();
+    for (const block of blocks) {
+      byNumber.set(block.number, block);
+    }
+    this.active = { byNumber, toTips };
+    this.log.trace(`Armed hot-block fast path`, { blocks: byNumber.size, toTips });
+  }
+
+  /** Disarms the fast path so subsequent reads delegate to the source again. */
+  public deactivate(): void {
+    this.active = undefined;
+  }
+
+  public getL2Tips(): Promise<L2Tips> {
+    return this.active ? Promise.resolve(this.active.toTips) : this.source.getL2Tips();
+  }
+
+  public getBlocks(query: BlocksQuery): Promise<L2Block[]> {
+    const served = this.active ? this.tryServeBlocksFromCache(query) : undefined;
+    return served ? Promise.resolve(served) : this.source.getBlocks(query);
+  }
+
+  public getBlockData(query: BlockQuery): Promise<BlockData | undefined> {
+    if (this.active && 'number' in query) {
+      const block = this.active.byNumber.get(query.number);
+      if (block) {
+        return l2BlockToBlockData(block);
+      }
+    }
+    return this.source.getBlockData(query);
+  }
+
+  /** Serves a block range from the cache only when it is fully covered by contiguous cached blocks. */
+  private tryServeBlocksFromCache(query: BlocksQuery): L2Block[] | undefined {
+    // Only the by-range form is cacheable, and only for the full (not checkpointed-only) chain: the cache may hold
+    // uncheckpointed blocks that an onlyCheckpointed query must not receive.
+    if (!this.active || !('from' in query) || query.onlyCheckpointed) {
+      return undefined;
+    }
+    const from = query.from;
+    const to = from + query.limit - 1;
+    const blocks: L2Block[] = [];
+    for (let n = from; n <= to; n++) {
+      const block = this.active.byNumber.get(n);
+      if (!block) {
+        // A gap inside the requested range: bail out and let the source serve the whole range.
+        return undefined;
+      }
+      blocks.push(block);
+    }
+    return blocks;
+  }
+}
+
+/**
+ * Event-driven wrapper around {@link L2BlockStream}. Subscribes to the source's aggregate `l2BlockSourceUpdated`
+ * event (when the source exposes one) to trigger an immediate reconciliation, while keeping the periodic poll as
+ * the correctness fallback. Subsystems keep consuming the same {@link L2BlockStreamEvent}s; the archiver aggregate
+ * event is handled entirely here.
+ *
+ * The event is passed through to the sync pass via {@link RunningPromise.trigger}. If, at the time the pass runs,
+ * the stream's local tips match the event's `fromTips` (it is caught up to where the event began), the event's
+ * hydrated blocks are served back through a hot-block cache and the event's `toTips` is reported as the source tips
+ * — so the triggered sync re-reads neither block bodies nor tips from the archiver. Otherwise the pass delegates
+ * entirely to the source, and the periodic poll guarantees eventual catch-up.
+ */
+export class EventDrivenL2BlockStream {
+  private readonly adapter: HotBlockSourceAdapter;
+  private readonly blockStream: L2BlockStream;
+  private readonly runningPromise: RunningPromise<L2BlockSourceUpdatedEvent>;
+  private readonly emitter: ArchiverEmitter | undefined;
+  private started = false;
+
+  private readonly onSourceUpdated = (event: L2BlockSourceUpdatedEvent) => {
+    // Fire-and-forget: trigger coalesces with any in-flight or periodic pass (see RunningPromise.trigger), so a
+    // burst of events does not run passes concurrently. Errors are swallowed by the inner stream's own handler.
+    void this.runningPromise
+      .trigger(event)
+      .catch(err => this.log.error(`Error in event-triggered block stream sync`, err));
+  };
+
+  constructor(
+    source: L2BlockSource | L2BlockSourceEventEmitter,
+    private readonly localData: L2BlockStreamLocalDataProvider,
+    handler: L2BlockStreamEventHandler,
+    private readonly log = createLogger('types:event_driven_block_stream'),
+    opts: L2BlockStreamOptions = {},
+  ) {
+    this.adapter = new HotBlockSourceAdapter(source, log);
+    // The inner stream's own RunningPromise is never started; this wrapper owns the polling loop and drives the
+    // stream through `sync()` (which runs `work()` directly when the inner loop is stopped).
+    this.blockStream = new L2BlockStream(this.adapter, localData, handler, log, opts);
+    this.runningPromise = new RunningPromise<L2BlockSourceUpdatedEvent>(
+      this.runPass.bind(this),
+      log,
+      opts.pollIntervalMS ?? 1000,
+    );
+    this.emitter = getEmitter(source);
+  }
+
+  public start(): void {
+    if (this.started) {
+      this.log.warn(`Attempted to start an already-started event-driven block stream`);
+      return;
+    }
+    this.started = true;
+    this.emitter?.on(L2BlockSourceEvents.L2BlockSourceUpdated, this.onSourceUpdated);
+    this.runningPromise.start();
+  }
+
+  public async stop(): Promise<void> {
+    this.started = false;
+    this.emitter?.off(L2BlockSourceEvents.L2BlockSourceUpdated, this.onSourceUpdated);
+    await this.runningPromise.stop();
+    await this.blockStream.stop();
+  }
+
+  public isRunning(): boolean {
+    return this.runningPromise.isRunning();
+  }
+
+  /**
+   * Runs a synchronization pass now, bypassing the poll interval, and resolves once that pass completes. Concurrent
+   * callers and periodic ticks coalesce onto a single pass; a caller that coalesces onto an already in-flight pass
+   * can resolve against a pass that began just before it, so this guarantees freshness only up to that coalescing
+   * window. The periodic poll and per-pass reorg handling make the gap a latency effect, never a correctness one.
+   */
+  public sync(): Promise<void> {
+    return this.runningPromise.trigger();
+  }
+
+  /**
+   * Runs a single pass over the underlying block stream. When triggered by an aggregate event and the stream is
+   * caught up to the event's pre-pass tips, the event's blocks and tips serve the pass directly; the fast path is
+   * always disarmed afterwards so a subsequent poll-driven pass reads from the source.
+   */
+  private async runPass(event?: L2BlockSourceUpdatedEvent): Promise<void> {
+    if (event) {
+      const localTips = await this.localData.getL2Tips();
+      if (localTipsMatch(localTips, event.fromTips)) {
+        this.adapter.activate(event.blocksAdded, event.toTips);
+      }
+    }
+
+    try {
+      await this.blockStream.sync();
+    } finally {
+      this.adapter.deactivate();
+    }
+  }
+}

package/src/block/l2_block_stream/index.ts

@@ -1,3 +1,4 @@
+export * from './event_driven_l2_block_stream.js';
 export * from './interfaces.js';
 export * from './l2_block_stream.js';
 export * from './l2_tips_memory_store.js';

package/src/block/l2_block_stream/interfaces.ts

@@ -1,17 +1,74 @@
-import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+
 import type { L2Block } from '../l2_block.js';
-import type { CheckpointId, L2BlockId, L2Tips } from '../l2_block_source.js';
+import type { CheckpointId, L2BlockId, L2TipId, L2Tips, LocalL2Tips } 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>;
+  getL2Tips(): Promise<LocalL2Tips>;
 }
 
-/** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
-export interface L2BlockStreamLocalDataProvider extends L2TipsProvider {
+/**
+ * A block id reported by a local data provider, whose hash may be unknown when the provider cannot resolve it (e.g.
+ * world-state cannot resolve the hash of a proven tip ahead of its synced range).
+ */
+export type LocalL2BlockId = { number: BlockNumber; hash?: string };
+
+/**
+ * Minimal local view of the chain the block stream needs to drive sync. `checkpointed` is only required when the
+ * stream emits checkpoint events (i.e. `ignoreCheckpoints` is off).
+ */
+export type LocalChainTips = {
+  proposed: LocalL2BlockId;
+  checkpointed?: { block: LocalL2BlockId; checkpoint: CheckpointId };
+  proven: { block: LocalL2BlockId };
+  finalized: { block: LocalL2BlockId };
+};
+
+/**
+ * Interface to the local view of the chain. Implemented by world-state and l2-tips-store. Anything implementing
+ * {@link L2TipsProvider} also satisfies this contract structurally, since {@link LocalL2Tips} is assignable to
+ * {@link LocalChainTips}.
+ */
+export interface L2BlockStreamLocalDataProvider {
+  getL2Tips(): Promise<LocalChainTips>;
   getL2BlockHash(number: number): Promise<string | undefined>;
 }
 
+/**
+ * Returns whether a local block id differs from a source block id. Compares block number and, when the local hash is
+ * known, block hash. The hash comparison is skipped when the local hash is undefined: world-state legitimately
+ * reports `undefined` hashes for tips ahead of its synced range, and comparing against an undefined hash would treat
+ * such a tip as different on every poll. An `undefined` local block (no local tip yet) always counts as differing.
+ */
+export function localBlockIdDiffers(localBlock: LocalL2BlockId | undefined, sourceBlock: L2BlockId): boolean {
+  if (localBlock === undefined) {
+    return true;
+  }
+  if (sourceBlock.number !== localBlock.number) {
+    return true;
+  }
+  if (localBlock.hash === undefined) {
+    return false;
+  }
+  return sourceBlock.hash !== localBlock.hash;
+}
+
+/**
+ * Returns whether the local chain tips agree with the given source tips on every tier the local provider exposes.
+ * Each tier is compared at the block level via {@link localBlockIdDiffers} (so an unresolved local hash matches on
+ * number alone); checkpoint ids are not compared, mirroring the stream's own tier reconciliation. The optional
+ * `checkpointed` tier is only compared when present (it is absent when the stream ignores checkpoints).
+ */
+export function localTipsMatch(local: LocalChainTips, source: L2Tips): boolean {
+  return (
+    !localBlockIdDiffers(local.proposed, source.proposed) &&
+    (local.checkpointed === undefined || !localBlockIdDiffers(local.checkpointed.block, source.checkpointed.block)) &&
+    !localBlockIdDiffers(local.proven.block, source.proven.block) &&
+    !localBlockIdDiffers(local.finalized.block, source.finalized.block)
+  );
+}
+
 /** Interface to a handler of events emitted. */
 export interface L2BlockStreamEventHandler {
   handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
@@ -22,27 +79,56 @@ export type L2BlockStreamEvent =
       type: 'blocks-added';
       blocks: L2Block[];
     }
-  | /** Emits checkpoints published to L1. */ {
+  | /**
+   * Reports the new proposed tip of the chain. Emitted once per sync pass when the source's proposed tip differs
+   * from the pre-pass local one (downloads, a prune, or a thin tip movement). Carries only the block id; in block
+   * mode the corresponding payloads arrive via preceding `blocks-added` events, while in tips-only mode this is the
+   * sole signal that the proposed tip moved. Consumers that only track the proposed tip can ignore `blocks-added`
+   * entirely and anchor on this event instead.
+   */ {
+      type: 'chain-proposed';
+      block: L2BlockId;
+    }
+  | /**
+   * Reports a new checkpointed tip. Emitted at most once per sync pass when the source's checkpointed tip
+   * leads the local one. Carries only the block + checkpoint ids; consumers that need the full checkpoint
+   * payload fetch it on demand from the block source.
+   */ {
       type: 'chain-checkpointed';
-      checkpoint: PublishedCheckpoint;
       block: L2BlockId;
+      checkpoint: CheckpointId;
     }
   | /**
    * Reports last correct block (new tip of the proposed chain). Note that this is not necessarily the anchor block
    * that will be used in the transaction - if the chain has already moved past the reorg, we'll also see blocks-added
-   * events that will push the anchor block forward.
+   * events that will push the anchor block forward. `block` is the prune target (the new proposed tip); `checkpointed`
+   * and `proven` are the source's confirmed checkpointed and proven tips (each a block and checkpoint id). Each is used
+   * to clamp the corresponding local cursor when it leads the source tip, so a cursor never overshoots its own source
+   * frontier during a prune (the source guarantees proven <= checkpointed).
    */ {
       type: 'chain-pruned';
       block: L2BlockId;
-      checkpoint: CheckpointId;
+      checkpointed: L2TipId;
+      proven: L2TipId;
     }
   | /** Reports new proven block. */ {
       type: 'chain-proven';
       block: L2BlockId;
+      checkpoint: CheckpointId;
     }
   | /** Reports new finalized block (proven and finalized on L1). */ {
       type: 'chain-finalized';
       block: L2BlockId;
+      checkpoint: CheckpointId;
     };
 
-export type L2TipsStore = L2BlockStreamEventHandler & L2BlockStreamLocalDataProvider;
+export type L2TipsStore = L2BlockStreamEventHandler &
+  L2TipsProvider &
+  Pick<L2BlockStreamLocalDataProvider, 'getL2BlockHash'> & {
+    /**
+     * Records `(number → hash)` witnesses into the walk-back hash index without moving any tip cursor. Consumers that
+     * materialize per-height state should record a witness for each height they materialize, so a reorg below the
+     * nearest sparse anchor does not produce an over-deep prune event. See {@link L2TipsStoreBase.recordBlockHashes}.
+     */
+    recordBlockHashes(blocks: L2BlockId[]): Promise<void>;
+  };