@lodestar/beacon-node 1.43.0-dev.9c8becae00 → 1.43.0-dev.9f5db5b9c7

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

@@ -1,29 +1,126 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ssz} from "@lodestar/types";
+import {ProtoBlock} from "@lodestar/fork-choice";
+import {Slot, isGloasBeaconBlock, ssz} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
 import {BlockError, BlockErrorCode} from "../../errors/index.js";
 import {IBlockInput} from "../blockInput/types.js";
+import {PayloadEnvelopeInput} from "../payloadEnvelopeInput/payloadEnvelopeInput.js";
+
+export type OrphanedPayloadEnvelope = {
+  slot: Slot;
+  payloadEnvelopeInput: PayloadEnvelopeInput;
+};
+
+export type ChainSegmentResult = {warnings: OrphanedPayloadEnvelope[] | null};
 
 /**
- * Assert this chain segment of blocks is linear with slot numbers and hashes
+ * 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
+ * - For gloas: verifies bid.parentBlockHash matches the tracked execution hash; if not, the
+ *   previous FULL envelope is treated as orphaned (segment continues as if previous slot was EMPTY)
+ * - If an envelope exists for this slot: verifies it references this block's root
+ * - Advances the tracked execution hash (FULL if envelope present, EMPTY if not)
  */
+export function assertLinearChainSegment(
+  config: ChainForkConfig,
+  blocks: IBlockInput[],
+  payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
+  parentBlock: ProtoBlock
+): ChainSegmentResult {
+  const warnings: OrphanedPayloadEnvelope[] = [];
 
-export function assertLinearChainSegment(config: ChainForkConfig, blocks: IBlockInput[]): void {
-  for (let i = 0; i < blocks.length - 1; i++) {
+  // Track the expected execution payload block hash through the segment.
+  // 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;
+  // 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();
+  }
+  // Track the execution hash before the last FULL advancement so we can recover
+  // if the next block reveals that envelope was orphaned.
+  let prevExecHash: string | null = currentExecHash;
+  // The slot whose envelope last advanced currentExecHash (for warning context).
+  let lastFullSlot: Slot | null = null;
+
+  for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i].getBlock();
-    const child = blocks[i + 1].getBlock();
-    // If this block has a child in this chain segment, ensure that its parent root matches
-    // the root of this block.
-    if (
-      !ssz.Root.equals(
-        config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message),
-        child.message.parentRoot
-      )
-    ) {
-      throw new BlockError(block, {code: BlockErrorCode.NON_LINEAR_PARENT_ROOTS});
+    const slot = block.message.slot;
+
+    if (i > 0) {
+      const prevBlock = blocks[i - 1].getBlock();
+      // Ensure parent root matches the previous block's root
+      if (
+        !ssz.Root.equals(
+          config.getForkTypes(prevBlock.message.slot).BeaconBlock.hashTreeRoot(prevBlock.message),
+          block.message.parentRoot
+        )
+      ) {
+        throw new BlockError(block, {code: BlockErrorCode.NON_LINEAR_PARENT_ROOTS});
+      }
+      // Ensure slots are strictly increasing
+      if (slot <= prevBlock.message.slot) {
+        throw new BlockError(block, {code: BlockErrorCode.NON_LINEAR_SLOTS});
+      }
     }
-    // Ensure that the slots are strictly increasing throughout the chain segment.
-    if (child.message.slot <= block.message.slot) {
-      throw new BlockError(block, {code: BlockErrorCode.NON_LINEAR_SLOTS});
+
+    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});
+          }
+        }
+        currentExecHash = prevExecHash;
+      }
+
+      const payloadInput = payloadEnvelopes?.get(slot) ?? null;
+      const payloadEnvelope = payloadInput?.hasPayloadEnvelope() ? payloadInput.getPayloadEnvelope() : null;
+      if (payloadEnvelope !== null) {
+        // Verify the envelope references this block's root
+        const blockRoot = toRootHex(config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block.message));
+        const envelopeBlockRoot = toRootHex(payloadEnvelope.message.beaconBlockRoot);
+        if (blockRoot !== envelopeBlockRoot) {
+          throw new BlockError(block, {
+            code: BlockErrorCode.ENVELOPE_BLOCK_ROOT_MISMATCH,
+            envelopeBlockRoot,
+            blockRoot,
+          });
+        }
+
+        // FULL variant: save state before advancing, then advance
+        prevExecHash = currentExecHash;
+        lastFullSlot = slot;
+        currentExecHash = toRootHex(payloadEnvelope.message.payload.blockHash);
+      }
+      // EMPTY variant: currentExecHash unchanged
     }
   }
