@aztec/aztec-node 6.0.0-nightly.20260604 → 6.0.0-nightly.20260721

package/src/modules/node_world_state_queries.ts

@@ -0,0 +1,374 @@
+import { ARCHIVE_HEIGHT, type L1_TO_L2_MSG_TREE_HEIGHT, type NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
+import { BlockNumber, type CheckpointNumber, type EpochNumber } from '@aztec/foundation/branded-types';
+import { chunkBy } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { MembershipWitness, type SiblingPath } from '@aztec/foundation/trees';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type BlockHash,
+  type BlockParameter,
+  type DataInBlock,
+  type L2BlockSource,
+  type NormalizedBlockParameter,
+  inspectBlockParameter,
+} from '@aztec/stdlib/block';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { InboxLeaf, type L1ToL2MessageSource, type L2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
+import {
+  MerkleTreeId,
+  type NullifierLeafPreimage,
+  NullifierMembershipWitness,
+  type PublicDataTreeLeafPreimage,
+  PublicDataWitness,
+} from '@aztec/stdlib/trees';
+import type { TxHash } from '@aztec/stdlib/tx';
+import { WorldStateSynchronizerError } from '@aztec/world-state';
+
+import { normalizeBlockParameter } from './block_parameter.js';
+
+/** Attempts at resolving a query and syncing world state to it before giving up (see {@link NodeWorldStateQueries.getWorldState}). */
+const WORLD_STATE_SYNC_ATTEMPTS = 3;
+
+/** Delay between world-state sync attempts. */
+const WORLD_STATE_SYNC_RETRY_DELAY_MS = 100;
+
+/** Dependencies required to build a {@link NodeWorldStateQueries}. */
+export interface NodeWorldStateQueriesDeps {
+  worldStateSynchronizer: WorldStateSynchronizer;
+  blockSource: L2BlockSource;
+  l1ToL2MessageSource: L1ToL2MessageSource;
+  log?: Logger;
+}
+
+/**
+ * Serves the node's Merkle-tree and membership-witness queries against committed world-state at a
+ * requested block. Extracted from `AztecNodeService` so the block-resolution and reorg-aware sync logic
+ * can be unit-tested without standing up the whole node, and to keep `server.ts` smaller.
+ */
+export class NodeWorldStateQueries {
+  private readonly worldStateSynchronizer: WorldStateSynchronizer;
+  private readonly blockSource: L2BlockSource;
+  private readonly l1ToL2MessageSource: L1ToL2MessageSource;
+  private readonly log: Logger;
+
+  constructor(deps: NodeWorldStateQueriesDeps) {
+    this.worldStateSynchronizer = deps.worldStateSynchronizer;
+    this.blockSource = deps.blockSource;
+    this.l1ToL2MessageSource = deps.l1ToL2MessageSource;
+    this.log = deps.log ?? createLogger('node:world-state-queries');
+  }
+
+  public async findLeavesIndexes(
+    referenceBlock: BlockParameter,
+    treeId: MerkleTreeId,
+    leafValues: Fr[],
+  ): Promise<(DataInBlock<bigint> | undefined)[]> {
+    const committedDb = await this.getWorldState(referenceBlock);
+    const maybeIndices = await committedDb.findLeafIndices(
+      treeId,
+      leafValues.map(x => x.toBuffer()),
+    );
+    // Filter out undefined values to query block numbers only for found leaves
+    const definedIndices = maybeIndices.filter(x => x !== undefined);
+
+    // Now we find the block numbers for the defined indices
+    const blockNumbers = await committedDb.getBlockNumbersForLeafIndices(treeId, definedIndices);
+
+    // Build a map from leaf index to block number
+    const indexToBlockNumber = new Map<bigint, BlockNumber>();
+    for (let i = 0; i < definedIndices.length; i++) {
+      const blockNumber = blockNumbers[i];
+      if (blockNumber === undefined) {
+        throw new Error(
+          `Block number is undefined for leaf index ${definedIndices[i]} in tree ${MerkleTreeId[treeId]}`,
+        );
+      }
+      indexToBlockNumber.set(definedIndices[i], blockNumber);
+    }
+
+    // Get unique block numbers in order to optimize num calls to getLeafValue function.
+    const uniqueBlockNumbers = [...new Set(indexToBlockNumber.values())];
+
+    // Now we obtain the block hashes from the archive tree (block number = leaf index in archive tree).
+    const blockHashes = await Promise.all(
+      uniqueBlockNumbers.map(blockNumber => {
+        return committedDb.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(blockNumber));
+      }),
+    );
+
+    // Build a map from block number to block hash
+    const blockNumberToHash = new Map<BlockNumber, BlockHash>();
+    for (let i = 0; i < uniqueBlockNumbers.length; i++) {
+      const blockHash = blockHashes[i];
+      if (blockHash === undefined) {
+        throw new Error(`Block hash is undefined for block number ${uniqueBlockNumbers[i]}`);
+      }
+      blockNumberToHash.set(uniqueBlockNumbers[i], blockHash);
+    }
+
+    // Create DataInBlock objects by combining indices, blockNumbers and blockHashes and return them.
+    return maybeIndices.map(index => {
+      if (index === undefined) {
+        return undefined;
+      }
+      const blockNumber = indexToBlockNumber.get(index);
+      if (blockNumber === undefined) {
+        throw new Error(`Block number not found for leaf index ${index} in tree ${MerkleTreeId[treeId]}`);
+      }
+      const l2BlockHash = blockNumberToHash.get(blockNumber);
+      if (l2BlockHash === undefined) {
+        throw new Error(`Block hash not found for block number ${blockNumber}`);
+      }
+      return {
+        l2BlockNumber: blockNumber,
+        l2BlockHash,
+        data: index,
+      };
+    });
+  }
+
+  public async getBlockHashMembershipWitness(
+    referenceBlock: BlockParameter,
+    blockHash: BlockHash,
+  ): Promise<MembershipWitness<typeof ARCHIVE_HEIGHT> | undefined> {
+    // The Noir circuit checks the archive membership proof against `anchor_block_header.last_archive.root`,
+    // which is the archive tree root BEFORE the anchor block was added (i.e. the state after block N-1).
+    // So we need the world state at block N-1, not block N, to produce a sibling path matching that root.
+    const referenceBlockNumber = await this.#resolveBlockNumber(referenceBlock);
+    if (referenceBlockNumber === BlockNumber.ZERO) {
+      // Block 0 (the initial block) has an empty archive, so no membership witness can exist.
+      return undefined;
+    }
+    const committedDb = await this.getWorldState(BlockNumber(referenceBlockNumber - 1));
+    const [pathAndIndex] = await committedDb.findSiblingPaths<MerkleTreeId.ARCHIVE>(MerkleTreeId.ARCHIVE, [blockHash]);
+    return pathAndIndex === undefined
+      ? undefined
+      : MembershipWitness.fromSiblingPath(pathAndIndex.index, pathAndIndex.path);
+  }
+
+  public async getNoteHashMembershipWitness(
+    referenceBlock: BlockParameter,
+    noteHash: Fr,
+  ): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT> | undefined> {
+    const committedDb = await this.getWorldState(referenceBlock);
+    const [pathAndIndex] = await committedDb.findSiblingPaths<MerkleTreeId.NOTE_HASH_TREE>(
+      MerkleTreeId.NOTE_HASH_TREE,
+      [noteHash],
+    );
+    return pathAndIndex === undefined
+      ? undefined
+      : MembershipWitness.fromSiblingPath(pathAndIndex.index, pathAndIndex.path);
+  }
+
+  public async getL1ToL2MessageMembershipWitness(
+    referenceBlock: BlockParameter,
+    l1ToL2Message: Fr,
+  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>] | undefined> {
+    const db = await this.getWorldState(referenceBlock);
+    const [witness] = await db.findSiblingPaths(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, [l1ToL2Message]);
+    if (!witness) {
+      return undefined;
+    }
+
+    // REFACTOR: Return a MembershipWitness object
+    return [witness.index, witness.path];
+  }
+
+  public async getL1ToL2MessageCheckpoint(l1ToL2Message: Fr): Promise<CheckpointNumber | undefined> {
+    const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
+    return messageIndex !== undefined ? InboxLeaf.checkpointNumberFromIndex(messageIndex) : undefined;
+  }
+
+  /**
+   * Returns all the L2 to L1 messages in an epoch (empty array if the epoch is not found). The public
+   * `AztecNodeService.getL2ToL1Messages` that delegates here is deprecated in favor of
+   * {@link getL2ToL1MembershipWitness}.
+   * @param epoch - The epoch at which to get the data.
+   */
+  public async getL2ToL1Messages(epoch: EpochNumber): Promise<Fr[][][][]> {
+    const blocks = await this.blockSource.getBlocks({ epoch, onlyCheckpointed: true });
+    const blocksInCheckpoints = chunkBy(blocks, block => block.header.globalVariables.slotNumber);
+    return blocksInCheckpoints.map(slotBlocks =>
+      slotBlocks.map(block => block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs)),
+    );
+  }
+
+  /**
+   * Returns the L2-to-L1 membership witness for a message in `txHash`. Passthrough to the
+   * archiver's locally-cached resolver — see {@link Archiver.getL2ToL1MembershipWitness}.
+   */
+  public getL2ToL1MembershipWitness(
+    txHash: TxHash,
+    message: Fr,
+    messageIndexInTx?: number,
+  ): Promise<L2ToL1MembershipWitness | undefined> {
+    return this.blockSource.getL2ToL1MembershipWitness(txHash, message, messageIndexInTx);
+  }
+
+  public async getNullifierMembershipWitness(
+    referenceBlock: BlockParameter,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    const db = await this.getWorldState(referenceBlock);
+    const [witness] = await db.findSiblingPaths(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]);
+    if (!witness) {
+      return undefined;
+    }
+
+    const { index, path } = witness;
+    const leafPreimage = await db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+    if (!leafPreimage) {
+      return undefined;
+    }
+
+    return new NullifierMembershipWitness(index, leafPreimage as NullifierLeafPreimage, path);
+  }
+
+  public async getLowNullifierMembershipWitness(
+    referenceBlock: BlockParameter,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    const committedDb = await this.getWorldState(referenceBlock);
+    const findResult = await committedDb.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+    if (!findResult) {
+      return undefined;
+    }
+    const { index, alreadyPresent } = findResult;
+    if (alreadyPresent) {
+      throw new Error(
+        `Cannot prove nullifier non-inclusion: nullifier ${nullifier.toBigInt()} already exists in the tree`,
+      );
+    }
+    const preimageData = (await committedDb.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index))!;
+
+    const siblingPath = await committedDb.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, BigInt(index));
+    return new NullifierMembershipWitness(BigInt(index), preimageData as NullifierLeafPreimage, siblingPath);
+  }
+
+  async getPublicDataWitness(referenceBlock: BlockParameter, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    const committedDb = await this.getWorldState(referenceBlock);
+    const lowLeafResult = await committedDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+    if (!lowLeafResult) {
+      return undefined;
+    } else {
+      const preimage = (await committedDb.getLeafPreimage(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        lowLeafResult.index,
+      )) as PublicDataTreeLeafPreimage;
+      const path = await committedDb.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+      return new PublicDataWitness(lowLeafResult.index, preimage, path);
+    }
+  }
+
+  public async getPublicStorageAt(referenceBlock: BlockParameter, contract: AztecAddress, slot: Fr): Promise<Fr> {
+    const committedDb = await this.getWorldState(referenceBlock);
+    const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
+
+    const lowLeafResult = await committedDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+    if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+      return Fr.ZERO;
+    }
+    const preimage = (await committedDb.getLeafPreimage(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      lowLeafResult.index,
+    )) as PublicDataTreeLeafPreimage;
+    return preimage.leaf.value;
+  }
+
+  /**
+   * Returns an instance of MerkleTreeOperations having first ensured the world state is synced to the requested
+   * block on the correct fork. Every query variant is resolved to a concrete (block number, block hash), which is
+   * threaded through both the sync and the snapshot read so a reorg that replaced the block at that height is
+   * detected rather than served silently. Transient failures — a prune landing between resolution and sync, or a
+   * fork flip caught at either the sync or the snapshot stage — are retried a few times, re-resolving the query
+   * against the updated chain each time; terminal failures — an unknown block hash at resolution, or a block whose
+   * history world state has pruned away — are thrown immediately.
+   * @param block - The block parameter (block number, block hash, or tag) at which to get the data.
+   * @returns An instance of a committed MerkleTreeOperations
+   */
+  public async getWorldState(block: BlockParameter) {
+    const query = normalizeBlockParameter(block);
+
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return await this.#resolveWorldState(query);
+      } catch (err) {
+        if (attempt >= WORLD_STATE_SYNC_ATTEMPTS || !(err instanceof WorldStateSynchronizerError)) {
+          throw err;
+        }
+        this.log.verbose(`Retrying world state query after sync failure: ${err.message}`, {
+          attempt,
+          block: inspectBlockParameter(block),
+        });
+        await sleep(WORLD_STATE_SYNC_RETRY_DELAY_MS);
+      }
+    }
+  }
+
+  /**
+   * Resolves `query` to a concrete (block number, block hash), syncs world state to that exact fork, and returns
+   * the committed db (for `proposed` queries) or the fork-verified snapshot at the resolved block.
+   */
+  async #resolveWorldState(query: NormalizedBlockParameter) {
+    // User requests 'latest on the current fork', so the committed db is returned unverified
+    if ('tag' in query && query.tag === 'proposed') {
+      this.log.debug(`Using committed db for latest block`);
+      await this.worldStateSynchronizer.syncImmediate();
+      return this.worldStateSynchronizer.getCommitted();
+    }
+
+    // Resolve the query against the block source BEFORE syncing to a concrete (number, hash), and drive the sync to
+    // that exact fork. Resolving after the sync races the block source: the resolved tip can advance past what world
+    // state synced while the sync is in flight. Passing the hash makes the sync reorg-aware — it barriers until the
+    // archive-tree commit for that block has landed and verifies it matches the requested fork, throwing otherwise.
+    const { blockNumber, blockHash } = await this.#resolveBlockNumberAndHash(query);
+    const blockSyncedTo = await this.worldStateSynchronizer.syncImmediate(blockNumber, blockHash);
+
+    // The fork could flip between it returning and the snapshot being read, so getVerifiedSnapshot pins the
+    // returned view to the resolved fork (re-resolved by the retry loop on mismatch).
+    this.log.debug(`Using verified snapshot for block ${blockNumber}, world state synced upto ${blockSyncedTo}`);
+    return await this.worldStateSynchronizer.getVerifiedSnapshot(blockNumber, blockHash);
+  }
+
+  /** Resolves any {@link BlockParameter} variant to its concrete `(blockNumber, blockHash)` via the block source. */
+  async #resolveBlockNumberAndHash(
+    query: NormalizedBlockParameter,
+  ): Promise<{ blockNumber: BlockNumber; blockHash: BlockHash }> {
+    const blockData = await this.blockSource.getBlockData(query);
+    if (blockData === undefined) {
+      this.#throwOnUndefinedBlockData(query);
+    }
+    return { blockNumber: blockData.header.getBlockNumber(), blockHash: blockData.blockHash };
+  }
+
+  /** Resolves any {@link BlockParameter} variant to a concrete block number. */
+  async #resolveBlockNumber(block: BlockParameter): Promise<BlockNumber> {
+    const blockQuery = normalizeBlockParameter(block);
+    const blockNumber = await this.blockSource.getBlockNumber(blockQuery);
+    if (blockNumber === undefined) {
+      this.#throwOnUndefinedBlockData(blockQuery);
+    }
+    return blockNumber;
+  }
+
+  /**
+   * Hash and archive misses are terminal (an unknown block, likely a reorg); tag and number misses are transient —
+   * the block may have been pruned between the tag->number resolution and this data read, or may simply not have
+   * arrived yet — and surface as {@link WorldStateSynchronizerError} so the retry loop re-resolves against the
+   * current chain.
+   */
+  #throwOnUndefinedBlockData(query: NormalizedBlockParameter): never {
+    if ('hash' in query) {
+      throw new Error(
+        `Block hash ${query.hash.toString()} not found when resolving query. If the node API has been queried with anchor block hash possibly a reorg has occurred.`,
+      );
+    }
+    if ('archive' in query) {
+      throw new Error(`Block with archive ${query.archive.toString()} not found when resolving query.`);
+    }
+    throw new WorldStateSynchronizerError(`Block not found for ${inspectBlockParameter(query)} when resolving query.`);
+  }
+}

