@lodestar/beacon-node 1.43.0-dev.374360e50a → 1.43.0-dev.38cd4b01e7

package/src/chain/blocks/payloadEnvelopeInput/types.ts

@@ -30,6 +30,23 @@ export type CreateFromBlockProps = {
   daOutOfRange: boolean;
 };
 
+/**
+ * Used to seed an entry from a state's `latestExecutionPayloadBid` (e.g., when initializing
+ * the chain from a checkpoint anchor state — we have the bid via the state but not the
+ * full SignedBeaconBlock).
+ */
+export type CreateFromBidProps = {
+  blockRootHex: RootHex;
+  slot: number;
+  forkName: ForkName;
+  proposerIndex: number;
+  bid: gloas.ExecutionPayloadBid;
+  sampledColumns: ColumnIndex[];
+  custodyColumns: ColumnIndex[];
+  timeCreatedSec: number;
+  daOutOfRange: boolean;
+};
+
 export type AddPayloadEnvelopeProps = SourceMeta & {
   envelope: gloas.SignedExecutionPayloadEnvelope;
 };

package/src/chain/blocks/utils/chainSegment.ts

@@ -17,8 +17,6 @@ export type ChainSegmentResult = {warnings: OrphanedPayloadEnvelope[] | null};
  * Assert this chain segment of blocks is linear with slot numbers and hashes,
  * and that the provided envelopes are consistent with their respective blocks.
  *
- * Must be called after verifyBlocksSanityChecks so that parentBlock (from forkchoice)
- * is available to seed the execution hash chain.
  *
  * For each block:
  * - Verifies parent root + slot linearity
