feat: gloas from genesis

packages/beacon-node/src/api/impl/beacon/blocks/index.ts

@@ -311,7 +311,10 @@ export function getBeaconBlockApi({
         chain
           .processBlock(blockForImport, opts)
           .catch((e) => {
-            if (e instanceof BlockError && e.type.code === BlockErrorCode.PARENT_UNKNOWN) {
+            if (
+              e instanceof BlockError &&
+              (e.type.code === BlockErrorCode.PARENT_UNKNOWN || e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN)
+            ) {
               chain.emitter.emit(ChainEvent.blockUnknownParent, {
                 blockInput: blockForImport,
                 peer: IDENTITY_PEER_ID,

packages/beacon-node/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -90,15 +90,23 @@ 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) {
+          throw new BlockError(block, {
+            code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+            parentBlockHash,
+          });
+        }
+        parentBlock = parentBlockWithPayload;
+      }
       // Parent is known to the fork-choice
       parentBlockSlot = parentBlock.slot;
     }

packages/beacon-node/src/chain/chain.ts

@@ -337,6 +337,7 @@ export class BeaconChain implements IBeaconChain {
       chainEvents: emitter,
       signal,
       serializedCache: this.serializedCache,
+      hasValidatedPayload: (blockRootHex) => this.forkChoice.hasPayloadHexUnsafe(blockRootHex),
       metrics,
       logger,
     });
@@ -891,6 +892,10 @@ export class BeaconChain implements IBeaconChain {
     parentBlockSlot: Slot,
     parentBlockRootHex: RootHex
   ): Promise<electra.ExecutionRequests> {
+    // Gloas genesis has no payload envelope — treat the parent's requests as empty.
+    if (parentBlockSlot === GENESIS_SLOT) {
+      return ssz.electra.ExecutionRequests.defaultValue();
+    }
     const envelope = await this.getExecutionPayloadEnvelope(parentBlockSlot, parentBlockRootHex);
     if (envelope === null) {
       throw Error(`Parent execution payload envelope not found slot=${parentBlockSlot}, root=${parentBlockRootHex}`);

packages/beacon-node/src/chain/forkChoice/index.ts

@@ -103,6 +103,63 @@ export function initializeForkChoiceFromFinalizedState(
 
   const isForkPostGloas = computeEpochAtSlot(state.slot) >= config.GLOAS_FORK_EPOCH;
 
+  const anchorBlockRoot = toRootHex(checkpoint.root);
+  const protoArray = ProtoArray.initialize(
+    {
+      slot: blockHeader.slot,
+      parentRoot: toRootHex(blockHeader.parentRoot),
+      stateRoot: toRootHex(blockHeader.stateRoot),
+      blockRoot: anchorBlockRoot,
+      timeliness: true, // Optimistically assume is timely
+
+      justifiedEpoch: justifiedCheckpoint.epoch,
+      justifiedRoot: toRootHex(justifiedCheckpoint.root),
+      finalizedEpoch: finalizedCheckpoint.epoch,
+      finalizedRoot: toRootHex(finalizedCheckpoint.root),
+      unrealizedJustifiedEpoch: justifiedCheckpoint.epoch,
+      unrealizedJustifiedRoot: toRootHex(justifiedCheckpoint.root),
+      unrealizedFinalizedEpoch: finalizedCheckpoint.epoch,
+      unrealizedFinalizedRoot: toRootHex(finalizedCheckpoint.root),
+
+      ...(isStatePostBellatrix(state) && state.isExecutionStateType && state.isMergeTransitionComplete
+        ? {
+            executionPayloadBlockHash: isStatePostGloas(state)
+              ? toRootHex(state.latestBlockHash)
+              : toRootHex(state.latestExecutionPayloadHeader.blockHash),
+            // TODO GLOAS: executionPayloadNumber is not tracked in BeaconState post-gloas (EIP-7732 removed
+            // latestExecutionPayloadHeader). Using 0 as unavailable fallback until a solution is found.
+            executionPayloadNumber: isStatePostGloas(state) ? 0 : state.payloadBlockNumber,
+            executionStatus: blockHeader.slot === GENESIS_SLOT ? ExecutionStatus.Valid : ExecutionStatus.Syncing,
+          }
+        : {executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge}),
+
+      dataAvailabilityStatus: DataAvailabilityStatus.PreData,
+      payloadStatus: isForkPostGloas ? PayloadStatus.PENDING : PayloadStatus.FULL,
+      parentBlockHash: isStatePostGloas(state) ? toRootHex(state.latestBlockHash) : null,
+    },
+    currentSlot
+  );
+
+  // Gloas anchor whose payload has already been fulfilled (e.g. genesis with EL genesis block,
+  // or a finalized anchor that was FULL at time of finalization) must expose a FULL variant so
+  // `forkChoice.hasPayload(anchorRoot)` returns true and next-slot FCU can extend the EL head.
+  // Spec: gloas/fork-choice.md `is_parent_block_full(state)` equivalent — parent is FULL when
+  // `state.latestBlockHash == state.latestExecutionPayloadBid.blockHash`.
+  if (isStatePostGloas(state) && state.isMergeTransitionComplete) {
+    const latestBlockHashHex = toRootHex(state.latestBlockHash);
+    const bidBlockHashHex = toRootHex(state.latestExecutionPayloadBid.blockHash);
+    if (latestBlockHashHex !== ZERO_HASH_HEX && latestBlockHashHex === bidBlockHashHex) {
+      protoArray.onExecutionPayload(
+        anchorBlockRoot,
+        currentSlot,
+        latestBlockHashHex,
+        0,
+        null,
+        blockHeader.slot === GENESIS_SLOT ? ExecutionStatus.Valid : ExecutionStatus.Syncing
+      );
+    }
+  }
+
   return new forkchoiceConstructor(
     config,
 
@@ -118,41 +175,7 @@ export function initializeForkChoiceFromFinalizedState(
       }
     ),
 
-    ProtoArray.initialize(
-      {
-        slot: blockHeader.slot,
-        parentRoot: toRootHex(blockHeader.parentRoot),
-        stateRoot: toRootHex(blockHeader.stateRoot),
-        blockRoot: toRootHex(checkpoint.root),
-        timeliness: true, // Optimistically assume is timely
-
-        justifiedEpoch: justifiedCheckpoint.epoch,
-        justifiedRoot: toRootHex(justifiedCheckpoint.root),
-        finalizedEpoch: finalizedCheckpoint.epoch,
-        finalizedRoot: toRootHex(finalizedCheckpoint.root),
-        unrealizedJustifiedEpoch: justifiedCheckpoint.epoch,
-        unrealizedJustifiedRoot: toRootHex(justifiedCheckpoint.root),
-        unrealizedFinalizedEpoch: finalizedCheckpoint.epoch,
-        unrealizedFinalizedRoot: toRootHex(finalizedCheckpoint.root),
-
-        ...(isStatePostBellatrix(state) && state.isExecutionStateType && state.isMergeTransitionComplete
-          ? {
-              executionPayloadBlockHash: isStatePostGloas(state)
-                ? toRootHex(state.latestBlockHash)
-                : toRootHex(state.latestExecutionPayloadHeader.blockHash),
-              // TODO GLOAS: executionPayloadNumber is not tracked in BeaconState post-gloas (EIP-7732 removed
-              // latestExecutionPayloadHeader). Using 0 as unavailable fallback until a solution is found.
-              executionPayloadNumber: isStatePostGloas(state) ? 0 : state.payloadBlockNumber,
-              executionStatus: blockHeader.slot === GENESIS_SLOT ? ExecutionStatus.Valid : ExecutionStatus.Syncing,
-            }
-          : {executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge}),
-
-        dataAvailabilityStatus: DataAvailabilityStatus.PreData,
-        payloadStatus: isForkPostGloas ? PayloadStatus.PENDING : PayloadStatus.FULL,
-        parentBlockHash: isStatePostGloas(state) ? toRootHex(state.latestBlockHash) : null,
-      },
-      currentSlot
-    ),
+    protoArray,
     state.validatorCount,
     metrics,
     opts,

packages/beacon-node/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -4,7 +4,8 @@ import {RootHex, Slot} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {SerializedCache} from "../../util/serializedCache.js";
-import {CreateFromBlockProps, PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
+import {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/payloadEnvelopeInput.js";
+import {CreateFromBlockProps} from "../blocks/payloadEnvelopeInput/types.js";
 import {ChainEvent, ChainEventEmitter} from "../emitter.js";
 
 export type {PayloadEnvelopeInputState} from "../blocks/payloadEnvelopeInput/index.js";
@@ -14,6 +15,7 @@ export type SeenPayloadEnvelopeInputModules = {
   chainEvents: ChainEventEmitter;
   signal: AbortSignal;
   serializedCache: SerializedCache;
+  hasValidatedPayload: (blockRootHex: RootHex) => boolean;
   metrics: Metrics | null;
   logger?: Logger;
 };
@@ -26,6 +28,9 @@ export type SeenPayloadEnvelopeInputModules = {
  *     on is known.
  *   - `onFinalized` calls `pruneBelow(finalizedSlot)` on every finalization for bulk cleanup.
  *
+ * Entries whose payload has not yet been validated are retained across pruning so that later
+ * envelope / column validation can reuse the PayloadEnvelopeInput created by importBlock().
+ *
  * Steady state (linear chain, healthy progression): the cache holds ~2 entries — the head
  * (parent for next-slot production) and its parent (proposer-boost-reorg fallback). It can
  * transiently hold more during forks, range-sync bursts, or when `prepareNextSlot` skips
@@ -35,14 +40,23 @@ export class SeenPayloadEnvelopeInput {
   private readonly chainEvents: ChainEventEmitter;
   private readonly signal: AbortSignal;
   private readonly serializedCache: SerializedCache;
+  private readonly hasValidatedPayload: (blockRootHex: RootHex) => boolean;
   private readonly metrics: Metrics | null;
   private readonly logger?: Logger;
   private payloadInputs = new Map<RootHex, PayloadEnvelopeInput>();
 
-  constructor({chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+  constructor({
+    chainEvents,
+    signal,
+    serializedCache,
+    hasValidatedPayload,
+    metrics,
+    logger,
+  }: SeenPayloadEnvelopeInputModules) {
     this.chainEvents = chainEvents;
     this.signal = signal;
     this.serializedCache = serializedCache;
+    this.hasValidatedPayload = hasValidatedPayload;
     this.metrics = metrics;
     this.logger = logger;
 
@@ -92,13 +106,25 @@ export class SeenPayloadEnvelopeInput {
 
   pruneBelow(slot: Slot): void {
     let deletedCount = 0;
+    let retainedUnvalidatedCount = 0;
     for (const [, input] of this.payloadInputs) {
-      if (input.slot < slot) {
-        this.evictPayloadInput(input);
-        deletedCount++;
+      if (input.slot >= slot) {
+        continue;
+      }
+
+      if (!this.hasValidatedPayload(input.blockRootHex)) {
+        retainedUnvalidatedCount++;
+        continue;
       }
+
+      this.evictPayloadInput(input);
+      deletedCount++;
     }
-    this.logger?.debug("SeenPayloadEnvelopeInput.pruneBelow deleted entries", {slot, deletedCount});
+    this.logger?.debug("SeenPayloadEnvelopeInput.pruneBelow deleted entries", {
+      slot,
+      deletedCount,
+      retainedUnvalidatedCount,
+    });
   }
 
   private evictPayloadInput(payloadInput: PayloadEnvelopeInput): void {

packages/beacon-node/src/chain/validation/executionPayloadEnvelope.ts

@@ -48,23 +48,31 @@ async function validateExecutionPayloadEnvelope(
   // [IGNORE] The node has not seen another valid
   // `SignedExecutionPayloadEnvelope` for this block root from this builder.
   const envelopeBlock = chain.forkChoice.getBlockHex(blockRootHex, PayloadStatus.FULL);
-  const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
-  if (envelopeBlock || payloadInput?.hasPayloadEnvelope()) {
+  if (envelopeBlock) {
     throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
       code: ExecutionPayloadEnvelopeErrorCode.ENVELOPE_ALREADY_KNOWN,
       blockRoot: blockRootHex,
       slot: payload.slotNumber,
     });
   }
 
+  const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
   if (!payloadInput) {
-    // PayloadEnvelopeInput should have been created during block import
+    // importBlock() is the only place that creates PayloadEnvelopeInput for a known Gloas block.
     throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
       code: ExecutionPayloadEnvelopeErrorCode.PAYLOAD_ENVELOPE_INPUT_MISSING,
       blockRoot: blockRootHex,
     });
   }
 
+  if (payloadInput.hasPayloadEnvelope()) {
+    throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
+      code: ExecutionPayloadEnvelopeErrorCode.ENVELOPE_ALREADY_KNOWN,
+      blockRoot: blockRootHex,
+      slot: payload.slotNumber,
+    });
+  }
+
   // [IGNORE] The envelope is from a slot greater than or equal to the latest finalized slot -- i.e. validate that `payload.slotNumber >= compute_start_slot_at_epoch(store.finalized_checkpoint.epoch)`
   const finalizedCheckpoint = chain.forkChoice.getFinalizedCheckpoint();
   const finalizedSlot = computeStartSlotAtEpoch(finalizedCheckpoint.epoch);

packages/beacon-node/src/metrics/metrics/lodestar.ts

@@ -613,6 +613,10 @@ export function createLodestarMetrics(
         name: "lodestar_sync_unknown_block_pending_blocks_size",
         help: "Current size of UnknownBlockSync pending blocks cache",
       }),
+      pendingPayloads: register.gauge({
+        name: "lodestar_sync_unknown_block_pending_payloads_size",
+        help: "Current size of UnknownBlockSync pending payloads cache",
+      }),
       knownBadBlocks: register.gauge({
         name: "lodestar_sync_unknown_block_known_bad_blocks_size",
         help: "Current size of UnknownBlockSync known bad blocks cache",

packages/beacon-node/src/network/processor/gossipHandlers.ts

@@ -198,7 +198,10 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     } catch (e) {
       if (e instanceof BlockGossipError) {
         logger.debug("Gossip block has error", {slot, root: blockShortHex, code: e.type.code});
-        if (e.type.code === BlockErrorCode.PARENT_UNKNOWN && blockInput) {
+        if (
+          (e.type.code === BlockErrorCode.PARENT_UNKNOWN || e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN) &&
+          blockInput
+        ) {
           chain.emitter.emit(ChainEvent.blockUnknownParent, {
             blockInput,
             peer: peerIdStr,
@@ -442,8 +445,8 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
 
     if (!payloadInput) {
-      // This should not happen for gossip because the network processor queues `data_column_sidecar`
-      // until block import creates the corresponding PayloadEnvelopeInput.
+      // This should not happen for gossip because the block should already be known by the time
+      // payload columns are processed.
       throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
         code: DataColumnSidecarErrorCode.PAYLOAD_ENVELOPE_INPUT_MISSING,
         slot,
@@ -1098,7 +1101,6 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
 
       if (!payloadInput) {
-        // This shouldn't happen because beacon block should have been imported and thus payload input should have been created.
         throw new ExecutionPayloadEnvelopeError(GossipAction.IGNORE, {
           code: ExecutionPayloadEnvelopeErrorCode.PAYLOAD_ENVELOPE_INPUT_MISSING,
           blockRoot: blockRootHex,