@lodestar/beacon-node 1.43.0-dev.1629c3a59e → 1.43.0-dev.1a52372103

package/src/chain/blocks/index.ts

@@ -65,7 +65,7 @@ export async function processBlocks(
   }
 
   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) {
@@ -109,8 +109,10 @@ 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,
         postState: postStates[i],
         parentBlockSlot: parentSlots[i],
@@ -121,14 +123,23 @@ export async function processBlocks(
         indexedAttestations: indexedAttestationsByBlock[i],
         // TODO: Make this param mandatory and capture in gossip
         seenTimestampSec: opts.seenTimestampSec ?? Math.floor(Date.now() / 1000),
-      })
-    );
+      });
+    }
 
-    for (const fullyVerifiedBlock of fullyVerifiedBlocks) {
-      // TODO: Consider batching importBlock too if it takes significant time
-      await importBlock.call(this, fullyVerifiedBlock, opts);
+    // 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 slot = fullyVerifiedBlock.blockInput.getBlock().message.slot;
       const payloadInput = payloadEnvelopes?.get(slot);
       if (payloadInput?.hasPayloadEnvelope()) {
         if (!payloadInput.isComplete()) {

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

@@ -156,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,

package/src/chain/blocks/types.ts

@@ -94,7 +94,8 @@ export type ImportBlockOpts = {
  *
  * `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: PayloadSeparated (payload arrives separately as an envelope and is imported later)
+ * - 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;

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

@@ -41,6 +41,14 @@ export function assertLinearChainSegment(
   // - 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;

package/src/chain/blocks/verifyBlock.ts

@@ -125,15 +125,17 @@ export async function verifyBlocksInEpoch(
     }> =
       fork >= ForkSeq.gloas
         ? (async () => {
-            const payloadInputsForDa: PayloadEnvelopeInput[] = [];
-            for (const input of blockInputs) {
-              const pi = payloadEnvelopes?.get(input.slot);
-              if (pi !== undefined) payloadInputsForDa.push(pi);
-            }
+            // 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]);

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[];
@@ -100,13 +102,21 @@ export function verifyBlocksSanityChecks(
         const parentBlockHash = toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash);
         const parentBlockWithPayload = chain.forkChoice.getBlockHexAndBlockHash(parentRoot, parentBlockHash);
         if (!parentBlockWithPayload) {
-          throw new BlockError(block, {
-            code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
-            parentRoot,
-            parentBlockHash,
-          });
+          // 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;
         }
-        parentBlock = parentBlockWithPayload;
       }
       // Parent is known to the fork-choice
       parentBlockSlot = parentBlock.slot;

package/src/chain/blocks/verifyExecutionPayloadEnvelope.ts

@@ -20,7 +20,7 @@ export type VerifyExecutionPayloadEnvelopeOpts = {
  * 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.5/specs/gloas/fork-choice.md#new-verify_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
  */
 export function verifyExecutionPayloadEnvelope(
   config: BeaconConfig,
@@ -43,6 +43,11 @@ export function verifyExecutionPayloadEnvelope(
       `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;
@@ -108,7 +113,7 @@ export function verifyExecutionPayloadEnvelope(
 /**
  * Verify the BLS signature of an execution payload envelope.
  *
- * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/fork-choice.md#new-verify_execution_payload_envelope_signature
+ * 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,

package/src/chain/errors/proposerPreferences.ts

@@ -1,9 +1,10 @@
-import {Slot, ValidatorIndex} from "@lodestar/types";
+import {RootHex, Slot, ValidatorIndex} from "@lodestar/types";
 import {GossipActionError} from "./gossipValidation.js";
 
 export enum ProposerPreferencesErrorCode {
   INVALID_EPOCH = "PROPOSER_PREFERENCES_ERROR_INVALID_EPOCH",
   PROPOSAL_SLOT_PASSED = "PROPOSER_PREFERENCES_ERROR_PROPOSAL_SLOT_PASSED",
+  UNKNOWN_DEPENDENT_ROOT = "PROPOSER_PREFERENCES_ERROR_UNKNOWN_DEPENDENT_ROOT",
   INVALID_PROPOSER = "PROPOSER_PREFERENCES_ERROR_INVALID_PROPOSER",
   ALREADY_KNOWN = "PROPOSER_PREFERENCES_ERROR_ALREADY_KNOWN",
   INVALID_SIGNATURE = "PROPOSER_PREFERENCES_ERROR_INVALID_SIGNATURE",
@@ -20,15 +21,22 @@ export type ProposerPreferencesErrorType =
       proposalSlot: Slot;
       currentSlot: Slot;
     }
+  | {
+      code: ProposerPreferencesErrorCode.UNKNOWN_DEPENDENT_ROOT;
+      proposalSlot: Slot;
+      dependentRoot: RootHex;
+    }
   | {
       code: ProposerPreferencesErrorCode.INVALID_PROPOSER;
       proposalSlot: Slot;
       validatorIndex: ValidatorIndex;
+      dependentRoot: RootHex;
     }
   | {
       code: ProposerPreferencesErrorCode.ALREADY_KNOWN;
       proposalSlot: Slot;
       validatorIndex: ValidatorIndex;
+      dependentRoot: RootHex;
     }
   | {
       code: ProposerPreferencesErrorCode.INVALID_SIGNATURE;

package/src/chain/produceBlock/produceBlockBody.ts

@@ -49,7 +49,7 @@ import {
   ssz,
 } from "@lodestar/types";
 import {Logger, byteArrayEquals, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
-import {ZERO_HASH, ZERO_HASH_HEX} from "../../constants/index.js";
+import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../execution/engine/utils.js";
 import {
   IExecutionBuilder,
@@ -111,6 +111,7 @@ export type ProduceFullGloas = {
   executionRequests: electra.ExecutionRequests;
   blobsBundle: BlobsBundle<ForkPostGloas>;
   cells: fulu.Cell[][];
+  parentBlockRoot: Root;
 };
 export type ProduceFullFulu = {
   type: BlockType.Full;
@@ -225,12 +226,6 @@ export async function produceBlockBody<T extends BlockType>(
       stateAfterParentPayload = currentState.withParentPayloadApplied(parentExecutionRequests);
     } else {
       parentBlockHash = currentState.latestExecutionPayloadBid.parentBlockHash;
-      // At gloas genesis the committed bid has no prior EL block to reference
-      // (`bid.parentBlockHash` is zero). Fall back to `bid.blockHash` (= eth1 genesis hash) so the
-      // FCU to the EL carries a valid head. Post-genesis bids always reference a non-zero parent.
-      if (byteArrayEquals(parentBlockHash, ZERO_HASH)) {
-        parentBlockHash = currentState.latestExecutionPayloadBid.blockHash;
-      }
       parentExecutionRequests = ssz.electra.ExecutionRequests.defaultValue();
     }
     const prepareRes = await prepareExecutionPayload(
@@ -317,6 +312,7 @@ export async function produceBlockBody<T extends BlockType>(
     gloasResult.executionRequests = executionRequests;
     gloasResult.blobsBundle = blobsBundle;
     gloasResult.cells = cells;
+    gloasResult.parentBlockRoot = fromHex(parentBlock.blockRoot);
 
     const fetchedTime = Date.now() / 1000 - computeTimeAtSlot(this.config, blockSlot, this.genesisTime);
     this.metrics?.blockPayload.payloadFetchedTime.observe({prepType}, fetchedTime);

package/src/chain/regen/queued.ts

@@ -1,7 +1,7 @@
 import {routes} from "@lodestar/api";
 import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
 import {IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
-import {BeaconBlock, Epoch, RootHex, Slot, isGloasBeaconBlock, phase0} from "@lodestar/types";
+import {BeaconBlock, Epoch, RootHex, Slot, phase0} from "@lodestar/types";
 import {Logger, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {JobItemQueue} from "../../util/queue/index.js";
@@ -88,12 +88,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
    */
   getPreStateSync(block: BeaconBlock): IBeaconStateView | null {
     const parentRoot = toRootHex(block.parentRoot);
-    const parentBlock = isGloasBeaconBlock(block)
-      ? this.forkChoice.getBlockHexAndBlockHash(
-          parentRoot,
-          toRootHex(block.body.signedExecutionPayloadBid.message.parentBlockHash)
-        )
-      : this.forkChoice.getBlockHexDefaultStatus(parentRoot);
+    const parentBlock = this.forkChoice.getBlockHexDefaultStatus(parentRoot);
     if (!parentBlock) {
       throw new RegenError({
         code: RegenErrorCode.BLOCK_NOT_IN_FORKCHOICE,

package/src/chain/regen/regen.ts

@@ -9,7 +9,7 @@ import {
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
 } from "@lodestar/state-transition";
-import {BeaconBlock, RootHex, SignedBeaconBlock, Slot, isGloasBeaconBlock} from "@lodestar/types";
+import {BeaconBlock, RootHex, SignedBeaconBlock, Slot} from "@lodestar/types";
 import {Logger, fromHex, toRootHex} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
 import {Metrics} from "../../metrics/index.js";
@@ -57,12 +57,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     regenCaller: RegenCaller
   ): Promise<IBeaconStateView> {
     const parentRoot = toRootHex(block.parentRoot);
-    const parentBlock = isGloasBeaconBlock(block)
-      ? this.modules.forkChoice.getBlockHexAndBlockHash(
-          parentRoot,
-          toRootHex(block.body.signedExecutionPayloadBid.message.parentBlockHash)
-        )
-      : this.modules.forkChoice.getBlockHexDefaultStatus(parentRoot);
+    const parentBlock = this.modules.forkChoice.getBlockHexDefaultStatus(parentRoot);
     if (!parentBlock) {
       throw new RegenError({
         code: RegenErrorCode.BLOCK_NOT_IN_FORKCHOICE,

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -78,13 +78,23 @@ export class SeenPayloadEnvelopeInput {
   };
 
   add(props: Omit<CreateFromBlockProps, "daOutOfRange">): PayloadEnvelopeInput {
-    if (this.payloadInputs.has(props.blockRootHex)) {
-      throw new Error(`PayloadEnvelopeInput already exists for block ${props.blockRootHex}`);
+    const existing = this.payloadInputs.get(props.blockRootHex);
+    if (existing !== undefined) {
+      this.logger?.verbose("SeenPayloadEnvelopeInput.add reused existing entry", {
+        slot: existing.slot,
+        root: props.blockRootHex,
+      });
+      return existing;
     }
     const daOutOfRange = isDaOutOfRange(this.config, props.forkName, props.block.message.slot, this.clock.currentEpoch);
     const input = PayloadEnvelopeInput.createFromBlock({...props, daOutOfRange});
     this.payloadInputs.set(props.blockRootHex, input);
     this.metrics?.seenCache.payloadEnvelopeInput.created.inc();
+    this.logger?.verbose("SeenPayloadEnvelopeInput.add created new entry", {
+      slot: input.slot,
+      root: props.blockRootHex,
+      daOutOfRange,
+    });
     return input;
   }
 

package/src/chain/seenCache/seenProposerPreferences.ts

@@ -1,28 +1,36 @@
-import {Slot, ValidatorIndex} from "@lodestar/types";
+import {RootHex, Slot, ValidatorIndex} from "@lodestar/types";
 import {MapDef} from "@lodestar/utils";
 
 /**
- * Tracks signed proposer preferences we've already seen per (proposal_slot, validator_index).
+ * Tracks signed proposer preferences we've already seen per (dependent_root, proposal_slot, validator_index).
  */
 export class SeenProposerPreferences {
-  private readonly validatorIndexesBySlot = new MapDef<Slot, Set<ValidatorIndex>>(() => new Set<ValidatorIndex>());
+  private readonly validatorBySlotByDependentRoot = new MapDef<RootHex, Map<Slot, ValidatorIndex>>(
+    () => new Map<Slot, ValidatorIndex>()
+  );
 
-  isKnown(proposalSlot: Slot, validatorIndex: ValidatorIndex): boolean {
-    return this.validatorIndexesBySlot.get(proposalSlot)?.has(validatorIndex) === true;
+  isKnown(dependentRoot: RootHex, proposalSlot: Slot, validatorIndex: ValidatorIndex): boolean {
+    return this.validatorBySlotByDependentRoot.get(dependentRoot)?.get(proposalSlot) === validatorIndex;
   }
 
-  add(proposalSlot: Slot, validatorIndex: ValidatorIndex): void {
-    this.validatorIndexesBySlot.getOrDefault(proposalSlot).add(validatorIndex);
+  add(dependentRoot: RootHex, proposalSlot: Slot, validatorIndex: ValidatorIndex): void {
+    this.validatorBySlotByDependentRoot.getOrDefault(dependentRoot).set(proposalSlot, validatorIndex);
   }
 
   /**
-   * Entries are only load-bearing while `proposal_slot > state.slot`. Once the slot has passed the
-   * `[IGNORE] proposal_slot > state.slot` gossip rule takes over, so drop them on each slot tick.
+   * Entries are only load-bearing while `proposal_slot > current_slot`. Once the slot has
+   * passed the `[IGNORE] proposal_slot > current_slot` gossip rule takes over, so drop them
+   * on each slot tick.
    */
   prune(currentSlot: Slot): void {
-    for (const slot of this.validatorIndexesBySlot.keys()) {
-      if (slot < currentSlot) {
-        this.validatorIndexesBySlot.delete(slot);
+    for (const [dependentRoot, slotMap] of this.validatorBySlotByDependentRoot.entries()) {
+      for (const slot of slotMap.keys()) {
+        if (slot < currentSlot) {
+          slotMap.delete(slot);
+        }
+      }
+      if (slotMap.size === 0) {
+        this.validatorBySlotByDependentRoot.delete(dependentRoot);
       }
     }
   }

package/src/chain/validation/executionPayloadBid.ts

@@ -48,9 +48,12 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [IGNORE] the `SignedProposerPreferences` where `preferences.proposal_slot`
-  // is equal to `bid.slot` has been seen.
-  // TODO GLOAS: Implement this along with proposer preference
+  // [IGNORE] A `SignedProposerPreferences` matching `bid.slot` and the bid's branch has been
+  // seen — i.e. `proposal_slot == bid.slot` AND `dependent_root ==
+  // get_proposer_dependent_root(parent_state, compute_epoch_at_slot(bid.slot))`,
+  // where `parent_state` is the post-state of `bid.parent_block_root`.
+  // This is the message referenced as `proposer_preferences` in the following REJECT rules.
+  // TODO GLOAS: Implement once a ProposerPreferencesPool exists.
 
   // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
   // `is_active_builder(state, bid.builder_index)` returns `True`.
@@ -71,11 +74,11 @@ async function validateExecutionPayloadBid(
     });
   }
 
-  // [REJECT] `bid.fee_recipient` matches the `fee_recipient` from the proposer's
-  // `SignedProposerPreferences` associated with `bid.slot`.
-  // [REJECT] `bid.gas_limit` matches the `gas_limit` from the proposer's
-  // `SignedProposerPreferences` associated with `bid.slot`.
-  // TODO GLOAS: Implement this along with proposer preference
+  // [REJECT] `bid.fee_recipient == proposer_preferences.fee_recipient`.
+  // [REJECT] `bid.gas_limit == proposer_preferences.gas_limit`.
+  // Both compared against the matching `proposer_preferences` defined above (same branch
+  // via dependent_root, same proposal_slot).
+  // TODO GLOAS: Implement once a ProposerPreferencesPool exists.
 
   // [REJECT] The length of KZG commitments is less than or equal to the limitation defined in the
   // consensus layer -- i.e. validate that

package/src/chain/validation/proposerPreferences.ts

@@ -3,12 +3,11 @@ import {
   computeEpochAtSlot,
   createSingleSignatureSetFromComponents,
   getProposerPreferencesSigningRoot,
-  isStatePostGloas,
 } from "@lodestar/state-transition";
-import {gloas} from "@lodestar/types";
+import {ValidatorIndex, gloas} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
 import {GossipAction, ProposerPreferencesError, ProposerPreferencesErrorCode} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
-import {RegenCaller} from "../regen/index.js";
 
 /**
  * Validates a gossiped `SignedProposerPreferences` per
@@ -19,7 +18,8 @@ export async function validateGossipProposerPreferences(
   signedProposerPreferences: gloas.SignedProposerPreferences
 ): Promise<void> {
   const preferences = signedProposerPreferences.message;
-  const {proposalSlot, validatorIndex} = preferences;
+  const {proposalSlot, validatorIndex, dependentRoot} = preferences;
+  const dependentRootHex = toRootHex(dependentRoot);
   const proposalEpoch = computeEpochAtSlot(proposalSlot);
 
   // [IGNORE] `preferences.proposal_slot` is in the current or next epoch.
@@ -42,32 +42,51 @@ export async function validateGossipProposerPreferences(
     });
   }
 
-  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipProposerPreferences);
-  if (!isStatePostGloas(state)) {
-    throw new Error(`Expected gloas+ state for proposer preferences validation, got fork=${state.forkName}`);
+  // [IGNORE] The block with root `dependent_root` has been seen by the node.
+  // Resolve the proposer lookahead for the message's branch via head state (fast path) or
+  // the previous-root checkpoint state (populated by `processSlotsToNearestCheckpoint` for
+  // any imported branch crossing into `proposalEpoch - 1`). The head-state path also handles
+  // narrow timing windows where the checkpoint state isn't yet populated.
+  const headState = chain.getHeadState();
+  let proposers: ValidatorIndex[] | null = null;
+  if (headState.epoch === proposalEpoch && headState.currentDecisionRoot === dependentRootHex) {
+    proposers = headState.currentProposers;
+  } else if (headState.epoch === proposalEpoch - 1 && headState.nextDecisionRoot === dependentRootHex) {
+    proposers = headState.nextProposers;
+  } else {
+    // Sync lookup only to not trigger disk reload from gossip input.
+    const checkpointState = chain.regen.getCheckpointStateSync({epoch: proposalEpoch - 1, rootHex: dependentRootHex});
+    if (checkpointState !== null) {
+      // State is at `proposalEpoch - 1`, so proposers for `proposalSlot` (next epoch from
+      // the state's perspective) live in `nextProposers`.
+      proposers = checkpointState.nextProposers;
+    }
+  }
+  if (proposers === null) {
+    throw new ProposerPreferencesError(GossipAction.IGNORE, {
+      code: ProposerPreferencesErrorCode.UNKNOWN_DEPENDENT_ROOT,
+      proposalSlot,
+      dependentRoot: dependentRootHex,
+    });
   }
 
-  // [REJECT] `preferences.validator_index` is present at the correct slot in the current or next
-  // epoch's portion of `state.proposer_lookahead` — i.e. `is_valid_proposal_slot(state, preferences)`
-  // returns True.
-  const epochOffset = proposalEpoch - state.epoch;
-  const proposers = epochOffset === 0 ? state.currentProposers : state.nextProposers;
-  const expectedProposer = proposers[proposalSlot % SLOTS_PER_EPOCH];
-  if (epochOffset < 0 || epochOffset > 1 || expectedProposer !== validatorIndex) {
+  // [REJECT] `is_valid_proposal_slot(state, preferences)` returns True.
+  if (proposers[proposalSlot % SLOTS_PER_EPOCH] !== validatorIndex) {
     throw new ProposerPreferencesError(GossipAction.REJECT, {
       code: ProposerPreferencesErrorCode.INVALID_PROPOSER,
       proposalSlot,
       validatorIndex,
+      dependentRoot: dependentRootHex,
     });
   }
 
-  // [IGNORE] The `signed_proposer_preferences` is the first valid message received from the validator
-  // with index `preferences.validator_index` and the given slot `preferences.proposal_slot`.
-  if (chain.seenProposerPreferences.isKnown(proposalSlot, validatorIndex)) {
+  // [IGNORE] First valid message for (dependent_root, proposal_slot, validator_index).
+  if (chain.seenProposerPreferences.isKnown(dependentRootHex, proposalSlot, validatorIndex)) {
     throw new ProposerPreferencesError(GossipAction.IGNORE, {
       code: ProposerPreferencesErrorCode.ALREADY_KNOWN,
       proposalSlot,
       validatorIndex,
+      dependentRoot: dependentRootHex,
     });
   }
 
@@ -87,5 +106,5 @@ export async function validateGossipProposerPreferences(
   }
 
   // Valid
-  chain.seenProposerPreferences.add(proposalSlot, validatorIndex);
+  chain.seenProposerPreferences.add(dependentRootHex, proposalSlot, validatorIndex);
 }

package/src/network/processor/gossipHandlers.ts

@@ -185,6 +185,18 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     });
     try {
       await validateGossipBlock(config, chain, signedBlock, fork);
+
+      if (isForkPostGloas(fork)) {
+        chain.seenPayloadEnvelopeInputCache.add({
+          blockRootHex,
+          block: signedBlock as SignedBeaconBlock<ForkPostGloas>,
+          forkName: fork,
+          sampledColumns: chain.custodyConfig.sampledColumns,
+          custodyColumns: chain.custodyConfig.custodyColumns,
+          timeCreatedSec: seenTimestampSec,
+        });
+      }
+
       const blockInputMeta = blockInput.getLogMeta();
 
       const recvToValidation = Date.now() / 1000 - seenTimestampSec;

package/src/node/nodejs.ts

@@ -221,7 +221,7 @@ export class BeaconNode {
 
     let executionEngineOpts = opts.executionEngine;
     if (opts.executionEngine.mode === "mock") {
-      const eth1BlockHash =
+      const latestEth1BlockHash =
         isStatePostBellatrix(anchorState) && anchorState.isExecutionStateType
           ? isStatePostGloas(anchorState)
             ? toRootHex(anchorState.latestBlockHash)
@@ -230,7 +230,7 @@ export class BeaconNode {
       executionEngineOpts = {
         ...opts.executionEngine,
         genesisBlockHash: ZERO_HASH_HEX,
-        eth1BlockHash,
+        eth1BlockHash: opts.executionEngine.eth1BlockHash ?? latestEth1BlockHash,
         genesisTime: anchorState.genesisTime,
         config,
       };

package/src/node/notifier.ts

@@ -167,14 +167,7 @@ function getHeadExecutionInfo(
     return [];
   }
 
-  // A PayloadSeparated head is a gloas beacon block imported before its payload envelope
-  // arrives, in that case the exec-block row surfaces the inherited parent anchor (from the
-  // bid), which is already validated. Normalize to "valid" to avoid leaking internal
-  // fork-choice bookkeeping into the log. Once the payload envelope arrives and the FULL
-  // variant becomes head, executionStatus is Valid/Syncing naturally.
-  // TODO GLOAS: revisit once optimistic sync is implemented
-  const executionStatusStr =
-    headInfo.executionStatus === ExecutionStatus.PayloadSeparated ? "valid" : headInfo.executionStatus.toLowerCase();
+  const executionStatusStr = headInfo.executionStatus.toLowerCase();
 
   // Add execution status to notifier only if head is on/post bellatrix
   if (isStatePostBellatrix(headState) && headState.isExecutionStateType) {