package/src/sentinel/README.md

@@ -17,10 +17,10 @@ The sentinel is one of several watchers registered with the slasher; it does not
 | Source | What it provides |
 |---|---|
 | `EpochCache` | Slot/epoch helpers, committee + proposer for a slot, escape-hatch state |
-| `L2BlockSource` (archiver) | Synced slot, `chain-checkpointed` events, block headers |
+| `L2BlockSource` (archiver) | Synced slot, `getCheckpoint({ slot })`, `getL2Tips()`, block headers |
 | `P2PClient` | `getCheckpointAttestationsForSlot(slot, payloadHash)`, `hasBlockProposalsForSlot(slot)` |
 | `CheckpointReexecutionTracker` | Local re-execution outcome for the proposal at each slot (`valid` / `invalid` / `unvalidated`) — populated by the validator client's `ProposalHandler` |
-| L1-checkpointed events | `chain-checkpointed` populates `slotNumberToCheckpoint` with the canonical attestor set |
+| L1-confirmed checkpoints | Fetched on demand per slot via `archiver.getCheckpoint({ slot })`, yielding the canonical attestor set |
 
 ## Two cadences
 
@@ -49,7 +49,7 @@ For each slot, the proposer is assigned one of six statuses, ranked highest-conf
 
 | # | Status | Trigger | Inactive party |
 |---|---|---|---|