+
+  return {warnings: warnings.length > 0 ? warnings : null};
 }

package/src/chain/blocks/verifyBlock.ts

@@ -1,12 +1,14 @@
 import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
-import {ForkName, isForkPostFulu} from "@lodestar/params";
+import {ForkName, ForkSeq, isForkPostFulu} from "@lodestar/params";
 import {DataAvailabilityStatus, IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
-import {IndexedAttestation, deneb} from "@lodestar/types";
+import {IndexedAttestation, Slot, deneb} from "@lodestar/types";
+import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import type {BeaconChain} from "../chain.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {BlockProcessOpts} from "../options.js";
 import {RegenCaller} from "../regen/index.js";
 import {DAType, IBlockInput} from "./blockInput/index.js";
+import {PayloadEnvelopeInput} from "./payloadEnvelopeInput/payloadEnvelopeInput.js";
 import {ImportBlockOpts} from "./types.js";
 import {DENEB_BLOWFISH_BANNER} from "./utils/blowfishBanner.js";
 import {ELECTRA_GIRAFFE_BANNER} from "./utils/giraffeBanner.js";
@@ -16,6 +18,7 @@ import {verifyBlocksDataAvailability} from "./verifyBlocksDataAvailability.js";
 import {SegmentExecStatus, verifyBlocksExecutionPayload} from "./verifyBlocksExecutionPayloads.js";
 import {verifyBlocksSignatures} from "./verifyBlocksSignatures.js";
 import {verifyBlocksStateTransitionOnly} from "./verifyBlocksStateTransitionOnly.js";
+import {verifyPayloadsDataAvailability} from "./verifyPayloadsDataAvailability.js";
 
 /**
  * Verifies 1 or more blocks are fully valid; from a linear sequence of blocks.
@@ -32,12 +35,14 @@ export async function verifyBlocksInEpoch(
   this: BeaconChain,
   parentBlock: ProtoBlock,
   blockInputs: IBlockInput[],
+  payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
   opts: BlockProcessOpts & ImportBlockOpts
 ): Promise<{
   postStates: IBeaconStateView[];
   proposerBalanceDeltas: number[];
   segmentExecStatus: SegmentExecStatus;
-  dataAvailabilityStatuses: DataAvailabilityStatus[];
+  blockDAStatuses: DataAvailabilityStatus[];
+  payloadDAStatuses: Map<Slot, DataAvailabilityStatus>;
   indexedAttestationsByBlock: IndexedAttestation[][];
 }> {
   const blocks = blockInputs.map((blockInput) => blockInput.getBlock());
@@ -110,17 +115,61 @@ export async function verifyBlocksInEpoch(
       });
     }
 
+    // Pick the data-availability source by fork:
+    // - Pre-Gloas: blob/Fulu-column data lives in IBlockInput → verifyBlocksDataAvailability.
+    // - Post-Gloas: verifyPayloadsDataAvailability (payload-level DA, keyed by slot).
+    const daAvailabilityPromise: Promise<{
+      blockDAStatuses: DataAvailabilityStatus[];
+      payloadDAStatuses: Map<Slot, DataAvailabilityStatus>;
+      availableTime: number;
+    }> =
+      fork >= ForkSeq.gloas
+        ? (async () => {
+            // Validate DA for ALL payloads in the Map, not just those paired with blockInputs.
+            // A checkpoint-sync batch may include a payload for a slot whose block was filtered
+            // out of relevantBlocks (e.g., the anchor at the finalized slot); that payload still
+            // needs DA validation so it can be imported in processBlocks.
+            const payloadInputsForDa: PayloadEnvelopeInput[] =
+              payloadEnvelopes !== null ? Array.from(payloadEnvelopes.values()) : [];
+            const {dataAvailabilityStatuses, availableTime} = await verifyPayloadsDataAvailability(
+              payloadInputsForDa,
+              abortController.signal
+            );
+
+            const payloadDAStatuses = new Map<Slot, DataAvailabilityStatus>();
+            for (let i = 0; i < payloadInputsForDa.length; i++) {
+              payloadDAStatuses.set(payloadInputsForDa[i].slot, dataAvailabilityStatuses[i]);
+            }
+            return {
+              // post-gloas, DataAvailabilityStatus is NotRequired for forkChoice.onBlock() ProtoBlock
+              blockDAStatuses: blockInputs.map(() => DataAvailabilityStatus.NotRequired),
+              payloadDAStatuses,
+              availableTime,
+            };
+          })()
+        : (async () => {
+            const {dataAvailabilityStatuses, availableTime} = await verifyBlocksDataAvailability(
+              blockInputs,
+              abortController.signal
+            );
+            return {
+              blockDAStatuses: dataAvailabilityStatuses,
+              payloadDAStatuses: new Map<Slot, DataAvailabilityStatus>(),
+              availableTime,
+            };
+          })();
+
     // batch all I/O operations to reduce overhead
     const [
       segmentExecStatus,
-      {dataAvailabilityStatuses, availableTime},
+      {blockDAStatuses, payloadDAStatuses, availableTime},
       {postStates, proposerBalanceDeltas, verifyStateTime},
       {verifySignaturesTime},
     ] = await Promise.all([
       verifyExecutionPayloadsPromise,
 
-      // data availability for the blobs
-      verifyBlocksDataAvailability(blockInputs, abortController.signal),
+      // data availability (fork-specific; see daAvailabilityPromise above)
+      daAvailabilityPromise,
 
       // Run state transition only
       // TODO: Ensure it yields to allow flushing to workers and engine API
@@ -149,6 +198,9 @@ export async function verifyBlocksInEpoch(
             opts
           )
         : Promise.resolve({verifySignaturesTime: Date.now()}),
+
+      // TODO GLOAS: can verify payload signatures in batch too
+      // maybe chain with the above verifyBlocksSignatures()
     ]);
 
     if (opts.verifyOnly !== true) {
@@ -200,7 +252,9 @@ export async function verifyBlocksInEpoch(
         blockInputs.length === 1 &&
         // gossip blocks have seenTimestampSec
         opts.seenTimestampSec !== undefined &&
+        // PreData (pre-deneb) and NoData (gloas) carry no blob data on the block — skip metric
         blockInputs[0].type !== DAType.PreData &&
+        blockInputs[0].type !== DAType.NoData &&
         executionStatuses[0] === ExecutionStatus.Valid
       ) {
         // Find the max time when the block was actually verified
@@ -209,8 +263,8 @@ export async function verifyBlocksInEpoch(
         this.metrics?.gossipBlock.receivedToFullyVerifiedTime.observe(recvTofullyVerifedTime);
 
         const verifiedToBlobsAvailabiltyTime = Math.max(availableTime - fullyVerifiedTime, 0) / 1000;
-        const block = blockInputs[0].getBlock() as deneb.SignedBeaconBlock;
-        const numBlobs = block.message.body.blobKzgCommitments.length;
+        const block = blockInputs[0].getBlock();
+        const numBlobs = getBlobKzgCommitments(blockInputs[0].forkName, block as deneb.SignedBeaconBlock).length;
 
         this.metrics?.gossipBlock.verifiedToBlobsAvailabiltyTime.observe({numBlobs}, verifiedToBlobsAvailabiltyTime);
         this.logger.verbose("Verified blockInput fully with blobs availability", {
@@ -229,7 +283,14 @@ export async function verifyBlocksInEpoch(
       );
     }
 
-    return {postStates, dataAvailabilityStatuses, proposerBalanceDeltas, segmentExecStatus, indexedAttestationsByBlock};
+    return {
+      postStates,
+      blockDAStatuses,
+      payloadDAStatuses,
+      proposerBalanceDeltas,
+      segmentExecStatus,
+      indexedAttestationsByBlock,
+    };
   } finally {
     abortController.abort();
   }

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -46,8 +46,7 @@ type VerifyBlockExecutionResponse =
   | VerifyExecutionErrorResponse
   | {executionStatus: ExecutionStatus.Valid; lvhResponse: LVHValidResponse; execError: null}
   | {executionStatus: ExecutionStatus.Syncing; lvhResponse?: LVHValidResponse; execError: null}
-  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null}
-  | {executionStatus: ExecutionStatus.PayloadSeparated; lvhResponse: undefined; execError: null};
+  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null};
 
 /**
  * Verifies 1 or more execution payloads from a linear sequence of blocks.
@@ -145,9 +144,10 @@ export async function verifyBlockExecutionPayload(
 ): Promise<VerifyBlockExecutionResponse> {
   const block = blockInput.getBlock();
 
-  // Gloas block doesn't have execution payload. Return right away
+  // Gloas block doesn't have execution payload. Return Syncing as a placeholder; the actual
+  // status for gloas PENDING/EMPTY is derived from parent's chain in importBlock.
   if (isBlockInputNoData(blockInput)) {
-    return {executionStatus: ExecutionStatus.PayloadSeparated, lvhResponse: undefined, execError: null};
+    return {executionStatus: ExecutionStatus.Syncing, lvhResponse: undefined, execError: null};
   }
 
   /** Not null if execution is enabled */
@@ -198,6 +198,7 @@ export async function verifyBlockExecutionPayload(
         executionStatus,
         latestValidExecHash: execResult.latestValidHash,
         invalidateFromParentBlockRoot: blockInput.parentRootHex,
+        invalidateFromParentBlockHash: toRootHex(executionPayloadEnabled.parentHash),
       };
       const execError = new BlockError(block, {
         code: BlockErrorCode.EXECUTION_ENGINE_ERROR,
@@ -281,6 +282,7 @@ function getSegmentErrorResponse(
         executionStatus: ExecutionStatus.Invalid,
         latestValidExecHash: lvhResponse.latestValidExecHash,
         invalidateFromParentBlockRoot: parentBlock.blockRoot,
+        invalidateFromParentBlockHash: parentBlock.executionPayloadBlockHash,
       };
     }
   }

package/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -7,6 +7,7 @@ import {IClock} from "../../util/clock.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {IChainOptions} from "../options.js";
 import {IBlockInput} from "./blockInput/types.js";
+import {PayloadEnvelopeInput} from "./payloadEnvelopeInput/payloadEnvelopeInput.js";
 import {ImportBlockOpts} from "./types.js";
 
 /**
@@ -30,6 +31,7 @@ export function verifyBlocksSanityChecks(
     blacklistedBlocks: Map<RootHex, Slot | null>;
   },
   blocks: IBlockInput[],
+  payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
   opts: ImportBlockOpts
 ): {
   relevantBlocks: IBlockInput[];
@@ -90,15 +92,32 @@ export function verifyBlocksSanityChecks(
     } else {
       // When importing a block segment, only the first NON-IGNORED block must be known to the fork-choice.
       const parentRoot = toRootHex(block.message.parentRoot);
-      parentBlock = isGloasBeaconBlock(block.message)
-        ? chain.forkChoice.getBlockHexAndBlockHash(
-            parentRoot,
-            toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash)
-          )
-        : chain.forkChoice.getBlockHexDefaultStatus(parentRoot);
-      if (!parentBlock) {
+      const parentBlockDefaultStatus = chain.forkChoice.getBlockHexDefaultStatus(parentRoot);
+      if (!parentBlockDefaultStatus) {
         throw new BlockError(block, {code: BlockErrorCode.PARENT_UNKNOWN, parentRoot});
       }
+
+      parentBlock = parentBlockDefaultStatus;
+      if (isGloasBeaconBlock(block.message)) {
+        const parentBlockHash = toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash);
+        const parentBlockWithPayload = chain.forkChoice.getBlockHexAndBlockHash(parentRoot, parentBlockHash);
+        if (!parentBlockWithPayload) {
+          // Checkpoint sync: parent's FULL variant may not be in fork-choice yet because the
+          // anchor block is initialized with PENDING+EMPTY only. The parent's payload arrives
+          // in the same batch via payloadEnvelopes and will be imported by processBlocks. If
+          // a matching payload is in the Map, accept the parent as known.
+          const parentPayloadInput = payloadEnvelopes?.get(parentBlockDefaultStatus.slot);
+          if (parentPayloadInput?.getBlockHashHex() !== parentBlockHash) {
+            throw new BlockError(block, {
+              code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+              parentRoot,
+              parentBlockHash,
+            });
+          }
+        } else {
+          parentBlock = parentBlockWithPayload;
+        }
+      }
       // Parent is known to the fork-choice
       parentBlockSlot = parentBlock.slot;
     }

package/src/chain/blocks/verifyExecutionPayloadEnvelope.ts

@@ -0,0 +1,134 @@
+import {BeaconConfig} from "@lodestar/config";
+import {
+  type IBeaconStateViewGloas,
+  type PubkeyCache,
+  computeTimeAtSlot,
+  getExecutionPayloadEnvelopeSignatureSet,
+} from "@lodestar/state-transition";
+import {gloas, ssz} from "@lodestar/types";
+import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
+import {IBlsVerifier} from "../bls/index.js";
+
+export type VerifyExecutionPayloadEnvelopeOpts = {
+  verifyExecutionRequestsRoot?: boolean;
+};
+
+/**
+ * Verify execution payload envelope fields against the post-block state.
+ *
+ * Signature verification and the execution engine call (`verify_and_notify_new_payload`) are
+ * performed outside this function, see `verifyExecutionPayloadEnvelopeSignature` and
+ * `importExecutionPayload` which run both in parallel with this check.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/fork-choice.md#new-verify_execution_payload_envelope
+ */
+export function verifyExecutionPayloadEnvelope(
+  config: BeaconConfig,
+  state: IBeaconStateViewGloas,
+  envelope: gloas.ExecutionPayloadEnvelope,
+  opts?: VerifyExecutionPayloadEnvelopeOpts
+): void {
+  const {verifyExecutionRequestsRoot = true} = opts ?? {};
+  const payload = envelope.payload;
+
+  // Verify consistency with the beacon block.
+  // Compute header root on a clone of latestBlockHeader to avoid mutating state.
+  const headerValue = ssz.phase0.BeaconBlockHeader.clone(state.latestBlockHeader);
+  if (byteArrayEquals(headerValue.stateRoot, ssz.Root.defaultValue())) {
+    headerValue.stateRoot = state.hashTreeRoot();
+  }
+  const headerRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(headerValue);
+  if (!byteArrayEquals(envelope.beaconBlockRoot, headerRoot)) {
+    throw new Error(
+      `Envelope's block is not the latest block header envelope=${toRootHex(envelope.beaconBlockRoot)} latestBlockHeader=${toRootHex(headerRoot)}`
+    );
+  }
+  if (!byteArrayEquals(envelope.parentBeaconBlockRoot, state.latestBlockHeader.parentRoot)) {
+    throw new Error(
+      `Envelope's parent_beacon_block_root mismatch envelope=${toRootHex(envelope.parentBeaconBlockRoot)} state=${toRootHex(state.latestBlockHeader.parentRoot)}`
+    );
+  }
+
+  // Verify consistency with the committed bid
+  const bid = state.latestExecutionPayloadBid;
+  if (envelope.builderIndex !== bid.builderIndex) {
+    throw new Error(
+      `Builder index mismatch between envelope and committed bid envelope=${envelope.builderIndex} bid=${bid.builderIndex}`
+    );
+  }
+  if (!byteArrayEquals(bid.prevRandao, payload.prevRandao)) {
+    throw new Error(
+      `Prev randao mismatch between bid and payload bid=${toHex(bid.prevRandao)} payload=${toHex(payload.prevRandao)}`
+    );
+  }
+  if (Number(bid.gasLimit) !== payload.gasLimit) {
+    throw new Error(
+      `Gas limit mismatch between payload and bid payload=${payload.gasLimit} bid=${Number(bid.gasLimit)}`
+    );
+  }
+  if (!byteArrayEquals(bid.blockHash, payload.blockHash)) {
+    throw new Error(
+      `Block hash mismatch between payload and bid payload=${toRootHex(payload.blockHash)} bid=${toRootHex(bid.blockHash)}`
+    );
+  }
+  // Verify execution_requests_root matches bid commitment.
+  // Can be skipped if already verified during gossip validation.
+  if (verifyExecutionRequestsRoot) {
+    const requestsRoot = ssz.electra.ExecutionRequests.hashTreeRoot(envelope.executionRequests);
+    if (!byteArrayEquals(requestsRoot, bid.executionRequestsRoot)) {
+      throw new Error(
+        `Execution requests root mismatch envelope=${toRootHex(requestsRoot)} bid=${toRootHex(bid.executionRequestsRoot)}`
+      );
+    }
+  }
+
+  // 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}`);
+  }
+  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);
+  if (payload.timestamp !== expectedTimestamp) {
+    throw new Error(
+      `Timestamp mismatch between payload and state payload=${payload.timestamp} state=${expectedTimestamp}`
+    );
+  }
+
+  // Verify consistency with expected withdrawals
+  const payloadWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(payload.withdrawals);
+  const expectedWithdrawalsRoot = ssz.capella.Withdrawals.hashTreeRoot(state.payloadExpectedWithdrawals);
+  if (!byteArrayEquals(payloadWithdrawalsRoot, expectedWithdrawalsRoot)) {
+    throw new Error(
+      `Withdrawals mismatch between payload and expected payload=${toRootHex(payloadWithdrawalsRoot)} expected=${toRootHex(expectedWithdrawalsRoot)}`
+    );
+  }
+
+  // Execution engine verification (verify_and_notify_new_payload) is done externally by the caller
+}
+
+/**
+ * Verify the BLS signature of an execution payload envelope.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/fork-choice.md#new-verify_execution_payload_envelope_signature
+ */
+export async function verifyExecutionPayloadEnvelopeSignature(
+  config: BeaconConfig,
+  state: IBeaconStateViewGloas,
+  pubkeyCache: PubkeyCache,
+  signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
+  proposerIndex: number,
+  bls: IBlsVerifier
+): Promise<boolean> {
+  const signatureSet = getExecutionPayloadEnvelopeSignatureSet(
+    config,
+    pubkeyCache,
+    state,
+    signedEnvelope,
+    proposerIndex
+  );
+  return bls.verifySignatureSets([signatureSet]);
+}

