@lodestar/beacon-node 1.44.0-dev.b66425f010 → 1.44.0-dev.be2850b7bb

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.44.0-dev.b66425f010",
+  "version": "1.44.0-dev.be2850b7bb",
   "type": "module",
   "exports": {
     ".": {
@@ -116,7 +116,6 @@
     "@chainsafe/libp2p-quic": "^2.0.1",
     "@chainsafe/persistent-merkle-tree": "^1.2.5",
     "@chainsafe/prometheus-gc-stats": "^1.0.0",
-    "@chainsafe/pubkey-index-map": "^3.0.0",
     "@chainsafe/snappy-wasm": "^0.5.0",
     "@chainsafe/ssz": "^1.4.0",
     "@chainsafe/threads": "^1.11.3",
@@ -135,17 +134,17 @@
     "@libp2p/peer-id": "^6.0.4",
     "@libp2p/prometheus-metrics": "^5.0.14",
     "@libp2p/tcp": "^11.0.13",
-    "@lodestar/api": "^1.44.0-dev.b66425f010",
-    "@lodestar/config": "^1.44.0-dev.b66425f010",
-    "@lodestar/db": "^1.44.0-dev.b66425f010",
-    "@lodestar/fork-choice": "^1.44.0-dev.b66425f010",
-    "@lodestar/logger": "^1.44.0-dev.b66425f010",
-    "@lodestar/params": "^1.44.0-dev.b66425f010",
-    "@lodestar/reqresp": "^1.44.0-dev.b66425f010",
-    "@lodestar/state-transition": "^1.44.0-dev.b66425f010",
-    "@lodestar/types": "^1.44.0-dev.b66425f010",
-    "@lodestar/utils": "^1.44.0-dev.b66425f010",
-    "@lodestar/validator": "^1.44.0-dev.b66425f010",
+    "@lodestar/api": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/config": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/db": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/fork-choice": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/logger": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/params": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/reqresp": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/state-transition": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/types": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/utils": "^1.44.0-dev.be2850b7bb",
+    "@lodestar/validator": "^1.44.0-dev.be2850b7bb",
     "@multiformats/multiaddr": "^13.0.1",
     "datastore-core": "^11.0.2",
     "datastore-fs": "^11.0.2",
@@ -168,13 +167,12 @@
     "@libp2p/interface-internal": "^3.0.13",
     "@libp2p/logger": "^6.2.2",
     "@libp2p/utils": "^7.0.13",
-    "@lodestar/spec-test-util": "^1.44.0-dev.b66425f010",
+    "@lodestar/spec-test-util": "^1.44.0-dev.be2850b7bb",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
     "dotenv": "^16.4.5",
     "js-yaml": "^4.1.0",
-    "rewiremock": "^3.14.5",
     "rimraf": "^4.4.1",
     "snappy": "^7.2.2",
     "snappyjs": "^0.7.0",
@@ -186,5 +184,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "c84f14f44f67178eb4ce92119200ba2a18db23ef"
+  "gitHead": "6006ab1cca25bb4d64302db69d3864ef42d6b23e"
 }

package/src/api/impl/config/constants.ts

@@ -53,6 +53,7 @@ import {
   VERSIONED_HASH_VERSION_KZG,
   WEIGHT_DENOMINATOR,
   WITHDRAWAL_REQUEST_TYPE,
+  ZERO_HASH_HEX,
 } from "@lodestar/params";
 
 /**
@@ -69,6 +70,7 @@ export const specConstants = {
   DEPOSIT_CONTRACT_TREE_DEPTH,
   JUSTIFICATION_BITS_LENGTH,
   ENDIANNESS: "little",
+  EMPTY_BLOCK_HASH: ZERO_HASH_HEX,
   // ## Withdrawal prefixes
   BLS_WITHDRAWAL_PREFIX: toHexByte(BLS_WITHDRAWAL_PREFIX),
   ETH1_ADDRESS_WITHDRAWAL_PREFIX: toHexByte(ETH1_ADDRESS_WITHDRAWAL_PREFIX),

package/src/api/impl/debug/index.ts

@@ -1,7 +1,8 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
-import {ExecutionStatus} from "@lodestar/fork-choice";
+import {ExecutionStatus, PayloadStatus} from "@lodestar/fork-choice";
 import {ForkPostDeneb, ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
+import {computeTimeAtSlot} from "@lodestar/state-transition";
 import {BeaconState, DataColumnSidecar, DataColumnSidecars, type SignedBeaconBlock, sszTypesFor} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {getBlobKzgCommitments} from "../../../util/dataColumns.js";
@@ -12,6 +13,29 @@ import {getStateResponseWithRegen} from "../beacon/state/utils.js";
 import {ApiModules} from "../types.js";
 import {assertUniqueItems} from "../utils.js";
 
+function toForkChoiceValidity(status: ExecutionStatus): "valid" | "invalid" | "optimistic" {
+  switch (status) {
+    case ExecutionStatus.Valid:
+      return "valid";
+    case ExecutionStatus.Invalid:
+      return "invalid";
+    case ExecutionStatus.Syncing:
+    case ExecutionStatus.PreMerge:
+      return "optimistic";
+  }
+}
+
+function toPayloadStatusName(status: PayloadStatus): "pending" | "empty" | "full" {
+  switch (status) {
+    case PayloadStatus.PENDING:
+      return "pending";
+    case PayloadStatus.EMPTY:
+      return "empty";
+    case PayloadStatus.FULL:
+      return "full";
+  }
+}
+
 export function getDebugApi({
   chain,
   config,
@@ -40,23 +64,60 @@ export function getDebugApi({
             justifiedEpoch: node.justifiedEpoch,
             finalizedEpoch: node.finalizedEpoch,
             weight: node.weight,
-            validity: (() => {
-              switch (node.executionStatus) {
-                case ExecutionStatus.Valid:
-                  return "valid";
-                case ExecutionStatus.Invalid:
-                  return "invalid";
-                case ExecutionStatus.Syncing:
-                case ExecutionStatus.PreMerge:
-                  return "optimistic";
-              }
-            })(),
+            validity: toForkChoiceValidity(node.executionStatus),
             executionBlockHash: node.executionPayloadBlockHash ?? ZERO_HASH_HEX,
           })),
         },
       };
     },
 
+    async getDebugForkChoiceV2() {
+      const {forkChoice} = chain;
+      return {
+        data: {
+          justifiedCheckpoint: forkChoice.getJustifiedCheckpoint(),
+          finalizedCheckpoint: forkChoice.getFinalizedCheckpoint(),
+          forkChoiceNodes: forkChoice.getAllNodes().map((node) => {
+            // Payload-specific fields apply only to a revealed Gloas payload = the FULL variant of a
+            // Gloas block
+            const ptc = node.payloadStatus === PayloadStatus.FULL ? forkChoice.getPTCVoteCounts(node.blockRoot) : null;
+            return {
+              payloadStatus: toPayloadStatusName(node.payloadStatus),
+              slot: node.slot,
+              blockRoot: node.blockRoot,
+              parentRoot: node.parentRoot,
+              weight: node.weight,
+              validity: toForkChoiceValidity(node.executionStatus),
+              executionBlockHash: node.executionPayloadBlockHash ?? ZERO_HASH_HEX,
+              extraData: {
+                executionOptimistic: isOptimisticBlock(node),
+                timestamp: computeTimeAtSlot(config, node.slot, chain.genesisTime),
+                target: node.targetRoot,
+                justifiedEpoch: node.justifiedEpoch,
+                finalizedEpoch: node.finalizedEpoch,
+                unrealizedJustifiedEpoch: node.unrealizedJustifiedEpoch,
+                unrealizedFinalizedEpoch: node.unrealizedFinalizedEpoch,
+                payloadAttesterCount: ptc?.attesterCount ?? null,
+                payloadAvailabilityYesCount: ptc?.payloadPresentCount ?? null,
+                payloadDataAvailabilityYesCount: ptc?.dataAvailableCount ?? null,
+                gasLimit:
+                  node.payloadStatus === PayloadStatus.FULL && "executionPayloadGasLimit" in node
+                    ? node.executionPayloadGasLimit
+                    : null,
+              },
+            };
+          }),
+          extraData: {
+            unrealizedJustifiedCheckpoint: forkChoice.getUnrealizedJustifiedCheckpoint(),
+            unrealizedFinalizedCheckpoint: forkChoice.getUnrealizedFinalizedCheckpoint(),
+            proposerBoostRoot: forkChoice.getProposerBoostRoot(),
+            previousProposerBoostRoot: forkChoice.getPreviousProposerBoostRoot(),
+            headRoot: forkChoice.getHeadRoot(),
+          },
+        },
+      };
+    },
+
     async getProtoArrayNodes() {
       const nodes = chain.forkChoice.getAllNodes().map((node) => ({
         // if node has executionPayloadNumber, it will overwrite the below default

package/src/api/impl/validator/index.ts

@@ -927,11 +927,9 @@ export function getValidatorApi(
       // TODO GLOAS: respect builderSelection (MaxProfit, BuilderAlways, ExecutionAlways, etc.) to let
       // the user control bid source preferences and value comparison. Also add external builder api
       // support when it is implemented.
-      const builderBid = chain.executionPayloadBidPool.getBestBid(
-        slot,
-        parentBlock.executionPayloadBlockHash,
-        parentBlockRootHex
-      );
+      const isBuildingOnFull = chain.forkChoice.shouldBuildOnFull(parentBlock, slot);
+      const bidParentBlockHash = isBuildingOnFull ? parentBlock.executionPayloadBlockHash : parentBlock.parentBlockHash;
+      const builderBid = chain.executionPayloadBidPool.getBestBid(slot, bidParentBlockHash, parentBlockRootHex);
 
       const logCtx = {
         slot,
@@ -1112,23 +1110,34 @@ export function getValidatorApi(
       notWhileSyncing();
       await waitForSlot(slot);
 
-      const block = chain.forkChoice.getCanonicalBlockClosestLteSlot(slot);
+      const block = chain.forkChoice.getCanonicalBlockAtSlot(slot);
       if (!block) {
-        throw new ApiError(404, `No canonical block found at or before slot=${slot}`);
+        // No block is seen at slot. Return 404 so vc can skip casting payload attestation.
+        throw new ApiError(404, `No canonical block found at slot=${slot}`);
       }
 
-      const blockIsForSlot = block.slot === slot;
       const payloadInput = chain.seenPayloadEnvelopeInputCache.get(block.blockRoot);
       // Spec: set payload_present only if the envelope was seen before get_payload_due_ms()
       // into the slot. Use the envelope's own arrival time (getPayloadEnvelopeSource), not
       // the input's creation time.
       const payloadDueSec = config.getPayloadDueMs() / 1000;
-      const payloadPresent =
-        blockIsForSlot &&
-        payloadInput !== undefined &&
-        payloadInput.hasPayloadEnvelope() &&
-        chain.clock.secFromSlot(slot, payloadInput.getPayloadEnvelopeSource().seenTimestampSec) < payloadDueSec;
-      const blobDataAvailable = blockIsForSlot && (payloadInput?.hasAllData() ?? false);
+      const payloadSeenSec =
+        payloadInput?.hasPayloadEnvelope() === true
+          ? chain.clock.secFromSlot(slot, payloadInput.getPayloadEnvelopeSource().seenTimestampSec)
+          : null;
+      const payloadPresent = payloadSeenSec !== null && payloadSeenSec < payloadDueSec;
+      const blobDataAvailable = payloadInput?.hasAllData() === true;
+
+      logger.debug("Produced payload attestation data", {
+        slot,
+        blockRoot: block.blockRoot,
+        blockSlot: block.slot,
+        payloadPresent,
+        blobDataAvailable,
+        hasPayloadInput: payloadInput !== undefined,
+        payloadSeenSec,
+        payloadDueSec,
+      });
 
       return {
         data: {

package/src/chain/archiveStore/archiveStore.ts

@@ -30,7 +30,6 @@ export enum ArchiveStoreTask {
   PruneHistory = "prune_history",
   OnFinalizedCheckpoint = "on_finalized_checkpoint",
   MaybeArchiveState = "maybe_archive_state",
-  RegenPruneOnFinalized = "regen_prune_on_finalized",
   ForkchoicePrune = "forkchoice_prune",
   UpdateBackfillRange = "update_backfill_range",
 }
@@ -229,10 +228,6 @@ export class ArchiveStore {
       await this.statesArchiverStrategy.maybeArchiveState(finalized, this.metrics);
       timer?.({source: ArchiveStoreTask.MaybeArchiveState});
 
-      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
-      this.chain.regen.pruneOnFinalized(finalizedEpoch);
-      timer?.({source: ArchiveStoreTask.RegenPruneOnFinalized});
-
       // tasks rely on extended fork choice
       timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       const prunedBlocks = this.chain.forkChoice.prune(finalized.rootHex);

package/src/chain/errors/payloadAttestation.ts

@@ -5,6 +5,7 @@ export enum PayloadAttestationErrorCode {
   NOT_CURRENT_SLOT = "PAYLOAD_ATTESTATION_ERROR_NOT_CURRENT_SLOT",
   PAYLOAD_ATTESTATION_ALREADY_KNOWN = "PAYLOAD_ATTESTATION_ERROR_PAYLOAD_ATTESTATION_ALREADY_KNOWN",
   UNKNOWN_BLOCK_ROOT = "PAYLOAD_ATTESTATION_ERROR_UNKNOWN_BLOCK_ROOT",
+  INVALID_BLOCK_SLOT = "PAYLOAD_ATTESTATION_ERROR_INVALID_BLOCK_SLOT",
   INVALID_BLOCK = "PAYLOAD_ATTESTATION_ERROR_INVALID_BLOCK",
   INVALID_ATTESTER = "PAYLOAD_ATTESTATION_ERROR_INVALID_ATTESTER",
   INVALID_SIGNATURE = "PAYLOAD_ATTESTATION_ERROR_INVALID_SIGNATURE",
@@ -18,6 +19,7 @@ export type PayloadAttestationErrorType =
       blockRoot: RootHex;
     }
   | {code: PayloadAttestationErrorCode.UNKNOWN_BLOCK_ROOT; blockRoot: RootHex}
+  | {code: PayloadAttestationErrorCode.INVALID_BLOCK_SLOT; blockRoot: RootHex; blockSlot: Slot; slot: Slot}
   | {code: PayloadAttestationErrorCode.INVALID_BLOCK; blockRoot: RootHex}
   | {code: PayloadAttestationErrorCode.INVALID_ATTESTER; attesterIndex: ValidatorIndex}
   | {code: PayloadAttestationErrorCode.INVALID_SIGNATURE};

package/src/chain/prepareNextSlot.ts

@@ -170,7 +170,7 @@ export class PrepareNextSlotScheduler {
         let stateAfterParentPayload: IBeaconStateViewBellatrix = updatedPrepareState;
         if (isStatePostGloas(updatedPrepareState)) {
           // Spec: should_build_on_full(store, head) — see produceBlockBody.ts for context.
-          if (this.chain.forkChoice.shouldBuildOnFull(updatedHead)) {
+          if (this.chain.forkChoice.shouldBuildOnFull(updatedHead, prepareSlot)) {
             parentBlockHash = updatedPrepareState.latestExecutionPayloadBid.blockHash;
             // Skip applying parent payload unless we're proposing the next slot or have to emit payload_attributes events
             if (feeRecipient !== undefined || this.chain.opts.emitPayloadAttributes === true) {

package/src/chain/produceBlock/produceBlockBody.ts

@@ -276,9 +276,9 @@ export async function produceBlockBody<T extends BlockType>(
     // Apply parent payload once here as it's reused by EL prep and voluntary exit filtering below
     let stateAfterParentPayload: IBeaconStateViewBellatrix = currentState;
     // Spec: should_build_on_full(store, head). `parentBlock` is the proposer's head
-    // (set by chain.getProposerHead(slot)). Returns false when the PTC majority
-    // signalled the blob data is not available, forcing a build on EMPTY (reorg).
-    const isBuildingOnFull = this.forkChoice.shouldBuildOnFull(parentBlock);
+    // (set by chain.getProposerHead(slot)). Returns false when the PTC majority signalled
+    // the blob data is not available or the payload was not timely, forcing a build on EMPTY (reorg).
+    const isBuildingOnFull = this.forkChoice.shouldBuildOnFull(parentBlock, blockSlot);
     if (isBuildingOnFull) {
       parentBlockHash = currentState.latestExecutionPayloadBid.blockHash;
       parentExecutionRequests = await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot);

package/src/chain/regen/interface.ts

@@ -47,7 +47,6 @@ export interface IStateRegenerator extends IStateRegeneratorInternal {
   getCheckpointStateSync(cp: CheckpointHex): IBeaconStateView | null;
   getClosestHeadState(head: ProtoBlock): IBeaconStateView | null;
   pruneOnCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void;
-  pruneOnFinalized(finalizedEpoch: Epoch): void;
   processState(blockRootHex: RootHex, postState: IBeaconStateView): void;
   addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView): void;
   updateHeadState(newHead: ProtoBlock, maybeHeadState: IBeaconStateView): void;

package/src/chain/regen/queued.ts

@@ -143,11 +143,6 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     this.blockStateCache.prune(headStateRoot);
   }
 
-  pruneOnFinalized(finalizedEpoch: number): void {
-    this.checkpointStateCache.pruneFinalized(finalizedEpoch);
-    this.blockStateCache.deleteAllBeforeEpoch(finalizedEpoch);
-  }
-
   processState(blockRootHex: RootHex, postState: IBeaconStateView): void {
     this.blockStateCache.add(postState);
     this.checkpointStateCache.processState(blockRootHex, postState).catch((e) => {

package/src/chain/stateCache/fifoBlockStateCache.ts

@@ -167,12 +167,6 @@ export class FIFOBlockStateCache implements BlockStateCache {
     }
   }
 
-  /**
-   * No need for this implementation
-   * This is only to conform to the old api
-   */
-  deleteAllBeforeEpoch(): void {}
-
   /**
    * ONLY FOR DEBUGGING PURPOSES. For lodestar debug API.
    */

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -414,11 +414,12 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
 
   /**
    * Prune all checkpoint states before the provided finalized epoch.
+   * Driven sequentially from processState() so it never interleaves with persist.
    */
-  pruneFinalized(finalizedEpoch: Epoch): void {
+  private async pruneFinalized(finalizedEpoch: Epoch): Promise<void> {
     for (const epoch of this.epochIndex.keys()) {
       if (epoch < finalizedEpoch) {
-        this.deleteAllEpochItems(epoch).catch((e) =>
+        await this.deleteAllEpochItems(epoch).catch((e) =>
           this.logger.debug("Error delete all epoch items", {epoch, finalizedEpoch}, e as Error)
         );
       }
@@ -476,6 +477,9 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    * As of Mar 2024, it takes <=350ms to persist a holesky state on fast server
    */
   async processState(blockRootHex: RootHex, state: IBeaconStateView): Promise<number> {
+    // prune finalized in the same flow so a finalized cp state is pruned, never persisted
+    await this.pruneFinalized(state.finalizedCheckpoint.epoch);
+
     let persistCount = 0;
     // it's important to sort the epochs in ascending order, in case of big reorg we always want to keep the most recent checkpoint states
     const sortedEpochs = Array.from(this.epochIndex.keys()).sort((a, b) => a - b);

package/src/chain/stateCache/types.ts

@@ -30,7 +30,6 @@ export interface BlockStateCache {
   clear(): void;
   size: number;
   prune(headStateRootHex: RootHex): void;
-  deleteAllBeforeEpoch(finalizedEpoch: Epoch): void;
   dumpSummary(): routes.lodestar.StateCacheItem[];
   /** Expose beacon states stored in cache. Use with caution */
   getStates(): IterableIterator<IBeaconStateView>;
@@ -67,7 +66,6 @@ export interface CheckpointStateCache {
   getOrReloadLatest(rootHex: RootHex, maxEpoch: Epoch): Promise<IBeaconStateView | null>;
   updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null;
   prune(finalizedEpoch: Epoch, justifiedEpoch: Epoch): void;
-  pruneFinalized(finalizedEpoch: Epoch): void;
   processState(blockRootHex: RootHex, state: IBeaconStateView): Promise<number>;
   clear(): void;
   dumpSummary(): routes.lodestar.StateCacheItem[];

package/src/chain/validation/executionPayloadBid.ts

@@ -35,10 +35,6 @@ async function validateExecutionPayloadBid(
   const bid = signedExecutionPayloadBid.message;
   const parentBlockRootHex = toRootHex(bid.parentBlockRoot);
   const parentBlockHashHex = toRootHex(bid.parentBlockHash);
-  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipExecutionPayloadBid);
-  if (!isStatePostGloas(state)) {
-    throw new Error(`Expected gloas+ state for execution payload bid validation, got fork=${state.forkName}`);
-  }
 
   // [IGNORE] `bid.slot` is the current slot or the next slot.
   const currentSlot = chain.clock.currentSlot;
@@ -111,9 +107,31 @@ async function validateExecutionPayloadBid(
     });
   }
 
+  // Use the bid's parent branch state for builder checks
+  const state = await chain.regen
+    .getBlockSlotState(parentBlock, bid.slot, {dontTransferCache: true}, RegenCaller.validateGossipExecutionPayloadBid)
+    .catch(() => {
+      throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
+        code: ExecutionPayloadBidErrorCode.UNKNOWN_BLOCK_ROOT,
+        parentBlockRoot: parentBlockRootHex,
+      });
+    });
+
+  if (!isStatePostGloas(state)) {
+    throw new Error(`Expected gloas+ state for execution payload bid validation, got fork=${state.forkName}`);
+  }
+
   // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
   // `is_active_builder(state, bid.builder_index)` returns `True`.
-  const builder = state.getBuilder(bid.builderIndex);
+  let builder: gloas.Builder;
+  try {
+    builder = state.getBuilder(bid.builderIndex);
+  } catch {
+    throw new ExecutionPayloadBidError(GossipAction.REJECT, {
+      code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE,
+      builderIndex: bid.builderIndex,
+    });
+  }
   if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
     throw new ExecutionPayloadBidError(GossipAction.REJECT, {
       code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE,

package/src/chain/validation/payloadAttestationMessage.ts

@@ -70,6 +70,17 @@ async function validatePayloadAttestationMessage(
     });
   }
 
+  // [IGNORE] The block referenced by `data.beacon_block_root` is at slot `data.slot`,
+  // i.e. the block has `block.slot == data.slot`.
+  if (block.slot !== data.slot) {
+    throw new PayloadAttestationError(GossipAction.IGNORE, {
+      code: PayloadAttestationErrorCode.INVALID_BLOCK_SLOT,
+      blockRoot: toRootHex(data.beaconBlockRoot),
+      blockSlot: block.slot,
+      slot: data.slot,
+    });
+  }
+
   // [REJECT] The message's block `data.beacon_block_root` passes validation.
   // TODO GLOAS: implement this. Technically if we cannot get proto block from fork choice,
   // it is possible that the block didn't pass the validation

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

@@ -1,6 +1,6 @@
 import {PeerId} from "@libp2p/interface";
 import {BeaconConfig} from "@lodestar/config";
-import {GENESIS_SLOT, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
+import {GENESIS_SLOT, isForkPostDeneb} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {deneb, phase0} from "@lodestar/types";
@@ -29,13 +29,20 @@ export async function* onBeaconBlocksByRange(
   // starts above it to avoid duplicate yields. See archiveBlocks.ts for the migration logic.
   const archiveMaxSlot = finalizedSlot;
 
-  const forkName = chain.config.getForkName(startSlot);
-  if (isForkPostFulu(forkName) && startSlot < chain.earliestAvailableSlot) {
-    chain.logger.verbose("Peer did not respect earliestAvailableSlot for BeaconBlocksByRange", {
+  // endSlot is exclusive, so highest served slot is endSlot - 1.
+  // Throw only when the entire requested range is below earliestAvailableSlot.
+  if (endSlot - 1 < chain.earliestAvailableSlot) {
+    chain.logger.verbose("Peer requested range before earliestAvailableSlot for BeaconBlocksByRange", {
       peer: prettyPrintPeerId(peerId),
       client: peerClient,
+      startSlot,
+      count,
+      earliestAvailableSlot: chain.earliestAvailableSlot,
     });
-    return;
+    throw new ResponseError(
+      RespStatus.RESOURCE_UNAVAILABLE,
+      `Requested range is before earliestAvailableSlot startSlot=${startSlot} count=${count} earliestAvailableSlot=${chain.earliestAvailableSlot}`
+    );
   }
 
   // Finalized range of blocks

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

@@ -1,5 +1,6 @@
 import {PeerId} from "@libp2p/interface";
 import {ChainConfig} from "@lodestar/config";
+import {PayloadStatus} from "@lodestar/fork-choice";
 import {ForkSeq, GENESIS_SLOT} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
@@ -33,12 +34,20 @@ export async function* onDataColumnSidecarsByRange(
     return;
   }
 
-  if (startSlot < chain.earliestAvailableSlot) {
-    chain.logger.verbose("Peer did not respect earliestAvailableSlot for DataColumnSidecarsByRange", {
+  // endSlot is exclusive, so highest served slot is endSlot - 1.
+  // Throw only when the entire requested range is below earliestAvailableSlot.
+  if (endSlot - 1 < chain.earliestAvailableSlot) {
+    chain.logger.verbose("Peer requested range before earliestAvailableSlot for DataColumnSidecarsByRange", {
       peer: prettyPrintPeerId(peerId),
       client: peerClient,
+      startSlot,
+      count,
+      earliestAvailableSlot: chain.earliestAvailableSlot,
     });
-    return;
+    throw new ResponseError(
+      RespStatus.RESOURCE_UNAVAILABLE,
+      `Requested range is before earliestAvailableSlot startSlot=${startSlot} count=${count} earliestAvailableSlot=${chain.earliestAvailableSlot}`
+    );
   }
 
   const finalized = db.dataColumnSidecarArchive;
@@ -104,6 +113,11 @@ export async function* onDataColumnSidecarsByRange(
 
       // Must include only columns in the range requested
       if (block.slot > archiveMaxSlot && block.slot >= startSlot && block.slot < endSlot) {
+        // Post-gloas, columns exist only for FULL blocks (pre-gloas blocks are always FULL)
+        if (block.payloadStatus !== PayloadStatus.FULL) {
+          continue;
+        }
+
         // Note: Here the forkChoice head may change due to a re-org, so the headChain reflects the canonical chain
         // at the time of the start of the request. Spec is clear the chain of columns must be consistent, but on
         // re-org there's no need to abort the request

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

@@ -30,7 +30,7 @@ export async function* onDataColumnSidecarsByRoot(
     const {blockRoot, columns: requestedColumns} = dataColumnsByRootIdentifier;
     const availableColumns = validateRequestedDataColumns(chain, requestedColumns);
     if (availableColumns.length === 0) {
-      return;
+      continue;
     }
 
     const blockRootHex = toRootHex(blockRoot);

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

@@ -1,3 +1,4 @@
+import {PeerId} from "@libp2p/interface";
 import {ChainConfig} from "@lodestar/config";
 import {PayloadStatus} from "@lodestar/fork-choice";
 import {GENESIS_SLOT} from "@lodestar/params";
@@ -6,23 +7,38 @@ import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {gloas} from "@lodestar/types";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
+import {prettyPrintPeerId} from "../../util.js";
 
 export async function* onExecutionPayloadEnvelopesByRange(
   request: gloas.ExecutionPayloadEnvelopesByRangeRequest,
   chain: IBeaconChain,
-  db: IBeaconDb
+  db: IBeaconDb,
+  peerId: PeerId,
+  peerClient: string
 ): AsyncIterable<ResponseOutgoing> {
   const {startSlot, count} = validateExecutionPayloadEnvelopesByRangeRequest(chain.config, request);
   const endSlot = startSlot + count;
 
-  if (startSlot < chain.earliestAvailableSlot) {
-    return;
+  // endSlot is exclusive, so highest served slot is endSlot - 1.
+  // Throw only when the entire requested range is below earliestAvailableSlot.
+  if (endSlot - 1 < chain.earliestAvailableSlot) {
+    chain.logger.verbose("Peer requested range before earliestAvailableSlot for ExecutionPayloadEnvelopesByRange", {
+      peer: prettyPrintPeerId(peerId),
+      client: peerClient,
+      startSlot,
+      count,
+      earliestAvailableSlot: chain.earliestAvailableSlot,
+    });
+    throw new ResponseError(
+      RespStatus.RESOURCE_UNAVAILABLE,
+      `Requested range is before earliestAvailableSlot startSlot=${startSlot} count=${count} earliestAvailableSlot=${chain.earliestAvailableSlot}`
+    );
   }
 
   const finalized = db.executionPayloadEnvelopeArchive;
-  const finalizedSlot = chain.forkChoice.getFinalizedCheckpointSlot();
-  // The current finalized block's envelope is still in the hot db; archive migration happens
-  // in the next finalization run (see migrateExecutionPayloadEnvelopesFromHotToColdDb).
+  // Use the finalized block's actual slot as the checkpoint epoch-boundary slot may be skipped
+  const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
+  // The finalized block's envelope stays in the hot db until the next finalization run
   const archiveMaxSlot = finalizedSlot - 1;
 
   // Finalized range of envelopes

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

@@ -1,14 +1,18 @@
+import {PeerId} from "@libp2p/interface";
 import {ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
 import {ExecutionPayloadEnvelopesByRootRequest} from "../../../util/types.js";
+import {prettyPrintPeerId} from "../../util.js";
 
 export async function* onExecutionPayloadEnvelopesByRoot(
   requestBody: ExecutionPayloadEnvelopesByRootRequest,
   chain: IBeaconChain,
-  db: IBeaconDb
+  db: IBeaconDb,
+  peerId: PeerId,
+  peerClient: string
 ): AsyncIterable<ResponseOutgoing> {
   // The gloas req/resp spec uses MIN_EPOCHS_FOR_BLOCK_REQUESTS to define the minimum range peers MUST serve.
   // Archival nodes may still serve older retained payloads to allow genesis sync.
@@ -20,6 +24,14 @@ export async function* onExecutionPayloadEnvelopesByRoot(
     const slot = block ? block.slot : await db.blockArchive.getSlotByRoot(root);
 
     if (slot === null) {
+      chain.logger.debug(
+        "Cannot serve ExecutionPayloadEnvelopesByRoot: block root not in fork choice or block archive",
+        {
+          root: rootHex,
+          peer: prettyPrintPeerId(peerId),
+          client: peerClient,
+        }
+      );
       continue;
     }
 
@@ -29,6 +41,13 @@ export async function* onExecutionPayloadEnvelopesByRoot(
         data: envelopeBytes,
         boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(slot)),
       };
+    } else {
+      chain.logger.debug("Cannot serve ExecutionPayloadEnvelopesByRoot: envelope not found", {
+        slot,
+        root: rootHex,
+        peer: prettyPrintPeerId(peerId),
+        client: peerClient,
+      });
     }
   }
 }