-| 6 | `checkpoint-mined` | `slotNumberToCheckpoint.has(slot)` (a checkpoint covering this slot has landed on L1) | Attestors who didn't attest |
+| 6 | `checkpoint-mined` | `archiver.getCheckpoint({ slot })` returns a checkpoint (one covering this slot has landed on L1) | Attestors who didn't attest |
 | 5 | `checkpoint-valid` | `tracker.getOutcomeForSlot(slot) === 'valid'` | Attestors who didn't attest |
 | 4 | `checkpoint-invalid` | `tracker.getOutcomeForSlot(slot) === 'invalid'` (re-executed and rejected) | Proposer |
 | 3 | `checkpoint-unvalidated` | `tracker.getOutcomeForSlot(slot) === 'unvalidated'` (validation aborted: missing data, timeout, etc.) | Proposer |

package/src/sentinel/factory.ts

@@ -5,7 +5,7 @@ import type { P2PClient } from '@aztec/p2p';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { CheckpointReexecutionTracker } from '@aztec/stdlib/checkpoint';
 import type { ChainConfig } from '@aztec/stdlib/config';
-import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { SlasherConfig, ValidatorClientConfig } from '@aztec/stdlib/interfaces/server';
 import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
 import type { SentinelConfig } from './config.js';