package/src/chain/blocks/verifyPayloadsDataAvailability.ts

@@ -28,11 +28,14 @@ export async function verifyPayloadsDataAvailability(
   await Promise.all(promises);
 
   const availableTime = Math.max(0, Math.max(...payloadInputs.map((payloadInput) => payloadInput.getTimeComplete())));
-  const dataAvailabilityStatuses: DataAvailabilityStatus[] = payloadInputs.map((payloadInput) =>
-    payloadInput.getBlobKzgCommitments().length === 0
+  const dataAvailabilityStatuses: DataAvailabilityStatus[] = payloadInputs.map((payloadInput) => {
+    if (payloadInput.daOutOfRange) {
+      return DataAvailabilityStatus.OutOfRange;
+    }
+    return payloadInput.getBlobKzgCommitments().length === 0
       ? DataAvailabilityStatus.NotRequired
-      : DataAvailabilityStatus.Available
-  );
+      : DataAvailabilityStatus.Available;
+  });
 
   return {dataAvailabilityStatuses, availableTime};
 }

package/src/chain/blocks/writePayloadEnvelopeInputToDb.ts

@@ -5,7 +5,7 @@ import {writeDataColumnsToDb} from "./writeBlockInputToDb.js";
 /**
  * Persists payload envelope data to DB. This operation must be eventually completed if a payload is imported.
  *
- * TODO GLOAS: Persist envelope metadata (stateRoot, executionRequests, builderIndex, etc.) without the full
+ * TODO GLOAS: Persist envelope metadata (executionRequests, builderIndex, etc.) without the full
  * execution payload body — only keep the blockHash reference. The EL already stores the payload.
  * See https://github.com/ChainSafe/lodestar/issues/5671
  */
@@ -33,23 +33,14 @@ export async function persistPayloadEnvelopeInput(
   this: BeaconChain,
   payloadInput: PayloadEnvelopeInput
 ): Promise<void> {
-  await writePayloadEnvelopeInputToDb
-    .call(this, payloadInput)
-    .catch((e) => {
-      this.logger.error(
-        "Error persisting payload envelope in hot db",
-        {
-          slot: payloadInput.slot,
-          root: payloadInput.blockRootHex,
-        },
-        e
-      );
-    })
-    .finally(() => {
-      this.seenPayloadEnvelopeInputCache.prune(payloadInput.blockRootHex);
-      this.logger.debug("Pruned payload envelope input", {
+  await writePayloadEnvelopeInputToDb.call(this, payloadInput).catch((e) => {
+    this.logger.error(
+      "Error persisting payload envelope in hot db",
+      {
         slot: payloadInput.slot,
         root: payloadInput.blockRootHex,
-      });
-    });
+      },
+      e
+    );
+  });
 }