@@ -31,7 +29,7 @@ export function assertLinearChainSegment(
   config: ChainForkConfig,
   blocks: IBlockInput[],
   payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
-  parentBlock: ProtoBlock
+  parentBlock: ProtoBlock | null
 ): ChainSegmentResult {
   const warnings: OrphanedPayloadEnvelope[] = [];
 
@@ -39,15 +37,16 @@ export function assertLinearChainSegment(
   // Starts from the known forkchoice parent's execution hash.
   // - FULL variant (envelope present for slot): advances to envelope.payload.blockHash
   // - EMPTY variant (no envelope for slot): execution hash is unchanged
-  // null only for pre-merge parents, which cannot precede gloas blocks.
-  let currentExecHash: string | null = parentBlock.executionPayloadBlockHash;
+  let currentExecHash: string | null = parentBlock?.executionPayloadBlockHash ?? null;
   // Checkpoint sync first batch: parent is the anchor PENDING whose executionPayloadBlockHash
   // is the inherited parentBlockHash semantic (= grandparent's payload), not its own payload.
   // If parent's own payload envelope arrives in this batch, advance currentExecHash to that
   // payload's blockHash so the segment validation sees the true EL chain head.
-  const parentPayloadInput = payloadEnvelopes?.get(parentBlock.slot);
-  if (parentPayloadInput?.hasPayloadEnvelope()) {
-    currentExecHash = parentPayloadInput.getBlockHashHex();
+  if (parentBlock !== null) {
+    const parentPayloadInput = payloadEnvelopes?.get(parentBlock.slot);
+    if (parentPayloadInput?.hasPayloadEnvelope()) {
+      currentExecHash = parentPayloadInput.getBlockHashHex();
+    }
   }
   // Track the execution hash before the last FULL advancement so we can recover
   // if the next block reveals that envelope was orphaned.
@@ -76,27 +75,31 @@ export function assertLinearChainSegment(
       }
     }
 
-    if (isGloasBeaconBlock(block.message) && currentExecHash !== null) {
-      // Verify the bid's parentBlockHash matches the tracked execution hash.
-      // This ensures the block was built on the correct FULL or EMPTY variant of its parent.
-      const bidParentHash = toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash);
-      if (bidParentHash !== currentExecHash) {
-        // Maybe the previous slot's FULL envelope was orphaned — try falling back.
-        // If even prevExecHash doesn't match, the segment is non-linear.
-        if (bidParentHash !== prevExecHash) {
-          throw new BlockError(block, {
-            code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
-            parentRoot: toRootHex(block.message.parentRoot),
-            parentBlockHash: bidParentHash,
-          });
-        }
-        if (lastFullSlot !== null && payloadEnvelopes !== null) {
-          const orphanedInput = payloadEnvelopes.get(lastFullSlot);
-          if (orphanedInput != null) {
-            warnings.push({slot: lastFullSlot, payloadEnvelopeInput: orphanedInput});
+    if (isGloasBeaconBlock(block.message)) {
+      // Bid check fires only when we have a seeded execution hash. With parentBlock=null the
+      // chain is seeded mid-segment by the first FULL envelope.
+      if (currentExecHash !== null) {
+        // Verify the bid's parentBlockHash matches the tracked execution hash.
+        // This ensures the block was built on the correct FULL or EMPTY variant of its parent.
+        const bidParentHash = toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash);
+        if (bidParentHash !== currentExecHash) {
+          // Maybe the previous slot's FULL envelope was orphaned — try falling back.
+          // If even prevExecHash doesn't match, the segment is non-linear.
+          if (bidParentHash !== prevExecHash) {
+            throw new BlockError(block, {
+              code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+              parentRoot: toRootHex(block.message.parentRoot),
+              parentBlockHash: bidParentHash,
+            });
+          }
+          if (lastFullSlot !== null && payloadEnvelopes !== null) {
+            const orphanedInput = payloadEnvelopes.get(lastFullSlot);
+            if (orphanedInput != null) {
+              warnings.push({slot: lastFullSlot, payloadEnvelopeInput: orphanedInput});
+            }
           }
+          currentExecHash = prevExecHash;
         }
-        currentExecHash = prevExecHash;
       }
 
       const payloadInput = payloadEnvelopes?.get(slot) ?? null;

package/src/chain/blocks/verifyExecutionPayloadEnvelope.ts

@@ -82,16 +82,19 @@ export function verifyExecutionPayloadEnvelope(
     }
   }
 
-  // Verify the execution payload is valid
-  if (payload.slotNumber !== state.slot) {
-    throw new Error(`Slot mismatch between payload and state payload=${payload.slotNumber} state=${state.slot}`);
+  // should not use state.slot, it does not work for skipped slot checkpoint sync
+  const blockSlot = state.latestBlockHeader.slot;
+  if (payload.slotNumber !== blockSlot) {
+    throw new Error(
+      `Slot mismatch between payload and latest block header payload=${payload.slotNumber} latestBlockHeader=${blockSlot}`
+    );
   }
   if (!byteArrayEquals(payload.parentHash, state.latestBlockHash)) {
     throw new Error(
       `Parent hash mismatch between payload and state payload=${toRootHex(payload.parentHash)} state=${toRootHex(state.latestBlockHash)}`
     );
   }
-  const expectedTimestamp = computeTimeAtSlot(config, state.slot, state.genesisTime);
+  const expectedTimestamp = computeTimeAtSlot(config, blockSlot, state.genesisTime);
   if (payload.timestamp !== expectedTimestamp) {
     throw new Error(
       `Timestamp mismatch between payload and state payload=${payload.timestamp} state=${expectedTimestamp}`

package/src/chain/chain.ts

@@ -23,6 +23,7 @@ import {
   getEffectiveBalancesFromStateBytes,
   isStatePostAltair,
   isStatePostElectra,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {
   BeaconBlock,
@@ -390,6 +391,7 @@ export class BeaconChain implements IBeaconChain {
       metrics,
       logger
     );
+
     const regen = new QueuedStateRegenerator({
       config,
       forkChoice,
@@ -426,6 +428,21 @@ export class BeaconChain implements IBeaconChain {
       logger,
     });
 
+    const anchorBlockSlot = anchorState.latestBlockHeader.slot;
+    if (isStatePostGloas(anchorState) && anchorBlockSlot > 0) {
+      const anchorBid = anchorState.latestExecutionPayloadBid;
+      this.seenPayloadEnvelopeInputCache.addFromBid({
+        blockRootHex: toRootHex(checkpoint.root),
+        slot: anchorBlockSlot,
+        forkName: anchorState.forkName,
+        proposerIndex: anchorState.latestBlockHeader.proposerIndex,
+        bid: anchorBid,
+        sampledColumns: this.custodyConfig.sampledColumns,
+        custodyColumns: this.custodyConfig.custodyColumns,
+        timeCreatedSec: Math.floor(Date.now() / 1000),
+      });
+    }
+
     this.clock = clock;
     this.regen = regen;
     this.bls = bls;

package/src/chain/initState.ts

@@ -1,7 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ZERO_HASH} from "@lodestar/params";
+import {ForkPostGloas, ForkSeq, ZERO_HASH} from "@lodestar/params";
 import {
   BeaconStateAllForks,
+  BeaconStateGloas,
   IBeaconStateView,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
@@ -52,6 +53,13 @@ export function createGenesisBlock(config: ChainForkConfig, genesisState: Beacon
   const genesisBlock = types.SignedBeaconBlock.defaultValue();
   const stateRoot = genesisState.hashTreeRoot();
   genesisBlock.message.stateRoot = stateRoot;
+
+  if (config.getForkSeq(GENESIS_SLOT) >= ForkSeq.gloas) {
+    const gloasBlock = genesisBlock as SignedBeaconBlock<ForkPostGloas>;
+    const gloasState = genesisState as BeaconStateGloas;
+    gloasBlock.message.body.signedExecutionPayloadBid.message = gloasState.latestExecutionPayloadBid.toValue();
+  }
+
   return genesisBlock;
 }
 

package/src/chain/lightClient/index.ts

@@ -1,12 +1,6 @@
 import {BitArray} from "@chainsafe/ssz";
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {
-  LightClientUpdateSummary,
-  isBetterUpdate,
-  toLightClientUpdateSummary,
-  upgradeLightClientHeader,
-} from "@lodestar/light-client/spec";
 import {
   ForkName,
   ForkPostAltair,
@@ -27,6 +21,12 @@ import {
   computeSyncPeriodAtSlot,
   executionPayloadToPayloadHeader,
 } from "@lodestar/state-transition";
+import {
+  LightClientUpdateSummary,
+  isBetterUpdate,
+  toLightClientUpdateSummary,
+  upgradeLightClientHeader,
+} from "@lodestar/state-transition/light-client";
 import {
   BeaconBlock,
   BeaconBlockBody,

package/src/chain/opPools/payloadAttestationPool.ts

@@ -57,7 +57,7 @@ export class PayloadAttestationPool {
   add(
     message: gloas.PayloadAttestationMessage,
     payloadAttDataRootHex: RootHex,
-    validatorCommitteeIndex: number
+    validatorCommitteeIndices: number[]
   ): InsertOutcome {
     const slot = message.data.slot;
     const lowestPermissibleSlot = this.lowestPermissibleSlot;
@@ -85,10 +85,10 @@ export class PayloadAttestationPool {
     const aggregate = aggregateByDataRoot.get(payloadAttDataRootHex);
     if (aggregate) {
       // Aggregate msg into aggregate
-      return aggregateMessageInto(message, validatorCommitteeIndex, aggregate);
+      return aggregateMessageInto(message, validatorCommitteeIndices, aggregate);
     }
     // Create a new aggregate with data
-    aggregateByDataRoot.set(payloadAttDataRootHex, messageToAggregate(message, validatorCommitteeIndex));
+    aggregateByDataRoot.set(payloadAttDataRootHex, messageToAggregate(message, validatorCommitteeIndices));
 
     return InsertOutcome.NewData;
   }
@@ -150,25 +150,49 @@ export class PayloadAttestationPool {
   }
 }
 
-function messageToAggregate(message: gloas.PayloadAttestationMessage, validatorCommitteeIndex: number): AggregateFast {
+function messageToAggregate(
+  message: gloas.PayloadAttestationMessage,
+  validatorCommitteeIndices: number[]
+): AggregateFast {
+  const aggregationBits = BitArray.fromBitLen(PTC_SIZE);
+  for (const index of validatorCommitteeIndices) {
+    aggregationBits.set(index, true);
+  }
+  const sig = signatureFromBytesNoCheck(message.signature);
+  // The validator signed once but occupies `validatorCommitteeIndices.length` PTC positions.
+  // Verification aggregates the pubkey once per set bit, so the signature must be aggregated
+  // the same number of times for the BLS check to balance — same pattern as sync committee.
+  const signature =
+    validatorCommitteeIndices.length === 1
+      ? sig
+      : aggregateSignatures(new Array(validatorCommitteeIndices.length).fill(sig));
   return {
-    aggregationBits: BitArray.fromSingleBit(PTC_SIZE, validatorCommitteeIndex),
+    aggregationBits,
     data: message.data,
-    signature: signatureFromBytesNoCheck(message.signature),
+    signature,
   };
 }
 
 function aggregateMessageInto(
   message: gloas.PayloadAttestationMessage,
-  validatorCommitteeIndex: number,
+  validatorCommitteeIndices: number[],
   aggregate: AggregateFast
 ): InsertOutcome {
-  if (aggregate.aggregationBits.get(validatorCommitteeIndex) === true) {
+  // Gossip dedup via `seenPayloadAttesters` is keyed by (epoch, validatorIndex), so the same
+  // validator's message is never processed twice — all of its bits are set together or none.
+  // Checking the first index is sufficient.
+  if (aggregate.aggregationBits.get(validatorCommitteeIndices[0]) === true) {
     return InsertOutcome.AlreadyKnown;
   }
 
-  aggregate.aggregationBits.set(validatorCommitteeIndex, true);
-  aggregate.signature = aggregateSignatures([aggregate.signature, signatureFromBytesNoCheck(message.signature)]);
+  for (const index of validatorCommitteeIndices) {
+    aggregate.aggregationBits.set(index, true);
+  }
+  const sig = signatureFromBytesNoCheck(message.signature);
+  aggregate.signature = aggregateSignatures([
+    aggregate.signature,
+    ...new Array(validatorCommitteeIndices.length).fill(sig),
+  ]);
 
   return InsertOutcome.Aggregated;
 }

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -7,7 +7,7 @@ import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {SerializedCache} from "../../util/serializedCache.js";
 import {isDaOutOfRange} from "../blocks/blockInput/index.js";
-import {CreateFromBlockProps, PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
+import {CreateFromBidProps, CreateFromBlockProps, PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 import {ChainEvent, ChainEventEmitter} from "../emitter.js";
 
 export type {PayloadEnvelopeInputState} from "../blocks/payloadEnvelopeInput/index.js";
@@ -27,11 +27,7 @@ export type SeenPayloadEnvelopeInputModules = {
 /**
  * Cache for tracking PayloadEnvelopeInput instances, keyed by beacon block root.
  *
- * Created during block import when a block is processed. Two pruning paths:
- *   - `prepareNextSlot` calls `pruneBelow(headParentSlot)` every slot once the head we'll build
- *     on is known.
- *   - `onFinalized` calls `pruneBelow(finalizedSlot)` on every finalization for bulk cleanup.
- *
+ * Created whenever we have a block because it needs block bid.
  * Steady state (linear chain, healthy progression): the cache holds ~2 entries — the head
  * (parent for next-slot production) and its parent (proposer-boost-reorg fallback). It can
  * transiently hold more during forks, range-sync bursts, or when `prepareNextSlot` skips
@@ -123,6 +119,27 @@ export class SeenPayloadEnvelopeInput {
     return input;
   }
 
+  /**
+   * Used at chain initialization to seed the anchor block's PayloadEnvelopeInput from
+   * `state.latestExecutionPayloadBid`.
+   */
+  addFromBid(props: Omit<CreateFromBidProps, "daOutOfRange">): PayloadEnvelopeInput {
+    const existing = this.payloadInputs.get(props.blockRootHex);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const daOutOfRange = isDaOutOfRange(this.config, props.forkName, props.slot, this.clock.currentEpoch);
+    const input = PayloadEnvelopeInput.createFromBid({...props, daOutOfRange});
+    this.payloadInputs.set(props.blockRootHex, input);
+    this.metrics?.seenCache.payloadEnvelopeInput.created.inc();
+    this.logger?.verbose("SeenPayloadEnvelopeInput.addFromBid created new entry", {
+      slot: input.slot,
+      root: props.blockRootHex,
+      daOutOfRange,
+    });
+    return input;
+  }
+
   get(blockRootHex: RootHex): PayloadEnvelopeInput | undefined {
     return this.payloadInputs.get(blockRootHex);
   }

package/src/chain/validation/payloadAttestationMessage.ts

@@ -11,7 +11,7 @@ import {IBeaconChain} from "../index.js";
 
 export type PayloadAttestationValidationResult = {
   attDataRootHex: RootHex;
-  validatorCommitteeIndex: number;
+  validatorCommitteeIndices: number[];
 };
 
 export async function validateApiPayloadAttestationMessage(
@@ -80,9 +80,11 @@ async function validatePayloadAttestationMessage(
   // [REJECT] The message's validator index is within the payload committee in
   // `get_ptc(state, data.slot)`. The `state` is the head state corresponding to
   // processing the block up to the current slot as determined by the fork choice.
-  const validatorCommitteeIndex = state.getIndexInPayloadTimelinessCommittee(validatorIndex, data.slot);
+  // The validator may occupy multiple PTC positions because `compute_ptc` samples
+  // by effective balance — collect all of them so duplicate votes are counted.
+  const validatorCommitteeIndices = state.getIndicesInPayloadTimelinessCommittee(validatorIndex, data.slot);
 
-  if (validatorCommitteeIndex === -1) {
+  if (validatorCommitteeIndices.length === 0) {
     throw new PayloadAttestationError(GossipAction.REJECT, {
       code: PayloadAttestationErrorCode.INVALID_ATTESTER,
       attesterIndex: validatorIndex,
@@ -115,6 +117,6 @@ async function validatePayloadAttestationMessage(
 
   return {
     attDataRootHex: toRootHex(ssz.gloas.PayloadAttestationData.hashTreeRoot(data)),
-    validatorCommitteeIndex,
+    validatorCommitteeIndices,
   };
 }

package/src/metrics/metrics/lodestar.ts

@@ -3,6 +3,7 @@ import {NotReorgedReason} from "@lodestar/fork-choice";
 import {ArchiveStoreTask} from "../../chain/archiveStore/archiveStore.js";
 import {FrequencyStateArchiveStep} from "../../chain/archiveStore/strategies/frequencyStateArchiveStrategy.js";
 import {BlockInputSource} from "../../chain/blocks/blockInput/index.js";
+import {PayloadErrorCode} from "../../chain/blocks/importExecutionPayload.js";
 import {PayloadEnvelopeInputSource} from "../../chain/blocks/payloadEnvelopeInput/index.js";
 import {JobQueueItemType} from "../../chain/bls/index.js";
 import {AttestationErrorCode, BlockErrorCode} from "../../chain/errors/index.js";
@@ -890,6 +891,11 @@ export function createLodestarMetrics(
         labelNames: ["source"],
         buckets: [0.5, 1, 2, 4, 6, 12],
       }),
+      processPayloadErrors: register.gauge<{error: PayloadErrorCode | "NOT_PAYLOAD_ERROR"}>({
+        name: "lodestar_gossip_execution_payload_envelope_process_payload_errors",
+        help: "Count of errors, by error type, while processing execution payload envelopes",
+        labelNames: ["error"],
+      }),
     },
     // recovery in the case of specific blob rows required
     recoverBlobSidecars: {

package/src/network/interface.ts

@@ -78,6 +78,7 @@ export interface INetwork extends INetworkCorePublic {
   // ReqResp
   sendBeaconBlocksByRange(peerId: PeerIdStr, request: phase0.BeaconBlocksByRangeRequest): Promise<SignedBeaconBlock[]>;
   sendBeaconBlocksByRoot(peerId: PeerIdStr, request: BeaconBlocksByRootRequest): Promise<SignedBeaconBlock[]>;
+  sendBeaconBlocksByHead(peerId: PeerIdStr, request: fulu.BeaconBlocksByHeadRequest): Promise<SignedBeaconBlock[]>;
   sendBlobSidecarsByRange(peerId: PeerIdStr, request: deneb.BlobSidecarsByRangeRequest): Promise<deneb.BlobSidecar[]>;
   sendBlobSidecarsByRoot(peerId: PeerIdStr, request: BlobSidecarsByRootRequest): Promise<deneb.BlobSidecar[]>;
   sendDataColumnSidecarsByRange(

package/src/network/network.ts

@@ -578,6 +578,18 @@ export class Network implements INetwork {
     );
   }
 
+  async sendBeaconBlocksByHead(
+    peerId: PeerIdStr,
+    request: fulu.BeaconBlocksByHeadRequest
+  ): Promise<SignedBeaconBlock[]> {
+    return collectMaxResponseTypedWithBytes(
+      this.sendReqRespRequest(peerId, ReqRespMethod.BeaconBlocksByHead, [Version.V1], request),
+      Math.min(request.count, this.config.MAX_REQUEST_BLOCKS_DENEB),
+      responseSszTypeByMethod[ReqRespMethod.BeaconBlocksByHead],
+      this.chain.serializedCache
+    );
+  }
+
   async sendLightClientBootstrap(peerId: PeerIdStr, request: Root): Promise<LightClientBootstrap> {
     return collectExactOneTyped(
       this.sendReqRespRequest(peerId, ReqRespMethod.LightClientBootstrap, [Version.V1], request),

package/src/network/processor/gossipHandlers.ts

@@ -35,6 +35,7 @@ import {
   IBlockInput,
   isBlockInputColumns,
 } from "../../chain/blocks/blockInput/index.js";
+import {PayloadError, PayloadErrorCode} from "../../chain/blocks/importExecutionPayload.js";
 import {PayloadEnvelopeInput, PayloadEnvelopeInputSource} from "../../chain/blocks/payloadEnvelopeInput/index.js";
 import {BlobSidecarValidation} from "../../chain/blocks/types.js";
 import {ChainEvent} from "../../chain/emitter.js";
@@ -1148,7 +1149,40 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       });
 
       chain.processExecutionPayload(payloadInput, {validSignature: true}).catch((e) => {
-        chain.logger.debug("Error processing execution payload from gossip", {slot, root: blockRootHex}, e as Error);
+        // Adjust verbosity based on error type
+        let logLevel: LogLevel;
+
+        if (e instanceof PayloadError) {
+          switch (e.type.code) {
+            // BLOCK_NOT_IN_FORK_CHOICE should not happen, validateGossipExecutionPayloadEnvelope above
+            // already verified the block is in fork choice
+            case PayloadErrorCode.BLOCK_NOT_IN_FORK_CHOICE:
+            case PayloadErrorCode.MISS_BLOCK_STATE:
+            case PayloadErrorCode.EXECUTION_ENGINE_ERROR:
+              // Errors might indicate an issue with our node or the connected EL client
+              logLevel = LogLevel.error;
+              break;
+            // INVALID_SIGNATURE should not happen, signature is verified during gossip validation
+            case PayloadErrorCode.INVALID_SIGNATURE:
+            case PayloadErrorCode.ENVELOPE_VERIFICATION_ERROR:
+            case PayloadErrorCode.EXECUTION_ENGINE_INVALID:
+              core.reportPeer(peerIdStr, PeerAction.LowToleranceError, "BadGossipPayload");
+              // Misbehaving peer, but could highlight an issue in another client
+              logLevel = LogLevel.warn;
+              break;
+          }
+        } else {
+          // Any unexpected error
+          logLevel = LogLevel.error;
+        }
+        metrics?.gossipExecutionPayloadEnvelope.processPayloadErrors.inc({
+          error: e instanceof PayloadError ? e.type.code : "NOT_PAYLOAD_ERROR",
+        });
+        chain.logger[logLevel](
+          "Error processing execution payload from gossip",
+          {slot, peer: peerIdStr, root: blockRootHex},
+          e as Error
+        );
       });
     },
     [GossipType.payload_attestation_message]: async ({
@@ -1163,7 +1197,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         const insertOutcome = chain.payloadAttestationPool.add(
           payloadAttestationMessage,
           validationResult.attDataRootHex,
-          validationResult.validatorCommitteeIndex
+          validationResult.validatorCommitteeIndices
         );
         metrics?.opPool.payloadAttestationPool.gossipInsertOutcome.inc({insertOutcome});
       } catch (e) {
@@ -1171,7 +1205,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       }
       chain.forkChoice.notifyPtcMessages(
         toRootHex(payloadAttestationMessage.data.beaconBlockRoot),
-        [validationResult.validatorCommitteeIndex],
+        validationResult.validatorCommitteeIndices,
         payloadAttestationMessage.data.payloadPresent
       );
     },

package/src/network/reqresp/ReqRespBeaconNode.ts

@@ -286,6 +286,7 @@ export class ReqRespBeaconNode extends ReqResp {
         // instead of protocol version. This is not easily fixable with our current architecture.
         // See https://github.com/ChainSafe/lodestar/pull/8168 for more details.
         [protocols.StatusV2(fork, this.config), this.onStatus.bind(this)],
+        [protocols.BeaconBlocksByHead(fork, this.config), this.getHandler(ReqRespMethod.BeaconBlocksByHead)],
         [
           protocols.DataColumnSidecarsByRoot(fork, this.config),
           this.getHandler(ReqRespMethod.DataColumnSidecarsByRoot),

package/src/network/reqresp/handlers/beaconBlocksByHead.ts

@@ -0,0 +1,91 @@
+import {PeerId} from "@libp2p/interface";
+import {BeaconConfig} from "@lodestar/config";
+import {ForkName, GENESIS_EPOCH, GENESIS_SLOT, isForkPostDeneb} from "@lodestar/params";
+import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
+import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
+import {fulu} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
+import {IBeaconChain} from "../../../chain/index.js";
+import {getParentRootFromSignedBeaconBlockSerialized} from "../../../util/sszBytes.js";
+import {prettyPrintPeerId} from "../../util.js";
+
+// See https://github.com/ethereum/consensus-specs/pull/5181
+export async function* onBeaconBlocksByHead(
+  request: fulu.BeaconBlocksByHeadRequest,
+  chain: IBeaconChain,
+  peerId: PeerId,
+  peerClient: string
+): AsyncIterable<ResponseOutgoing> {
+  const currentFork = chain.config.getForkName(chain.clock.currentSlot);
+  const {beaconRoot, count} = validateBeaconBlocksByHeadRequest(currentFork, chain.config, request);
+
+  const requestedRootHex = toRootHex(beaconRoot);
+  let blockRootHex = requestedRootHex;
+  const minimumRequestEpoch = Math.max(
+    GENESIS_EPOCH,
+    chain.clock.currentEpoch - chain.config.MIN_EPOCHS_FOR_BLOCK_REQUESTS
+  );
+  const minimumRequestSlot = computeStartSlotAtEpoch(minimumRequestEpoch);
+
+  for (let blocksSent = 0; blocksSent < count; blocksSent++) {
+    const blockBytes = await chain.getSerializedBlockByRoot(blockRootHex);
+    if (!blockBytes) {
+      if (blocksSent === 0) {
+        throw new ResponseError(RespStatus.RESOURCE_UNAVAILABLE, `Unknown block root ${requestedRootHex}`);
+      }
+      return;
+    }
+
+    if (blockBytes.slot < minimumRequestSlot) {
+      if (blocksSent === 0) {
+        chain.logger.verbose("Peer requested unavailable block for BeaconBlocksByHead", {
+          peer: prettyPrintPeerId(peerId),
+          client: peerClient,
+          requestedRoot: requestedRootHex,
+          slot: blockBytes.slot,
+          minimumRequestSlot,
+        });
+      }
+      return;
+    }
+
+    yield {
+      data: blockBytes.block,
+      boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(blockBytes.slot)),
+    };
+
+    if (blockBytes.slot === GENESIS_SLOT) {
+      return;
+    }
+
+    const parentRootHex = getParentRootFromSignedBeaconBlockSerialized(blockBytes.block);
+    if (parentRootHex === null) {
+      throw new ResponseError(
+        RespStatus.SERVER_ERROR,
+        `Invalid block bytes for root ${blockRootHex} slot ${blockBytes.slot}`
+      );
+    }
+    blockRootHex = parentRootHex;
+  }
+}
+
+export function validateBeaconBlocksByHeadRequest(
+  fork: ForkName,
+  config: BeaconConfig,
+  request: fulu.BeaconBlocksByHeadRequest
+): fulu.BeaconBlocksByHeadRequest {
+  const {beaconRoot} = request;
+  let {count} = request;
+
+  if (count < 1) {
+    throw new ResponseError(RespStatus.INVALID_REQUEST, "count < 1");
+  }
+
+  const maxRequestBlocks = isForkPostDeneb(fork) ? config.MAX_REQUEST_BLOCKS_DENEB : config.MAX_REQUEST_BLOCKS;
+
+  if (count > maxRequestBlocks) {
+    count = maxRequestBlocks;
+  }
+
+  return {beaconRoot, count};
+}

package/src/network/reqresp/handlers/index.ts

@@ -9,6 +9,7 @@ import {
   ExecutionPayloadEnvelopesByRootRequestType,
 } from "../../../util/types.js";
 import {GetReqRespHandlerFn, ReqRespMethod} from "../types.js";
+import {onBeaconBlocksByHead} from "./beaconBlocksByHead.js";
 import {onBeaconBlocksByRange} from "./beaconBlocksByRange.js";
 import {onBeaconBlocksByRoot} from "./beaconBlocksByRoot.js";
 import {onBlobSidecarsByRange} from "./blobSidecarsByRange.js";
@@ -47,6 +48,10 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
       const body = BeaconBlocksByRootRequestType(fork, chain.config).deserialize(req.data);
       return onBeaconBlocksByRoot(body, chain);
     },
+    [ReqRespMethod.BeaconBlocksByHead]: (req, peerId, peerClient) => {
+      const body = ssz.fulu.BeaconBlocksByHeadRequest.deserialize(req.data);
+      return onBeaconBlocksByHead(body, chain, peerId, peerClient);
+    },
     [ReqRespMethod.BlobSidecarsByRoot]: (req) => {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
       const body = BlobSidecarsByRootRequestType(fork, chain.config).deserialize(req.data);

package/src/network/reqresp/interface.ts

@@ -33,7 +33,7 @@ export enum RespStatus {
    */
   SERVER_ERROR = 2,
   /**
-   * The responder does not have requested resource.  The response payload adheres to the ErrorMessage schema (described below). Note: This response code is only valid as a response to BlocksByRange
+   * The responder does not have requested resource. The response payload adheres to the ErrorMessage schema.
    */
   RESOURCE_UNAVAILABLE = 3,
   /**

package/src/network/reqresp/protocols.ts

@@ -70,6 +70,12 @@ export const BeaconBlocksByRootV2 = toProtocol({
   contextBytesType: ContextBytesType.ForkDigest,
 });
 
+export const BeaconBlocksByHead = toProtocol({
+  method: ReqRespMethod.BeaconBlocksByHead,
+  version: Version.V1,
+  contextBytesType: ContextBytesType.ForkDigest,
+});
+
 export const BlobSidecarsByRange = toProtocol({
   method: ReqRespMethod.BlobSidecarsByRange,
   version: Version.V1,