@@ -17,12 +17,24 @@ export async function createSentinel(
   archiver: L2BlockSource,
   p2p: P2PClient,
   reexecutionTracker: CheckpointReexecutionTracker,
-  config: SentinelConfig & DataStoreConfig & SlasherConfig & Pick<ChainConfig, 'l1ChainId' | 'rollupAddress'>,
+  config: SentinelConfig &
+    DataStoreConfig &
+    SlasherConfig &
+    Pick<ChainConfig, 'l1ChainId' | 'rollupAddress'> &
+    Pick<ValidatorClientConfig, 'disableValidator'>,
   logger = createLogger('node:sentinel'),
 ): Promise<Sentinel | undefined> {
-  if (!config.sentinelEnabled) {
+  const runsValidator = !config.disableValidator;
+  if (!runsValidator && !config.sentinelEnabled) {
+    logger.verbose('Sentinel is disabled');
     return undefined;
   }
+  if (runsValidator) {
+    logger.info('Enabling sentinel since this node runs a validator');
+  } else {
+    logger.info('Enabling sentinel from SENTINEL_ENABLED configuration');
+  }
+
   const kvStore = await createStore('sentinel', SentinelStore.SCHEMA_VERSION, config, logger.getBindings());
   const storeHistoryLength = config.sentinelHistoryLengthInEpochs * epochCache.getL1Constants().epochDuration;
   const storeHistoricEpochPerformanceLength = config.sentinelHistoricEpochPerformanceLengthInEpochs;

package/src/sentinel/sentinel.ts

@@ -1,16 +1,9 @@
 import type { EpochCache } from '@aztec/epoch-cache';
-import {
-  BlockNumber,
-  CheckpointNumber,
-  CheckpointProposalHash,
-  EpochNumber,
-  SlotNumber,
-} from '@aztec/foundation/branded-types';
+import { CheckpointNumber, CheckpointProposalHash, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { countWhile, filterAsync, fromEntries, getEntries, mapValues } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { L2TipsMemoryStore, type L2TipsStore } from '@aztec/kv-store/stores';
 import type { P2PClient } from '@aztec/p2p';
 import {
   OffenseType,
@@ -21,13 +14,7 @@ import {
   getOffenseTypeName,
 } from '@aztec/slasher';
 import type { SlasherConfig } from '@aztec/slasher/config';
-import {
-  type L2BlockSource,
-  L2BlockStream,
-  type L2BlockStreamEvent,
-  type L2BlockStreamEventHandler,
-  getAttestationInfoFromPublishedCheckpoint,
-} from '@aztec/stdlib/block';
+import { type L2BlockSource, getAttestationInfoFromPublishedCheckpoint } from '@aztec/stdlib/block';
 import type { CheckpointReexecutionTracker } from '@aztec/stdlib/checkpoint';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { getEpochAtSlot, getSlotRangeForEpoch, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
@@ -97,7 +84,7 @@ function statusToCategory(status: ValidatorStatusInSlot): ValidatorStatusType {
  * first:
  *
  *  - `checkpoint-mined`        — a checkpoint covering this slot has landed on L1
- *                                (`slotNumberToCheckpoint` populated from `chain-checkpointed`).
+ *                                (fetched on demand via `archiver.getCheckpoint({ slot })`).
  *  - `checkpoint-valid`        — the local node re-executed a checkpoint proposal for this slot
  *                                successfully (consulted via `CheckpointReexecutionTracker`).
  *  - `checkpoint-invalid`      — the local node re-executed a checkpoint proposal for this slot
@@ -135,25 +122,13 @@ function statusToCategory(status: ValidatorStatusInSlot): ValidatorStatusType {
  * (no history entries for that slot) and per-epoch evaluation writes an empty performance map
  * (no slashing).
  */
-export class Sentinel extends (EventEmitter as new () => WatcherEmitter) implements L2BlockStreamEventHandler, Watcher {
+export class Sentinel extends (EventEmitter as new () => WatcherEmitter) implements Watcher {
   protected runningPromise: RunningPromise;
-  protected blockStream!: L2BlockStream;
-  protected l2TipsStore: L2TipsStore;
 
   protected initialSlot: SlotNumber | undefined;
   protected lastProcessedSlot: SlotNumber | undefined;
   /** Largest epoch number for which the end-of-epoch aggregator has run. */
   protected lastEvaluatedEpoch: EpochNumber | undefined;
-  protected slotNumberToCheckpoint: Map<
-    SlotNumber,
-    {
-      checkpointNumber: CheckpointNumber;
-      archive: string;
-      /** Hex keccak256 of the consensus payload bytes; used to fetch matching p2p attestations. */
-      proposalPayloadHash: CheckpointProposalHash;
-      attestors: EthAddress[];
-    }
-  > = new Map();
 
   constructor(
     protected epochCache: EpochCache,
@@ -165,7 +140,6 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     protected logger = createLogger('node:sentinel'),
   ) {
     super();
-    this.l2TipsStore = new L2TipsMemoryStore(archiver.getGenesisBlockHash());
     const interval = (epochCache.getL1Constants().ethereumSlotDuration * 1000) / 4;
     this.runningPromise = new RunningPromise(this.work.bind(this), logger, interval);
   }
@@ -187,17 +161,14 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   }
 
   /**
-   * Loads initial slot and initializes blockstream. We will not process anything at or before
-   * the initial slot. Floors at the archiver's synced L2 slot so the sentinel keeps making
-   * forward progress when L1 is advancing but L2 has no activity (the synced slot is driven by
-   * L1 sync, not by L2 blocks). Falls back to the wallclock if the archiver isn't ready yet
-   * (cold start).
+   * Loads the initial slot. We will not process anything at or before the initial slot. Floors at the
+   * archiver's synced L2 slot so the sentinel keeps making forward progress when L1 is advancing but L2 has no
+   * activity (the synced slot is driven by L1 sync, not by L2 blocks). Falls back to the wallclock if the
+   * archiver isn't ready yet (cold start).
    */
   protected async init() {
     this.initialSlot = await this.getCurrentSlot();
-    const startingBlock = BlockNumber(await this.archiver.getBlockNumber());
-    this.logger.info(`Starting validator sentinel with initial slot ${this.initialSlot} and block ${startingBlock}`);
-    this.blockStream = new L2BlockStream(this.archiver, this.l2TipsStore, this, this.logger, { startingBlock });
+    this.logger.info(`Starting validator sentinel with initial slot ${this.initialSlot}`);
   }
 
   /**
@@ -215,44 +186,38 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     return this.runningPromise.stop();
   }
 
-  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
-    await this.l2TipsStore.handleBlockStreamEvent(event);
-    if (event.type === 'chain-checkpointed') {
-      this.handleCheckpoint(event);
-    }
-  }
-
-  protected handleCheckpoint(event: L2BlockStreamEvent) {
-    if (event.type !== 'chain-checkpointed') {
-      return;
+  /**
+   * Fetches the L1-confirmed checkpoint covering a slot (if any) and derives the slot-level data the
+   * activity classifier needs: the checkpoint number, archive root, consensus payload hash (used to fetch
+   * matching p2p attestations regardless of feeAssetPriceModifier variants), and the recovered attestor set.
+   * Reads on demand so the result is always against the canonical chain — a reorged-out checkpoint simply
+   * stops being returned, with no stale mapping to clean up.
+   */
+  protected async getCheckpointForSlot(slot: SlotNumber): Promise<
+    | {
+        checkpointNumber: CheckpointNumber;
+        archive: string;
+        proposalPayloadHash: CheckpointProposalHash;
+        attestors: EthAddress[];
+      }
+    | undefined
+  > {
+    const checkpoint = await this.archiver.getCheckpoint({ slot });
+    if (!checkpoint) {
+      return undefined;
     }
-    const checkpoint = event.checkpoint;
-
-    // Store mapping from slot to archive, checkpoint number, attestors, and the consensus payload
-    // hash (used to query matching p2p attestations regardless of feeAssetPriceModifier variants).
     const signatureContext = this.getSignatureContext();
     const proposalPayloadHash = CheckpointProposalHash.fromBuffer(
       ConsensusPayload.fromCheckpoint(checkpoint.checkpoint, signatureContext).getPayloadHash(),
     );
-    this.slotNumberToCheckpoint.set(checkpoint.checkpoint.header.slotNumber, {
+    return {
       checkpointNumber: checkpoint.checkpoint.number,
       archive: checkpoint.checkpoint.archive.root.toString(),
       proposalPayloadHash,
       attestors: getAttestationInfoFromPublishedCheckpoint(checkpoint, signatureContext)
         .filter(a => a.status === 'recovered-from-signature')
         .map(a => a.address!),
-    });
-
-    // Prune the archive map to only keep at most N entries
-    const historyLength = this.store.getHistoryLength();
-    if (this.slotNumberToCheckpoint.size > historyLength) {
-      const toDelete = Array.from(this.slotNumberToCheckpoint.keys())
-        .sort((a, b) => Number(a - b))
-        .slice(0, this.slotNumberToCheckpoint.size - historyLength);
-      for (const key of toDelete) {
-        this.slotNumberToCheckpoint.delete(key);
-      }
-    }
+    };
   }
 
   /**
@@ -387,10 +352,6 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
   public async work() {
     const currentSlot = await this.getCurrentSlot();
     try {
-      // Manually sync the block stream to ensure we have the latest data.
-      // Note we never `start` the blockstream, so it loops at the same pace as we do.
-      await this.blockStream.sync();
-
       // Per-slot activity recording (lag = 2 slots for P2P attestation settlement).
       const targetSlot = await this.isReadyToProcess(currentSlot);
       if (targetSlot !== false) {
@@ -478,7 +439,7 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
       return false;
     }
 
-    const archiverLastBlockHash = await this.l2TipsStore.getL2Tips().then(tip => tip.proposed.hash);
+    const archiverLastBlockHash = await this.archiver.getL2Tips().then(tip => tip.proposed.hash);
     const p2pLastBlockHash = await this.p2p.getL2Tips().then(tips => tips.proposed.hash);
     const isP2pSynced = archiverLastBlockHash === p2pLastBlockHash;
     if (!isP2pSynced) {
@@ -534,8 +495,9 @@ export class Sentinel extends (EventEmitter as new () => WatcherEmitter) impleme
     this.logger.debug(`Computing stats for slot ${slot} at epoch ${epoch}`, { slot, epoch, proposer, committee });
 
     // Gather attestors from both p2p (live attestations) and the archiver (signers on the
-    // checkpoint if one has landed on L1). Used regardless of which case applies.
-    const checkpoint = this.slotNumberToCheckpoint.get(slot);
+    // checkpoint if one has landed on L1). Fetched on demand so it always reflects the canonical chain.
+    // Used regardless of which case applies.
+    const checkpoint = await this.getCheckpointForSlot(slot);
     const p2pAttested = await this.p2p.getCheckpointAttestationsForSlot(slot, checkpoint?.proposalPayloadHash);
     const p2pAttestors = p2pAttested.map(a => a.getSender()).filter((s): s is EthAddress => s !== undefined);
     const attestors = new Set(