@lodestar/beacon-node 1.43.0-dev.2fba242f5d → 1.43.0-dev.3bcc6d0ad5

package/src/chain/blocks/importBlock.ts

@@ -69,8 +69,8 @@ export async function importBlock(
   fullyVerifiedBlock: FullyVerifiedBlock,
   opts: ImportBlockOpts
 ): Promise<void> {
-  const {blockInput, postState, parentBlockSlot, dataAvailabilityStatus, indexedAttestations} = fullyVerifiedBlock;
-  let {executionStatus} = fullyVerifiedBlock;
+  const {blockInput, postState, parentBlockSlot, executionStatus, dataAvailabilityStatus, indexedAttestations} =
+    fullyVerifiedBlock;
   const block = blockInput.getBlock();
   const source = blockInput.getBlockSource();
   const {slot: blockSlot} = block.message;
@@ -105,23 +105,12 @@ export async function importBlock(
 
   // Should compute checkpoint balances before forkchoice.onBlock
   this.checkpointBalancesCache.processState(blockRootHex, postState);
-  if (fork >= ForkSeq.gloas) {
-    const parentRootHex = toRootHex(block.message.parentRoot);
-    const parentBlock = this.forkChoice.getBlockHexDefaultStatus(parentRootHex);
-    if (parentBlock === null) {
-      throw Error(`Parent block not found in forkChoice, parentRoot=${parentRootHex}`);
-    }
-    if (parentBlock.executionStatus === ExecutionStatus.Invalid) {
-      throw Error(`Parent block has invalid execution status, parentRoot=${parentRootHex}`);
-    }
-    executionStatus = parentBlock.executionStatus;
-  }
   const blockSummary = this.forkChoice.onBlock(
     block.message,
     postState,
     blockDelaySec,
     currentSlot,
-    executionStatus,
+    fork >= ForkSeq.gloas ? ExecutionStatus.PayloadSeparated : executionStatus,
     dataAvailabilityStatus
   );
 

package/src/chain/blocks/importExecutionPayload.ts

@@ -61,6 +61,7 @@ function toForkChoiceExecutionStatus(status: ExecutionPayloadStatus): PayloadExe
   switch (status) {
     case ExecutionPayloadStatus.VALID:
       return ExecutionStatus.Valid;
+    // TODO GLOAS: Handle optimistic import for payload
     case ExecutionPayloadStatus.SYNCING:
     case ExecutionPayloadStatus.ACCEPTED:
       return ExecutionStatus.Syncing;
@@ -254,7 +255,8 @@ export async function importExecutionPayload(
       builderIndex: envelope.builderIndex,
       blockHash: blockHashHex,
       blockRoot: blockRootHex,
-      executionOptimistic: execStatus === ExecutionStatus.Syncing,
+      // TODO GLOAS: revisit once we support optimistic import
+      executionOptimistic: false,
     });
   }
 

package/src/chain/blocks/index.ts

@@ -65,7 +65,7 @@ export async function processBlocks(
   }
 
   try {
-    const {relevantBlocks, parentSlots, parentBlock} = verifyBlocksSanityChecks(this, blocks, payloadEnvelopes, opts);
+    const {relevantBlocks, parentSlots, parentBlock} = verifyBlocksSanityChecks(this, blocks, opts);
 
     // No relevant blocks, skip verifyBlocksInEpoch()
     if (relevantBlocks.length === 0 || parentBlock === null) {
@@ -109,10 +109,8 @@ export async function processBlocks(
     }
 
     const {executionStatuses} = segmentExecStatus;
-    const verifiedBlocksBySlot = new Map<Slot, FullyVerifiedBlock>();
-    for (let i = 0; i < relevantBlocks.length; i++) {
-      const block = relevantBlocks[i];
-      verifiedBlocksBySlot.set(block.getBlock().message.slot, {
+    const fullyVerifiedBlocks = relevantBlocks.map(
+      (block, i): FullyVerifiedBlock => ({
         blockInput: block,
         postState: postStates[i],
         parentBlockSlot: parentSlots[i],
@@ -123,23 +121,14 @@ export async function processBlocks(
         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);
-      }
+    for (const fullyVerifiedBlock of fullyVerifiedBlocks) {
+      // 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/types.ts

@@ -94,8 +94,7 @@ 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: inherited from parent's chain (Valid/Syncing) by importBlock; payload arrives
- *   separately as an envelope and creates the FULL variant later via onExecutionPayload
+ * - post-gloas: PayloadSeparated (payload arrives separately as an envelope and is imported later)
  */
 export type FullyVerifiedBlock = {
   blockInput: IBlockInput;

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

@@ -41,14 +41,6 @@ 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,17 +125,15 @@ export async function verifyBlocksInEpoch(
     }> =
       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 payloadInputsForDa: PayloadEnvelopeInput[] = [];
+            for (const input of blockInputs) {
+              const pi = payloadEnvelopes?.get(input.slot);
+              if (pi !== undefined) payloadInputsForDa.push(pi);
+            }
             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,7 +46,8 @@ 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.PreMerge; lvhResponse: undefined; execError: null}
+  | {executionStatus: ExecutionStatus.PayloadSeparated; lvhResponse: undefined; execError: null};
 
 /**
  * Verifies 1 or more execution payloads from a linear sequence of blocks.
@@ -144,10 +145,9 @@ export async function verifyBlockExecutionPayload(
 ): Promise<VerifyBlockExecutionResponse> {
   const block = blockInput.getBlock();
 
-  // 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.
+  // Gloas block doesn't have execution payload. Return right away
   if (isBlockInputNoData(blockInput)) {
-    return {executionStatus: ExecutionStatus.Syncing, lvhResponse: undefined, execError: null};
+    return {executionStatus: ExecutionStatus.PayloadSeparated, lvhResponse: undefined, execError: null};
   }
 
   /** Not null if execution is enabled */
@@ -198,7 +198,6 @@ 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,
@@ -282,7 +281,6 @@ function getSegmentErrorResponse(
         executionStatus: ExecutionStatus.Invalid,
         latestValidExecHash: lvhResponse.latestValidExecHash,
         invalidateFromParentBlockRoot: parentBlock.blockRoot,
-        invalidateFromParentBlockHash: parentBlock.executionPayloadBlockHash,
       };
     }
   }

package/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -7,7 +7,6 @@ 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";
 
 /**
@@ -31,7 +30,6 @@ export function verifyBlocksSanityChecks(
     blacklistedBlocks: Map<RootHex, Slot | null>;
   },
   blocks: IBlockInput[],
-  payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
   opts: ImportBlockOpts
 ): {
   relevantBlocks: IBlockInput[];
@@ -102,21 +100,13 @@ export function verifyBlocksSanityChecks(
         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;
+          throw new BlockError(block, {
+            code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+            parentRoot,
+            parentBlockHash,
+          });
         }
+        parentBlock = parentBlockWithPayload;
       }
       // Parent is known to the fork-choice
       parentBlockSlot = parentBlock.slot;

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, phase0} from "@lodestar/types";
+import {BeaconBlock, Epoch, RootHex, Slot, isGloasBeaconBlock, phase0} from "@lodestar/types";
 import {Logger, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {JobItemQueue} from "../../util/queue/index.js";
@@ -88,7 +88,12 @@ export class QueuedStateRegenerator implements IStateRegenerator {
    */
   getPreStateSync(block: BeaconBlock): IBeaconStateView | null {
     const parentRoot = toRootHex(block.parentRoot);
-    const parentBlock = this.forkChoice.getBlockHexDefaultStatus(parentRoot);
+    const parentBlock = isGloasBeaconBlock(block)
+      ? this.forkChoice.getBlockHexAndBlockHash(
+          parentRoot,
+          toRootHex(block.body.signedExecutionPayloadBid.message.parentBlockHash)
+        )
+      : 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} from "@lodestar/types";
+import {BeaconBlock, RootHex, SignedBeaconBlock, Slot, isGloasBeaconBlock} from "@lodestar/types";
 import {Logger, fromHex, toRootHex} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
 import {Metrics} from "../../metrics/index.js";
@@ -57,7 +57,12 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     regenCaller: RegenCaller
   ): Promise<IBeaconStateView> {
     const parentRoot = toRootHex(block.parentRoot);
-    const parentBlock = this.modules.forkChoice.getBlockHexDefaultStatus(parentRoot);
+    const parentBlock = isGloasBeaconBlock(block)
+      ? this.modules.forkChoice.getBlockHexAndBlockHash(
+          parentRoot,
+          toRootHex(block.body.signedExecutionPayloadBid.message.parentBlockHash)
+        )
+      : this.modules.forkChoice.getBlockHexDefaultStatus(parentRoot);
     if (!parentBlock) {
       throw new RegenError({
         code: RegenErrorCode.BLOCK_NOT_IN_FORKCHOICE,

package/src/node/nodejs.ts

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

package/src/node/notifier.ts

@@ -167,7 +167,14 @@ function getHeadExecutionInfo(
     return [];
   }
 
-  const executionStatusStr = headInfo.executionStatus.toLowerCase();
+  // 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();
 
   // Add execution status to notifier only if head is on/post bellatrix
   if (isStatePostBellatrix(headState) && headState.isExecutionStateType) {

package/src/sync/utils/downloadByRange.ts

@@ -14,7 +14,6 @@ import {
   deneb,
   fulu,
   gloas,
-  isGloasBeaconBlock,
   isGloasDataColumnSidecar,
   phase0,
 } from "@lodestar/types";
@@ -362,7 +361,7 @@ export async function requestByRange({
   let blocks: undefined | SignedBeaconBlock[];
   let blobSidecars: undefined | deneb.BlobSidecars;
   let columnSidecars: undefined | DataColumnSidecar[];
-  const payloadEnvelopes: gloas.SignedExecutionPayloadEnvelope[] = [];
+  let payloadEnvelopes: undefined | gloas.SignedExecutionPayloadEnvelope[];
 
   const requests: Promise<unknown>[] = [];
 
@@ -370,17 +369,6 @@ export async function requestByRange({
     requests.push(
       network.sendBeaconBlocksByRange(peerIdStr, blocksRequest).then((blockResponse) => {
         blocks = blockResponse;
-        const firstBlock = blockResponse.at(0);
-        if (firstBlock && isGloasBeaconBlock(firstBlock.message)) {
-          return network
-            .sendExecutionPayloadEnvelopesByRoot(peerIdStr, [
-              firstBlock.message.body.signedExecutionPayloadBid.message.parentBlockRoot,
-            ])
-            .then((envelopeResponse) => {
-              payloadEnvelopes?.unshift(...envelopeResponse);
-            });
-        }
-        return undefined;
       })
     );
   }
@@ -404,7 +392,7 @@ export async function requestByRange({
   if (envelopesRequest) {
     requests.push(
       network.sendExecutionPayloadEnvelopesByRange(peerIdStr, envelopesRequest).then((envelopeResponse) => {
-        payloadEnvelopes?.push(...envelopeResponse);
+        payloadEnvelopes = envelopeResponse;
       })
     );
   }
@@ -1191,7 +1179,7 @@ export function validateEnvelopesByRangeResponse(
     const slot = payloadEnvelope.message.payload.slotNumber;
     const batchBlockRoot = batchBlockRoots.get(slot);
 
-    // Envelopes for slots not in the batch are silently ignored (orphaned payloads or a parent payload)
+    // Envelopes for slots not in the batch are silently ignored (orphaned payloads)
     if (batchBlockRoot === undefined) {
       continue;
     }