@lodestar/beacon-node 1.50.0-dev.fda8006fc3 → 1.50.0-dev.fe4e7408b4

package/src/sync/unknownBlock.ts

@@ -73,7 +73,11 @@ type AdvancePendingBlockResult =
   | "removed";
 
 class UnknownBlockRateLimitedError extends Error {
-  constructor(message: string) {
+  constructor(
+    message: string,
+    /** Earliest backoff expiry seen when the download was deferred, it is retried once that has passed */
+    readonly retryAt: number
+  ) {
     super(message);
     this.name = "UnknownBlockRateLimitedError";
   }
@@ -849,17 +853,20 @@ export class BlockInputSync {
     }
   };
 
-  private scheduleRateLimitBackoffRetry(): void {
+  /**
+   * Returns false if there is no backoff left to wait for, in which case no retry is scheduled.
+   */
+  private scheduleRateLimitBackoffRetry(): boolean {
     this.clearRateLimitBackoffTimer();
 
     if (!this.subscribedToNetworkEvents || (this.pendingBlocks.size === 0 && this.pendingPayloads.size === 0)) {
-      return;
+      return false;
     }
 
     const now = Date.now();
     const retryAt = this.peerBalancer.getNextRateLimitRetryAt();
     if (retryAt === null) {
-      return;
+      return false;
     }
 
     this.rateLimitBackoffTimeout = setTimeout(
@@ -870,6 +877,7 @@ export class BlockInputSync {
       },
       Math.max(0, retryAt - now)
     );
+    return true;
   }
 
   private clearRateLimitBackoffTimer(): void {
@@ -1081,7 +1089,11 @@ export class BlockInputSync {
           pendingBlock.status = PendingBlockInputStatus.pending;
         }
         this.logger.debug("Deferring unknown block download due to peer rate limit", logCtx, res.err);
-        this.scheduleRateLimitBackoffRetry();
+        if (!this.scheduleRateLimitBackoffRetry() || res.err.retryAt <= Date.now()) {
+          // The backoff this download waited for expired in the meantime, a timer is only armed if another
+          // peer is still in backoff and would retry it later than needed
+          this.triggerUnknownBlockSearch();
+        }
         return;
       }
 
@@ -1364,6 +1376,14 @@ export class BlockInputSync {
     if (!isPendingPayloadEnvelope(payload)) {
       payload.status = PendingPayloadInputStatus.pending;
     }
+    if (
+      res.err instanceof UnknownBlockRateLimitedError &&
+      (!this.scheduleRateLimitBackoffRetry() || res.err.retryAt <= Date.now())
+    ) {
+      // The backoff this download waited for expired in the meantime, a timer is only armed if another
+      // peer is still in backoff and would retry it later than needed
+      this.triggerUnknownBlockSearch();
+    }
   }
 
   private async processPayload(pendingPayload: PendingPayloadInput): Promise<void> {
@@ -1488,16 +1508,21 @@ export class BlockInputSync {
       const pendingColumns = payloadInput?.hasAllData()
         ? new Set<number>()
         : new Set(payloadInput?.getMissingSampledColumnMeta().missing ?? []);
+      // Same `now` for both calls, a backoff expiring in between would be reported as no peer available
+      const now = Date.now();
       // prefer peers that gossiped this payload root to us (#9923)
       const peerMeta = this.peerBalancer.bestPeerForPendingColumns(
         pendingColumns,
         excludedPeers,
-        cacheItem.peerIdStrings
+        cacheItem.peerIdStrings,
+        now
       );
       if (peerMeta === null) {
-        if (this.peerBalancer.getNextRateLimitRetryAt(pendingColumns, excludedPeers) !== null) {
+        const retryAt = this.peerBalancer.getNextRateLimitRetryAt(pendingColumns, excludedPeers, now);
+        if (retryAt !== null) {
           throw new UnknownBlockRateLimitedError(
-            `Error fetching payload by root slot=${slot} root=${rootHex} after ${i}: peers with needed columns are rate-limited`
+            `Error fetching payload by root slot=${slot} root=${rootHex} after ${i}: peers with needed columns are rate-limited`,
+            retryAt
           );
         }
 
@@ -1636,9 +1661,11 @@ export class BlockInputSync {
     );
     this.metrics?.blockInputSync.payloadFetchPeers.set({result: FetchResult.FailureMaxAttempts}, i - 1);
 
-    if (deferredByRateLimit && this.peerBalancer.getNextRateLimitRetryAt() !== null) {
+    const retryAt = deferredByRateLimit ? this.peerBalancer.getNextRateLimitRetryAt() : null;
+    if (retryAt !== null) {
       throw new UnknownBlockRateLimitedError(
-        `Error fetching payload with slot=${slot} root=${rootHex} after ${i - 1} attempts: peers are rate-limited`
+        `Error fetching payload with slot=${slot} root=${rootHex} after ${i - 1} attempts: peers are rate-limited`,
+        retryAt
       );
     }
     throw Error(`Error fetching payload with slot=${slot} root=${rootHex} after ${i - 1} attempts.`);
@@ -1730,16 +1757,21 @@ export class BlockInputSync {
         isPendingBlockInput(cacheItem) && isBlockInputColumns(cacheItem.blockInput)
           ? new Set(cacheItem.blockInput.getMissingSampledColumnMeta().missing)
           : defaultPendingColumns;
+      // Same `now` for both calls, a backoff expiring in between would be reported as no peer available
+      const now = Date.now();
       // prefer peers that gossiped this block root to us (#9923)
       const peerMeta = this.peerBalancer.bestPeerForPendingColumns(
         pendingColumns,
         excludedPeers,
-        cacheItem.peerIdStrings
+        cacheItem.peerIdStrings,
+        now
       );
       if (peerMeta === null) {
-        if (this.peerBalancer.getNextRateLimitRetryAt(pendingColumns, excludedPeers) !== null) {
+        const retryAt = this.peerBalancer.getNextRateLimitRetryAt(pendingColumns, excludedPeers, now);
+        if (retryAt !== null) {
           throw new UnknownBlockRateLimitedError(
-            `Error fetching UnknownBlockRoot slot=${slot} root=${rootHex} after ${i}: peers with needed columns are rate-limited`
+            `Error fetching UnknownBlockRoot slot=${slot} root=${rootHex} after ${i}: peers with needed columns are rate-limited`,
+            retryAt
           );
         }
 
@@ -1845,8 +1877,9 @@ export class BlockInputSync {
 
     const message = `Error fetching BlockInput with slot=${slot} root=${rootHex} after ${i - 1} attempts.`;
 
-    if (deferredByRateLimit && this.peerBalancer.getNextRateLimitRetryAt() !== null) {
-      throw new UnknownBlockRateLimitedError(`${message} Peers are rate-limited.`);
+    const retryAt = deferredByRateLimit ? this.peerBalancer.getNextRateLimitRetryAt() : null;
+    if (retryAt !== null) {
+      throw new UnknownBlockRateLimitedError(`${message} Peers are rate-limited.`, retryAt);
     }
 
     if (!isPendingBlockInput(cacheItem)) {
@@ -2037,8 +2070,11 @@ export class UnknownBlockPeerBalancer {
     this.rateLimitedUntilByPeer.set(peerId, rateLimitedUntilMs);
   }
 
-  getNextRateLimitRetryAt(pendingColumns?: Set<number>, excludedPeers?: Set<PeerIdStr>): number | null {
-    const now = Date.now();
+  getNextRateLimitRetryAt(
+    pendingColumns?: Set<number>,
+    excludedPeers?: Set<PeerIdStr>,
+    now = Date.now()
+  ): number | null {
     let retryAt: number | null = null;
 
     for (const [peerId, rateLimitedUntil] of this.rateLimitedUntilByPeer.entries()) {
@@ -2077,9 +2113,10 @@ export class UnknownBlockPeerBalancer {
   bestPeerForPendingColumns(
     pendingColumns: Set<number>,
     excludedPeers: Set<PeerIdStr>,
-    preferredPeers?: Set<PeerIdStr>
+    preferredPeers?: Set<PeerIdStr>,
+    now = Date.now()
   ): PeerSyncMeta | null {
-    const eligiblePeers = this.filterPeers(pendingColumns, excludedPeers);
+    const eligiblePeers = this.filterPeers(pendingColumns, excludedPeers, now);
     if (eligiblePeers.length === 0) {
       return null;
     }
@@ -2120,8 +2157,7 @@ export class UnknownBlockPeerBalancer {
     return totalActiveRequests;
   }
 
-  private filterPeers(pendingDataColumns: Set<number>, excludedPeers: Set<PeerIdStr>): PeerIdStr[] {
-    const now = Date.now();
+  private filterPeers(pendingDataColumns: Set<number>, excludedPeers: Set<PeerIdStr>, now: number): PeerIdStr[] {
     let maxColumnCount = 0;
     const considerPeers: {peerId: PeerIdStr; columnCount: number}[] = [];
     for (const [peerId, syncMeta] of this.peersMeta.entries()) {

package/src/sync/utils/downloadByRange.ts

@@ -1,5 +1,6 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {
+  ForkName,
   ForkPostDeneb,
   ForkPostFulu,
   ForkPostGloas,
@@ -13,9 +14,11 @@ import {
   RootHex,
   SignedBeaconBlock,
   Slot,
+  ValidatorIndex,
   deneb,
   fulu,
   gloas,
+  isGloasBeaconBlock,
   isGloasDataColumnSidecar,
   phase0,
 } from "@lodestar/types";
@@ -59,10 +62,17 @@ export type DownloadByRangeRequests = {
   };
 };
 
-export type ParentPayloadCommitments = {
+/**
+ * The head block when the `SyncChain` was created. The first block of the first batch may build on its FULL variant
+ * while the payload is not imported yet, the batch then downloads the payload by root as its dangling parent.
+ */
+export type ParentPayload = {
   blockRoot: Uint8Array;
   blockRootHex: RootHex;
-  kzgCommitments: deneb.BlobKzgCommitments;
+  slot: Slot;
+  proposerIndex: ValidatorIndex;
+  forkName: ForkName;
+  bid: gloas.ExecutionPayloadBid;
 };
 
 export type DownloadByRangeResponses = {
@@ -78,14 +88,14 @@ export type DownloadAndCacheByRangeProps = DownloadByRangeRequests & {
   logger: Logger;
   peerIdStr: string;
   batchBlocks?: IBlockInput[];
-  /** Required when `parentPayloadRequest` is set; supplies the data needed to validate the parent's columns. */
-  parentPayloadCommitments?: ParentPayloadCommitments;
+  /** Required when `parentPayloadRequest` is set */
+  parentPayload?: ParentPayload;
   peerDasMetrics?: BeaconMetrics["peerDas"] | null;
 };
 
 export type CacheByRangeResponsesProps = {
-  cache: SeenBlockInput;
-  seenPayloadEnvelopeInputCache: SeenPayloadEnvelopeInput;
+  cache: Pick<SeenBlockInput, "getByBlock">;
+  seenPayloadEnvelopeInputCache: Pick<SeenPayloadEnvelopeInput, "add" | "addFromBid">;
   peerIdStr: string;
   responses: ValidatedResponses;
   batchBlocks: IBlockInput[];
@@ -93,6 +103,8 @@ export type CacheByRangeResponsesProps = {
   downloadedPayloadEnvelopes: Map<Slot, gloas.SignedExecutionPayloadEnvelope> | null;
   /** Envelopes already wrapped from previous partial downloads on this batch */
   existingPayloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null;
+  /** Set when `downloadedPayloadEnvelopes` may contain the dangling parent envelope */
+  parentPayload?: ParentPayload;
   /** Sampled/custody column indices for building PayloadEnvelopeInputs */
   custodyConfig: Pick<CustodyConfig, "sampledColumns" | "custodyColumns">;
   seenTimestampSec: number;
@@ -130,6 +142,7 @@ export function cacheByRangeResponses({
   batchBlocks,
   downloadedPayloadEnvelopes,
   existingPayloadEnvelopes,
+  parentPayload,
   custodyConfig,
   seenTimestampSec,
 }: CacheByRangeResponsesProps): {blocks: IBlockInput[]; payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null} {
@@ -228,20 +241,29 @@ export function cacheByRangeResponses({
 
   if (downloadedPayloadEnvelopes !== null) {
     for (const [slot, envelope] of downloadedPayloadEnvelopes) {
-      // the only PayloadEnvelopeInput miss is the dangling parent, which we can get from the seen cache
+      // the only PayloadEnvelopeInput miss is the dangling parent
       let payloadInput = payloadEnvelopes.get(slot);
       if (payloadInput === undefined) {
+        const blockRootHex = toRootHex(envelope.message.beaconBlockRoot);
         if (updatedBatchBlocks.has(slot)) {
-          throw new Error(
-            `Missing PayloadEnvelopeInput for in-batch slot ${slot} root ${toRootHex(envelope.message.beaconBlockRoot)}`
-          );
+          throw new Error(`Missing PayloadEnvelopeInput for in-batch slot ${slot} root ${blockRootHex}`);
         }
-        payloadInput = seenPayloadEnvelopeInputCache.get(toRootHex(envelope.message.beaconBlockRoot));
-      }
-      if (payloadInput === undefined) {
-        throw new Error(
-          `Missing PayloadEnvelopeInput for slot ${slot} root ${toRootHex(envelope.message.beaconBlockRoot)}`
-        );
+        if (parentPayload === undefined || blockRootHex !== parentPayload.blockRootHex) {
+          throw new Error(`Coding error: envelope for slot ${slot} root ${blockRootHex} is not the dangling parent`);
+        }
+        // Recreates the entry if it was evicted, by the cache cap or after an invalid envelope failed the import,
+        // the parent block is not part of the batch to recreate it from
+        payloadInput = seenPayloadEnvelopeInputCache.addFromBid({
+          blockRootHex,
+          slot: parentPayload.slot,
+          forkName: parentPayload.forkName,
+          proposerIndex: parentPayload.proposerIndex,
+          bid: parentPayload.bid,
+          sampledColumns: custodyConfig.sampledColumns,
+          custodyColumns: custodyConfig.custodyColumns,
+          seenTimestampSec,
+          source: PayloadEnvelopeInputSource.byRange,
+        });
       }
 
       if (!payloadInput.hasPayloadEnvelope()) {
@@ -332,7 +354,7 @@ export async function downloadByRange({
   columnsRequest,
   envelopesRequest,
   parentPayloadRequest,
-  parentPayloadCommitments,
+  parentPayload,
   peerDasMetrics,
 }: DownloadAndCacheByRangeProps): Promise<
   WarnResult<
@@ -367,7 +389,7 @@ export async function downloadByRange({
     columnsRequest,
     envelopesRequest,
     parentPayloadRequest,
-    parentPayloadCommitments,
+    parentPayload,
     peerDasMetrics,
     ...response,
   });
@@ -471,7 +493,7 @@ export async function validateResponses({
   columnsRequest,
   envelopesRequest,
   parentPayloadRequest,
-  parentPayloadCommitments,
+  parentPayload,
   blocks,
   blobSidecars,
   columnSidecars,
@@ -481,7 +503,7 @@ export async function validateResponses({
   DownloadByRangeResponses & {
     config: ChainForkConfig;
     batchBlocks?: IBlockInput[];
-    parentPayloadCommitments?: ParentPayloadCommitments;
+    parentPayload?: ParentPayload;
     peerDasMetrics?: BeaconMetrics["peerDas"] | null;
   }): Promise<
   WarnResult<
@@ -502,9 +524,9 @@ export async function validateResponses({
     );
   }
 
-  // `parentPayloadRequest` and `parentPayloadCommitments` must be supplied together
-  if ((parentPayloadRequest === undefined) !== (parentPayloadCommitments === undefined)) {
-    throw new Error("Coding error: parentPayloadRequest and parentPayloadCommitments must be both set or both unset");
+  // `parentPayloadRequest` and `parentPayload` must be supplied together
+  if ((parentPayloadRequest === undefined) !== (parentPayload === undefined)) {
+    throw new Error("Coding error: parentPayloadRequest and parentPayload must be both set or both unset");
   }
 
   const validatedResponses: ValidatedResponses = {};
@@ -518,7 +540,7 @@ export async function validateResponses({
     validatedResponses.validatedBlocks = result.result;
   }
 
-  const needsEnvelopeValidation = !!envelopesRequest || parentPayloadCommitments !== undefined;
+  const needsEnvelopeValidation = !!envelopesRequest || parentPayload !== undefined;
   const dataRequest = blobsRequest ?? columnsRequest;
   if (!dataRequest && !needsEnvelopeValidation) {
     return {result: {responses: validatedResponses, payloadEnvelopes: null}, warnings};
@@ -526,12 +548,8 @@ export async function validateResponses({
 
   if (!dataRequest) {
     // Only envelope and/or parent-by-root validation needed
-    if (parentPayloadCommitments !== undefined) {
-      const parentValidated = await validateParentPayloadColumns(
-        parentPayloadCommitments,
-        columnSidecars ?? [],
-        peerDasMetrics
-      );
+    if (parentPayload !== undefined) {
+      const parentValidated = await validateParentPayloadColumns(parentPayload, columnSidecars ?? [], peerDasMetrics);
       if (parentValidated) {
         validatedResponses.validatedColumnSidecars = [parentValidated];
       }
@@ -540,7 +558,7 @@ export async function validateResponses({
       validatedResponses.validatedBlocks ?? [],
       batchBlocks,
       payloadEnvelopes ?? [],
-      parentPayloadCommitments
+      parentPayload
     );
     return {result: {responses: validatedResponses, payloadEnvelopes: validatedPayloadEnvelopes}, warnings};
   }
@@ -601,12 +619,8 @@ export async function validateResponses({
   }
 
   // Parent columns (by-root): KZG-validate against parent's bid commitments and append.
-  if (parentPayloadCommitments !== undefined) {
-    const parentValidated = await validateParentPayloadColumns(
-      parentPayloadCommitments,
-      columnSidecars ?? [],
-      peerDasMetrics
-    );
+  if (parentPayload !== undefined) {
+    const parentValidated = await validateParentPayloadColumns(parentPayload, columnSidecars ?? [], peerDasMetrics);
     if (parentValidated) {
       validatedResponses.validatedColumnSidecars = [
         ...(validatedResponses.validatedColumnSidecars ?? []),
@@ -621,7 +635,7 @@ export async function validateResponses({
       validatedResponses.validatedBlocks ?? [],
       batchBlocks,
       payloadEnvelopes ?? [],
-      parentPayloadCommitments
+      parentPayload
     );
   }
 
@@ -629,13 +643,13 @@ export async function validateResponses({
 }
 
 async function validateParentPayloadColumns(
-  parentPayloadCommitments: ParentPayloadCommitments,
+  parentPayload: ParentPayload,
   columnSidecars: DataColumnSidecar[],
   peerDasMetrics?: BeaconMetrics["peerDas"] | null
 ): Promise<ValidatedColumnSidecars | null> {
   const parentColumns: gloas.DataColumnSidecar[] = [];
   for (const cs of columnSidecars) {
-    if (isGloasDataColumnSidecar(cs) && byteArrayEquals(cs.beaconBlockRoot, parentPayloadCommitments.blockRoot)) {
+    if (isGloasDataColumnSidecar(cs) && byteArrayEquals(cs.beaconBlockRoot, parentPayload.blockRoot)) {
       parentColumns.push(cs);
     }
   }
@@ -645,17 +659,16 @@ async function validateParentPayloadColumns(
   }
 
   parentColumns.sort((a, b) => a.index - b.index);
-  const parentSlot = parentColumns[0].slot;
 
   await validateGloasBlockDataColumnSidecars(
-    parentSlot,
-    parentPayloadCommitments.blockRoot,
-    parentPayloadCommitments.kzgCommitments,
+    parentPayload.slot,
+    parentPayload.blockRoot,
+    parentPayload.bid.blobKzgCommitments,
     parentColumns,
     peerDasMetrics
   );
 
-  return {blockRoot: parentPayloadCommitments.blockRoot, columnSidecars: parentColumns};
+  return {blockRoot: parentPayload.blockRoot, columnSidecars: parentColumns};
 }
 
 /**
@@ -1171,6 +1184,10 @@ export enum DownloadByRangeErrorCode {
 
   /** Envelope beaconBlockRoot does not match the block's root */
   INVALID_ENVELOPE_BEACON_BLOCK_ROOT = "DOWNLOAD_BY_RANGE_ERROR_INVALID_ENVELOPE_BEACON_BLOCK_ROOT",
+  /** Envelope payload.blockHash does not match the block's bid */
+  INVALID_ENVELOPE_BLOCK_HASH = "DOWNLOAD_BY_RANGE_ERROR_INVALID_ENVELOPE_BLOCK_HASH",
+  /** Dangling parent envelope payload.slotNumber does not match the parent's slot */
+  INVALID_ENVELOPE_SLOT = "DOWNLOAD_BY_RANGE_ERROR_INVALID_ENVELOPE_SLOT",
 
   /** Block segment + envelopes failed chain-segment linearity / FULL-chain checks */
   INVALID_CHAIN_SEGMENT = "DOWNLOAD_BY_RANGE_ERROR_INVALID_CHAIN_SEGMENT",
@@ -1272,6 +1289,17 @@ export type DownloadByRangeErrorType =
       expected: string;
       actual: string;
     }
+  | {
+      code: DownloadByRangeErrorCode.INVALID_ENVELOPE_BLOCK_HASH;
+      slot: Slot;
+      expected: string;
+      actual: string;
+    }
+  | {
+      code: DownloadByRangeErrorCode.INVALID_ENVELOPE_SLOT;
+      expected: Slot;
+      actual: Slot;
+    }
   | {
       code: DownloadByRangeErrorCode.INVALID_CHAIN_SEGMENT;
       slot: Slot;
@@ -1285,57 +1313,94 @@ export class DownloadByRangeError extends LodestarError<DownloadByRangeErrorType
  *
  * Three categories of envelope slots:
  *   - In-batch slot whose block we have: verify envelope.beaconBlockRoot matches.
- *   - Dangling-parent envelope (only when `parentPayloadCommitments` is set, i.e. the first
- *     batch of a `SyncChain`): keep if `envelope.beaconBlockRoot === parentPayloadCommitments.blockRoot`.
+ *   - Dangling-parent envelope (only when `parentPayload` is set, i.e. the first
+ *     batch of a `SyncChain`): keep if `envelope.beaconBlockRoot === parentPayload.blockRoot`, its slot and
+ *     block hash must match the parent's bid.
  *   - Other "orphan" envelopes (e.g. unrelated slots): ignored.
  */
 export function validateEnvelopesByRangeResponse(
   validatedBlocks: ValidatedBlock[],
   batchBlocks: IBlockInput[] | undefined,
   payloadEnvelopes: gloas.SignedExecutionPayloadEnvelope[],
-  parentPayloadCommitments?: ParentPayloadCommitments
+  parentPayload?: ParentPayload
 ): Map<Slot, gloas.SignedExecutionPayloadEnvelope> {
-  // Build a map of slot -> blockRoot for all blocks in the batch
-  const batchBlockRoots = new Map<Slot, Uint8Array>();
+  // Build a map of slot -> block root and bid block hash for all blocks in the batch
+  const batchBlocksBySlot = new Map<Slot, {blockRoot: Uint8Array; block: SignedBeaconBlock | null}>();
   if (batchBlocks) {
     for (const blockInput of batchBlocks) {
-      batchBlockRoots.set(blockInput.slot, fromHex(blockInput.blockRootHex));
+      batchBlocksBySlot.set(blockInput.slot, {
+        blockRoot: fromHex(blockInput.blockRootHex),
+        block: blockInput.hasBlock() ? blockInput.getBlock() : null,
+      });
     }
   }
   for (const {block, blockRoot} of validatedBlocks) {
-    batchBlockRoots.set(block.message.slot, blockRoot);
+    batchBlocksBySlot.set(block.message.slot, {blockRoot, block});
   }
 
   const payloadEnvelopeMap = new Map<Slot, gloas.SignedExecutionPayloadEnvelope>();
 
   for (const payloadEnvelope of payloadEnvelopes) {
     const slot = payloadEnvelope.message.payload.slotNumber;
-    const batchBlockRoot = batchBlockRoots.get(slot);
+    const batchBlock = batchBlocksBySlot.get(slot);
 
-    if (batchBlockRoot === undefined) {
+    if (batchBlock === undefined) {
       // Keep the requested dangling-parent envelope only when its beaconBlockRoot matches
       // exactly. All other unrelated envelopes are dropped.
       if (
-        parentPayloadCommitments !== undefined &&
-        byteArrayEquals(payloadEnvelope.message.beaconBlockRoot, parentPayloadCommitments.blockRoot)
+        parentPayload !== undefined &&
+        byteArrayEquals(payloadEnvelope.message.beaconBlockRoot, parentPayload.blockRoot)
       ) {
+        if (slot !== parentPayload.slot) {
+          throw new DownloadByRangeError({
+            code: DownloadByRangeErrorCode.INVALID_ENVELOPE_SLOT,
+            expected: parentPayload.slot,
+            actual: slot,
+          });
+        }
+        assertEnvelopeBlockHash(payloadEnvelope, parentPayload.bid.blockHash);
         payloadEnvelopeMap.set(slot, payloadEnvelope);
       }
       continue;
     }
 
     // Verify beaconBlockRoot matches the block's root
-    if (!byteArrayEquals(payloadEnvelope.message.beaconBlockRoot, batchBlockRoot)) {
+    if (!byteArrayEquals(payloadEnvelope.message.beaconBlockRoot, batchBlock.blockRoot)) {
       throw new DownloadByRangeError({
         code: DownloadByRangeErrorCode.INVALID_ENVELOPE_BEACON_BLOCK_ROOT,
         slot,
-        expected: toRootHex(batchBlockRoot),
+        expected: toRootHex(batchBlock.blockRoot),
         actual: toRootHex(payloadEnvelope.message.beaconBlockRoot),
       });
     }
 
+    if (batchBlock.block !== null && isGloasBeaconBlock(batchBlock.block.message)) {
+      assertEnvelopeBlockHash(
+        payloadEnvelope,
+        batchBlock.block.message.body.signedExecutionPayloadBid.message.blockHash
+      );
+    }
+
     payloadEnvelopeMap.set(slot, payloadEnvelope);
   }
 
   return payloadEnvelopeMap;
 }
+
+/**
+ * Rejected before it is cached. In-batch, `assertLinearChainSegment` fails on a wrong hash without evicting the
+ * envelope. For the dangling parent, the mismatch would only be caught at import.
+ */
+function assertEnvelopeBlockHash(
+  payloadEnvelope: gloas.SignedExecutionPayloadEnvelope,
+  bidBlockHash: Uint8Array
+): void {
+  if (!byteArrayEquals(payloadEnvelope.message.payload.blockHash, bidBlockHash)) {
+    throw new DownloadByRangeError({
+      code: DownloadByRangeErrorCode.INVALID_ENVELOPE_BLOCK_HASH,
+      slot: payloadEnvelope.message.payload.slotNumber,
+      expected: toRootHex(bidBlockHash),
+      actual: toRootHex(payloadEnvelope.message.payload.blockHash),
+    });
+  }
+}

package/src/util/asyncIterableToEvents.ts

@@ -6,6 +6,10 @@ export type RequestEvent<T> = {
   id: number;
 };
 
+export type RequestCancelEvent = {
+  id: number;
+};
+
 export enum IteratorEventType {
   next = "iterator.next",
   done = "iterator.done",
@@ -19,8 +23,10 @@ export type IteratorEvent<V> =
 
 export type AsyncIterableEventBus<Args, Item> = {
   emitRequest(data: RequestEvent<Args>): void;
+  emitRequestCancel(data: RequestCancelEvent): void;
   emitResponse(data: IteratorEvent<Item>): void;
   onRequest(handler: (data: RequestEvent<Args>) => void): void;
+  onRequestCancel(handler: (data: RequestCancelEvent) => void): void;
   onResponse(handler: (data: IteratorEvent<Item>) => void): void;
 };
 
@@ -37,7 +43,9 @@ export class AsyncIterableBridgeCaller<Args, Item> {
   // TODO: Consider expiring the requests after no reply for long enough, t
   private readonly pending = new Map<number, PendingItem<Item>>();
 
-  constructor(private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onResponse" | "emitRequest">) {
+  constructor(
+    private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onResponse" | "emitRequest" | "emitRequestCancel">
+  ) {
     events.onResponse(this.onResponse.bind(this));
   }
 
@@ -89,7 +97,10 @@ export class AsyncIterableBridgeCaller<Args, Item> {
 
           async return() {
             // This will be reached if the consumer called 'break' or 'return' early in the loop.
-            self.pending.delete(id);
+            // Without the cancel the handler keeps producing items that cross the thread boundary just to be dropped
+            if (self.pending.delete(id)) {
+              self.events.emitRequestCancel({id});
+            }
             return {value: undefined, done: true};
           },
         };
@@ -132,20 +143,35 @@ export class AsyncIterableBridgeCaller<Args, Item> {
 }
 
 export class AsyncIterableBridgeHandler<Args, Item> {
+  private readonly iterators = new Map<number, AsyncIterator<Item>>();
+
   constructor(
-    private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onRequest" | "emitResponse">,
+    private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onRequest" | "onRequestCancel" | "emitResponse">,
     private readonly handler: (args: Args) => AsyncIterable<Item>
   ) {
     events.onRequest(this.onRequest.bind(this));
+    events.onRequestCancel(this.onRequestCancel.bind(this));
+  }
+
+  get iteratingCount(): number {
+    return this.iterators.size;
   }
 
   private async onRequest(data: RequestEvent<Args>): Promise<void> {
     try {
-      for await (const item of this.handler(data.callArgs)) {
+      const iterator = this.handler(data.callArgs)[Symbol.asyncIterator]();
+      this.iterators.set(data.id, iterator);
+
+      while (true) {
+        const result = await iterator.next();
+        if (result.done) {
+          break;
+        }
+
         this.events.emitResponse({
           type: IteratorEventType.next,
           id: data.id,
-          item,
+          item: result.value,
         });
       }
 
@@ -159,6 +185,19 @@ export class AsyncIterableBridgeHandler<Args, Item> {
         id: data.id,
         error: toThreadBoundaryError(e as Error),
       });
+    } finally {
+      this.iterators.delete(data.id);
+    }
+  }
+
+  private onRequestCancel(data: RequestCancelEvent): void {
+    const iterator = this.iterators.get(data.id);
+    if (!iterator?.return) {
+      return;
     }
+
+    // An async generator queues return() behind the next() that is in flight, so at most one more
+    // item is produced before its finally blocks run. Any error surfaces through that next() call.
+    void iterator.return().catch(() => {});
   }
 }