@lodestar/beacon-node 1.43.0-dev.ade910fc78 → 1.43.0-dev.b05ea98d04

package/src/chain/blocks/index.ts

@@ -1,4 +1,4 @@
-import {SignedBeaconBlock} from "@lodestar/types";
+import {SignedBeaconBlock, Slot} from "@lodestar/types";
 import {isErrorAborted, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {nextEventLoop} from "../../util/eventLoop.js";
@@ -8,6 +8,8 @@ import {BlockError, BlockErrorCode, isBlockErrorAborted} from "../errors/index.j
 import {BlockProcessOpts} from "../options.js";
 import {IBlockInput} from "./blockInput/types.js";
 import {importBlock} from "./importBlock.js";
+import {importExecutionPayload} from "./importExecutionPayload.js";
+import {PayloadEnvelopeInput} from "./payloadEnvelopeInput/payloadEnvelopeInput.js";
 import {FullyVerifiedBlock, ImportBlockOpts} from "./types.js";
 import {assertLinearChainSegment} from "./utils/chainSegment.js";
 import {verifyBlocksInEpoch} from "./verifyBlock.js";
@@ -21,20 +23,24 @@ const QUEUE_MAX_LENGTH = 256;
  * BlockProcessor processes block jobs in a queued fashion, one after the other.
  */
 export class BlockProcessor {
-  readonly jobQueue: JobItemQueue<[IBlockInput[], ImportBlockOpts], void>;
+  readonly jobQueue: JobItemQueue<[IBlockInput[], Map<Slot, PayloadEnvelopeInput> | null, ImportBlockOpts], void>;
 
   constructor(chain: BeaconChain, metrics: Metrics | null, opts: BlockProcessOpts, signal: AbortSignal) {
-    this.jobQueue = new JobItemQueue<[IBlockInput[], ImportBlockOpts], void>(
-      (job, importOpts) => {
-        return processBlocks.call(chain, job, {...opts, ...importOpts});
+    this.jobQueue = new JobItemQueue<[IBlockInput[], Map<Slot, PayloadEnvelopeInput> | null, ImportBlockOpts], void>(
+      (job, payloadEnvelopes, importOpts) => {
+        return processBlocks.call(chain, job, payloadEnvelopes, {...opts, ...importOpts});
       },
       {maxLength: QUEUE_MAX_LENGTH, noYieldIfOneItem: true, signal},
       metrics?.blockProcessorQueue ?? undefined
     );
   }
 
-  async processBlocksJob(job: IBlockInput[], opts: ImportBlockOpts = {}): Promise<void> {
-    await this.jobQueue.push(job, opts);
+  async processBlocksJob(
+    job: IBlockInput[],
+    payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
+    opts: ImportBlockOpts = {}
+  ): Promise<void> {
+    await this.jobQueue.push(job, payloadEnvelopes, opts);
   }
 }
 
@@ -51,18 +57,15 @@ export class BlockProcessor {
 export async function processBlocks(
   this: BeaconChain,
   blocks: IBlockInput[],
+  payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
   opts: BlockProcessOpts & ImportBlockOpts
 ): Promise<void> {
   if (blocks.length === 0) {
     return; // TODO: or throw?
   }
 
-  if (blocks.length > 1) {
-    assertLinearChainSegment(this.config, blocks);
-  }
-
   try {
-    const {relevantBlocks, parentSlots, parentBlock} = verifyBlocksSanityChecks(this, blocks, opts);
+    const {relevantBlocks, parentSlots, parentBlock} = verifyBlocksSanityChecks(this, blocks, payloadEnvelopes, opts);
 
     // No relevant blocks, skip verifyBlocksInEpoch()
     if (relevantBlocks.length === 0 || parentBlock === null) {
@@ -70,10 +73,31 @@ export async function processBlocks(
       return;
     }
 
+    const {warnings: orphanedPayloads} = assertLinearChainSegment(
+      this.config,
+      relevantBlocks,
+      payloadEnvelopes,
+      parentBlock
+    );
+    if (orphanedPayloads != null) {
+      for (const orphaned of orphanedPayloads) {
+        this.logger.debug("Orphaned payload envelope in chain segment", {
+          slot: orphaned.slot,
+          blockRoot: orphaned.payloadEnvelopeInput.blockRootHex,
+        });
+      }
+    }
+
     // Fully verify a block to be imported immediately after. Does not produce any side-effects besides adding intermediate
     // states in the state cache through regen.
-    const {postStates, dataAvailabilityStatuses, proposerBalanceDeltas, segmentExecStatus, indexedAttestationsByBlock} =
-      await verifyBlocksInEpoch.call(this, parentBlock, relevantBlocks, opts);
+    const {
+      postStates,
+      blockDAStatuses,
+      payloadDAStatuses,
+      proposerBalanceDeltas,
+      segmentExecStatus,
+      indexedAttestationsByBlock,
+    } = await verifyBlocksInEpoch.call(this, parentBlock, relevantBlocks, payloadEnvelopes, opts);
 
     // If segmentExecStatus has lvhForkchoice then, the entire segment should be invalid
     // and we need to further propagate
@@ -85,25 +109,51 @@ export async function processBlocks(
     }
 
     const {executionStatuses} = segmentExecStatus;
-    const fullyVerifiedBlocks = relevantBlocks.map(
-      (block, i): FullyVerifiedBlock => ({
+    const verifiedBlocksBySlot = new Map<Slot, FullyVerifiedBlock>();
+    for (let i = 0; i < relevantBlocks.length; i++) {
+      const block = relevantBlocks[i];
+      verifiedBlocksBySlot.set(block.getBlock().message.slot, {
         blockInput: block,
-        postBlockState: postStates[i],
-        postPayloadState: null,
+        postState: postStates[i],
         parentBlockSlot: parentSlots[i],
         executionStatus: executionStatuses[i],
         // start supporting optimistic syncing/processing
-        dataAvailabilityStatus: dataAvailabilityStatuses[i],
+        dataAvailabilityStatus: blockDAStatuses[i],
         proposerBalanceDelta: proposerBalanceDeltas[i],
         indexedAttestations: indexedAttestationsByBlock[i],
         // TODO: Make this param mandatory and capture in gossip
         seenTimestampSec: opts.seenTimestampSec ?? Math.floor(Date.now() / 1000),
-      })
-    );
+      });
+    }
+
+    // Iterate slots from the original `blocks` input (which spans the entire batch including
+    // slots filtered out of `relevantBlocks`). The first batch of a checkpoint sync may contain
+    // a payload at the anchor slot whose block is already in fork-choice (added by
+    // initializeForkChoice as PENDING+EMPTY) and therefore not in verifiedBlocksBySlot — the
+    // payload still needs to be imported here to populate the anchor's FULL variant so
+    // subsequent slots can find their parent payload.
+    const slots = Array.from(new Set(blocks.map((b) => b.getBlock().message.slot)));
+    for (const slot of slots) {
+      const fullyVerifiedBlock = verifiedBlocksBySlot.get(slot);
+      if (fullyVerifiedBlock !== undefined) {
+        // TODO: Consider batching importBlock too if it takes significant time
+        await importBlock.call(this, fullyVerifiedBlock, opts);
+      }
+
+      const payloadInput = payloadEnvelopes?.get(slot);
+      if (payloadInput?.hasPayloadEnvelope()) {
+        if (!payloadInput.isComplete()) {
+          // we validated DA before reaching this
+          throw new Error(`Payload envelope for slot ${slot} not complete after DA verification`);
+        }
+        // we already awaited DA in verifyBlocksInEpoch for this segment
+        const payloadDA = payloadDAStatuses.get(slot);
+        if (payloadDA === undefined) {
+          throw new Error(`Missing payload DA status for slot ${slot}`);
+        }
+        await importExecutionPayload.call(this, payloadInput, payloadDA, {validSignature: false});
+      }
 
-    for (const fullyVerifiedBlock of fullyVerifiedBlocks) {
-      // TODO: Consider batching importBlock too if it takes significant time
-      await importBlock.call(this, fullyVerifiedBlock, opts);
       await nextEventLoop();
     }
   } catch (e) {

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

@@ -64,6 +64,7 @@ export class PayloadEnvelopeInput {
   readonly proposerIndex: ValidatorIndex;
   readonly bid: gloas.ExecutionPayloadBid;
   readonly versionedHashes: VersionedHashes;
+  readonly daOutOfRange: boolean;
 
   private columnsCache = new Map<ColumnIndex, ColumnWithSource>();
 
@@ -73,6 +74,7 @@ export class PayloadEnvelopeInput {
   private timeCreatedSec: number;
 
   private readonly payloadEnvelopeDataPromise: PromiseParts<gloas.SignedExecutionPayloadEnvelope>;
+  private readonly allDataPromise: PromiseParts<gloas.DataColumnSidecar[]>;
   private readonly columnsDataPromise: PromiseParts<gloas.DataColumnSidecar[]>;
 
   state: PayloadEnvelopeInputState;
@@ -86,6 +88,7 @@ export class PayloadEnvelopeInput {
     sampledColumns: ColumnIndex[];
     custodyColumns: ColumnIndex[];
     timeCreatedSec: number;
+    daOutOfRange: boolean;
   }) {
     this.blockRootHex = props.blockRootHex;
     this.slot = props.slot;
@@ -96,15 +99,18 @@ export class PayloadEnvelopeInput {
     this.sampledColumns = props.sampledColumns;
     this.custodyColumns = props.custodyColumns;
     this.timeCreatedSec = props.timeCreatedSec;
+    this.daOutOfRange = props.daOutOfRange;
     this.payloadEnvelopeDataPromise = createPromise();
+    this.allDataPromise = createPromise();
     this.columnsDataPromise = createPromise();
 
     const noBlobs = props.bid.blobKzgCommitments.length === 0;
     const noSampledColumns = props.sampledColumns.length === 0;
-    const hasAllData = noBlobs || noSampledColumns;
+    const hasAllData = props.daOutOfRange || noBlobs || noSampledColumns;
 
     if (hasAllData) {
       this.state = {hasPayload: false, hasAllData: true, hasComputedAllData: true};
+      this.allDataPromise.resolve(this.getSampledColumns());
       this.columnsDataPromise.resolve(this.getSampledColumns());
     } else {
       this.state = {hasPayload: false, hasAllData: false, hasComputedAllData: false};
@@ -122,6 +128,7 @@ export class PayloadEnvelopeInput {
       sampledColumns: props.sampledColumns,
       custodyColumns: props.custodyColumns,
       timeCreatedSec: props.timeCreatedSec,
+      daOutOfRange: props.daOutOfRange,
     });
   }
 
@@ -149,6 +156,7 @@ export class PayloadEnvelopeInput {
       throw new Error("Payload envelope beacon_block_root mismatch");
     }
 
+    // TODO GLOAS: track source by metrics, maybe inside the seen cache
     const source: SourceMeta = {
       source: props.source,
       seenTimestampSec: props.seenTimestampSec,
@@ -203,6 +211,12 @@ export class PayloadEnvelopeInput {
       return true;
     }
 
+    // Resolve allDataPromise on the first transition to hasAllData (either sampled-complete or
+    // reconstruction-threshold branch). Guarded so it fires exactly once.
+    if (!this.state.hasAllData && hasAllData) {
+      this.allDataPromise.resolve(sampledColumns);
+    }
+
     if (hasComputedAllData) {
       this.columnsDataPromise.resolve(sampledColumns);
     }
@@ -297,8 +311,11 @@ export class PayloadEnvelopeInput {
     return this.state.hasAllData;
   }
 
+  /**
+   * Strictly checks missing sampled columns. Does NOT short-circuit on `state.hasAllData`.
+   */
   getMissingSampledColumnMeta(): MissingColumnMeta {
-    if (this.state.hasAllData) {
+    if (this.state.hasComputedAllData) {
       return {missing: [], versionedHashes: this.versionedHashes};
     }
 
@@ -315,6 +332,24 @@ export class PayloadEnvelopeInput {
     return this.state.hasComputedAllData;
   }
 
+  waitForAllData(timeout: number, signal?: AbortSignal): Promise<gloas.DataColumnSidecar[]> {
+    if (this.state.hasAllData) {
+      return Promise.resolve(this.getSampledColumns());
+    }
+    return withTimeout(() => this.allDataPromise.promise, timeout, signal);
+  }
+
+  async waitForEnvelopeAndAllData(timeout: number, signal?: AbortSignal): Promise<this> {
+    if (!this.state.hasPayload || !this.state.hasAllData) {
+      await withTimeout(
+        () => Promise.all([this.payloadEnvelopeDataPromise.promise, this.allDataPromise.promise]),
+        timeout,
+        signal
+      );
+    }
+    return this;
+  }
+
   waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<gloas.DataColumnSidecar[]> {
     if (this.state.hasComputedAllData) {
       return Promise.resolve(this.getSampledColumns());

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

@@ -27,6 +27,7 @@ export type CreateFromBlockProps = {
   sampledColumns: ColumnIndex[];
   custodyColumns: ColumnIndex[];
   timeCreatedSec: number;
+  daOutOfRange: boolean;
 };
 
 export type AddPayloadEnvelopeProps = SourceMeta & {

package/src/chain/blocks/payloadEnvelopeProcessor.ts

@@ -2,7 +2,7 @@ import {Metrics} from "../../metrics/metrics.js";
 import {JobItemQueue} from "../../util/queue/index.js";
 import type {BeaconChain} from "../chain.js";
 import {PayloadEnvelopeInput} from "../seenCache/seenPayloadEnvelopeInput.js";
-import {importExecutionPayload} from "./importExecutionPayload.js";
+import {processExecutionPayload} from "./importExecutionPayload.js";
 import {ImportPayloadOpts} from "./types.js";
 
 // TODO GLOAS: Set to be equal to DEFAULT_MAX_PENDING_UNFINALIZED_PAYLOAD_ENVELOPE_WRITES for now
@@ -16,6 +16,11 @@ enum PayloadEnvelopeImportStatus {
 
 /**
  * PayloadEnvelopeProcessor processes payload envelope jobs in a queued fashion, one after the other.
+ *
+ * Jobs are enqueued only on envelope arrival (gossip or API). The envelope may reach us before
+ * the sampled data columns; importExecutionPayload awaits `verifyPayloadsDataAvailability`
+ * internally, so a queued job can pend for up to `PAYLOAD_DATA_AVAILABILITY_TIMEOUT` while
+ * waiting for columns. Duplicate triggers for the same payloadInput are deduped via `importStatus`.
  */
 export class PayloadEnvelopeProcessor {
   readonly jobQueue: JobItemQueue<[PayloadEnvelopeInput, ImportPayloadOpts], void>;
@@ -25,7 +30,7 @@ export class PayloadEnvelopeProcessor {
     this.jobQueue = new JobItemQueue<[PayloadEnvelopeInput, ImportPayloadOpts], void>(
       (payloadInput, opts) => {
         this.importStatus.set(payloadInput, PayloadEnvelopeImportStatus.importing);
-        return importExecutionPayload.call(chain, payloadInput, opts);
+        return processExecutionPayload.call(chain, payloadInput, signal, opts);
       },
       {maxLength: QUEUE_MAX_LENGTH, noYieldIfOneItem: true, signal},
       metrics?.payloadEnvelopeProcessorQueue ?? undefined
@@ -33,10 +38,6 @@ export class PayloadEnvelopeProcessor {
   }
 
   async processPayloadEnvelopeJob(payloadInput: PayloadEnvelopeInput, opts: ImportPayloadOpts = {}): Promise<void> {
-    if (!payloadInput.isComplete()) {
-      return;
-    }
-
     if (this.importStatus.get(payloadInput) !== undefined) {
       return;
     }

package/src/chain/blocks/types.ts

@@ -1,5 +1,5 @@
 import type {ChainForkConfig} from "@lodestar/config";
-import {BlockExecutionStatus, PayloadExecutionStatus} from "@lodestar/fork-choice";
+import type {BlockExecutionStatus, PayloadExecutionStatus} from "@lodestar/fork-choice";
 import {ForkSeq} from "@lodestar/params";
 import {DataAvailabilityStatus, IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
 import type {IndexedAttestation, Slot, fulu} from "@lodestar/types";
@@ -43,8 +43,9 @@ export enum BlobSidecarValidation {
 
 export type ImportPayloadOpts = {
   /**
-   * Set to true if envelope signature was already verified (e.g., during gossip/API validation).
-   * When false/undefined, signature will be verified during import.
+   * Set to true when the envelope was already validated upstream (e.g., gossip/API validation):
+   * signature is trusted and execution_requests_root was already verified against the bid.
+   * When false/undefined, both are verified during import.
    */
   validSignature?: boolean;
 };
@@ -88,9 +89,17 @@ export type ImportBlockOpts = {
   seenTimestampSec?: number;
 };
 
-type FullyVerifiedBlockBase = {
+/**
+ * A wrapper around a `SignedBeaconBlock` that indicates that this block is fully verified and ready to import.
+ *
+ * `executionStatus` reflects the outcome of execution payload verification at block-import time:
+ * - pre-gloas: Valid | Syncing | PreMerge (from EL notifyNewPayload against the in-block payload)
+ * - post-gloas: inherited from parent's chain (Valid/Syncing) by importBlock; payload arrives
+ *   separately as an envelope and creates the FULL variant later via onExecutionPayload
+ */
+export type FullyVerifiedBlock = {
   blockInput: IBlockInput;
-  postBlockState: IBeaconStateView;
+  postState: IBeaconStateView;
   parentBlockSlot: Slot;
   proposerBalanceDelta: number;
   dataAvailabilityStatus: DataAvailabilityStatus;
@@ -98,25 +107,6 @@ type FullyVerifiedBlockBase = {
   indexedAttestations: IndexedAttestation[];
   /** Seen timestamp seconds */
   seenTimestampSec: number;
+  /** If the execution payload couldn't be verified because of EL syncing status, used in optimistic sync */
+  executionStatus: BlockExecutionStatus | PayloadExecutionStatus;
 };
-
-/**
- * A wrapper around a `SignedBeaconBlock` that indicates that this block is fully verified and ready to import.
- *
- * Discriminated union on `postPayloadState`:
- * - `null`  → block has no pre-verified envelope; `executionStatus` is any `BlockExecutionStatus`
- * - non-null → envelope was pre-verified during state transition; `executionStatus` is narrowed to
- *              `Valid | Syncing` (matching what `forkChoice.onExecutionPayload` expects)
- */
-export type FullyVerifiedBlock = FullyVerifiedBlockBase &
-  (
-    | {
-        postPayloadState: null;
-        /** If the execution payload couldn't be verified because of EL syncing status, used in optimistic sync or for merge block */
-        executionStatus: BlockExecutionStatus;
-      }
-    | {
-        postPayloadState: IBeaconStateView;
-        executionStatus: PayloadExecutionStatus;
-      }
-  );

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};
 }