@lodestar/beacon-node 1.43.0-dev.a140dd987e → 1.43.0-dev.a6d8600051

package/src/api/impl/beacon/pool/index.ts

@@ -1,17 +1,27 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
-import {ForkPostElectra, ForkPreElectra, SYNC_COMMITTEE_SUBNET_SIZE, isForkPostElectra} from "@lodestar/params";
+import {
+  ForkPostElectra,
+  ForkPreElectra,
+  SYNC_COMMITTEE_SUBNET_SIZE,
+  isForkPostElectra,
+  isForkPostGloas,
+} from "@lodestar/params";
 import {isStatePostAltair} from "@lodestar/state-transition";
 import {Attestation, Epoch, SingleAttestation, isElectraAttestation, ssz, sszTypesFor} from "@lodestar/types";
+import {toRootHex} from "@lodestar/utils";
 import {
   AttestationError,
   AttestationErrorCode,
   GossipAction,
+  PayloadAttestationError,
+  PayloadAttestationErrorCode,
   SyncCommitteeError,
 } from "../../../../chain/errors/index.js";
 import {validateApiAttesterSlashing} from "../../../../chain/validation/attesterSlashing.js";
 import {validateApiBlsToExecutionChange} from "../../../../chain/validation/blsToExecutionChange.js";
 import {toElectraSingleAttestation, validateApiAttestation} from "../../../../chain/validation/index.js";
+import {validateApiPayloadAttestationMessage} from "../../../../chain/validation/payloadAttestationMessage.js";
 import {validateApiProposerSlashing} from "../../../../chain/validation/proposerSlashing.js";
 import {validateApiSyncCommittee} from "../../../../chain/validation/syncCommittee.js";
 import {validateApiVoluntaryExit} from "../../../../chain/validation/voluntaryExit.js";
@@ -62,6 +72,15 @@ export function getBeaconPoolApi({
       return {data: attestations, meta: {version: fork}};
     },
 
+    async getPoolPayloadAttestations({slot}) {
+      const fork = chain.config.getForkName(slot ?? chain.clock.currentSlot);
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `Payload attestation pool is not supported before Gloas fork=${fork}`);
+      }
+
+      return {data: chain.payloadAttestationPool.getAll(slot), meta: {version: fork}};
+    },
+
     async getPoolAttesterSlashings() {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
 
@@ -231,6 +250,69 @@ export function getBeaconPoolApi({
       }
     },
 
+    async submitPayloadAttestationMessages({payloadAttestationMessages}) {
+      const failures: FailureList = [];
+
+      await Promise.all(
+        payloadAttestationMessages.map(async (payloadAttestationMessage, i) => {
+          try {
+            const validateFn = () => validateApiPayloadAttestationMessage(chain, payloadAttestationMessage);
+            const {slot, beaconBlockRoot} = payloadAttestationMessage.data;
+            const {attDataRootHex, validatorCommitteeIndex} = await validateGossipFnRetryUnknownRoot(
+              validateFn,
+              network,
+              chain,
+              slot,
+              beaconBlockRoot
+            );
+
+            const insertOutcome = chain.payloadAttestationPool.add(
+              payloadAttestationMessage,
+              attDataRootHex,
+              validatorCommitteeIndex
+            );
+            metrics?.opPool.payloadAttestationPool.apiInsertOutcome.inc({insertOutcome});
+
+            chain.forkChoice.notifyPtcMessages(
+              toRootHex(payloadAttestationMessage.data.beaconBlockRoot),
+              [validatorCommitteeIndex],
+              payloadAttestationMessage.data.payloadPresent
+            );
+
+            await network.publishPayloadAttestationMessage(payloadAttestationMessage);
+          } catch (e) {
+            const logCtx = {
+              slot: payloadAttestationMessage.data.slot,
+              validatorIndex: payloadAttestationMessage.validatorIndex,
+              beaconBlockRoot: toRootHex(payloadAttestationMessage.data.beaconBlockRoot),
+            };
+
+            if (
+              e instanceof PayloadAttestationError &&
+              e.type.code === PayloadAttestationErrorCode.PAYLOAD_ATTESTATION_ALREADY_KNOWN
+            ) {
+              logger.debug("Ignoring known payload attestation message", logCtx);
+              return;
+            }
+
+            failures.push({index: i, message: (e as Error).message});
+            logger.verbose(`Error on submitPayloadAttestationMessages [${i}]`, logCtx, e as Error);
+            if (e instanceof PayloadAttestationError && e.action === GossipAction.REJECT) {
+              chain.persistInvalidSszValue(
+                ssz.gloas.PayloadAttestationMessage,
+                payloadAttestationMessage,
+                "api_reject"
+              );
+            }
+          }
+        })
+      );
+
+      if (failures.length > 0) {
+        throw new IndexedError("Error processing payload attestation messages", failures);
+      }
+    },
+
     /**
      * POST `/eth/v1/beacon/pool/sync_committees`
      *

package/src/api/impl/lodestar/index.ts

@@ -118,7 +118,7 @@ export function getLodestarApi({
       return {
         // biome-ignore lint/complexity/useLiteralKeys: The `blockProcessor` is a protected attribute
         data: (chain as BeaconChain)["blockProcessor"].jobQueue.getItems().map((item) => {
-          const [blockInputs, opts] = item.args;
+          const [blockInputs, _payloadEnvelopes, opts] = item.args;
           return {
             blockSlots: blockInputs.map((blockInput) => blockInput.slot),
             jobOpts: opts,

package/src/api/impl/validator/index.ts

@@ -26,6 +26,7 @@ import {
   computeTimeAtSlot,
   getCurrentSlot,
   isStatePostAltair,
+  isStatePostGloas,
   proposerShufflingDecisionRoot,
 } from "@lodestar/state-transition";
 import {
@@ -1049,6 +1050,36 @@ export function getValidatorApi(
       };
     },
 
+    async producePayloadAttestationData({slot}) {
+      const fork = config.getForkName(slot);
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `producePayloadAttestationData is not supported before Gloas fork=${fork}`);
+      }
+
+      notWhileSyncing();
+      await waitForSlot(slot);
+
+      const block = chain.forkChoice.getCanonicalBlockClosestLteSlot(slot);
+      if (!block) {
+        throw new ApiError(404, `No canonical block found at or before slot=${slot}`);
+      }
+
+      const blockIsForSlot = block.slot === slot;
+      const payloadInput = chain.seenPayloadEnvelopeInputCache.get(block.blockRoot);
+      const payloadPresent = blockIsForSlot && (payloadInput?.hasPayloadEnvelope() ?? false);
+      const blobDataAvailable = blockIsForSlot && (payloadInput?.hasAllData() ?? false);
+
+      return {
+        data: {
+          beaconBlockRoot: fromHex(block.blockRoot),
+          slot,
+          payloadPresent,
+          blobDataAvailable,
+        },
+        meta: {version: fork},
+      };
+    },
+
     /**
      * GET `/eth/v1/validator/sync_committee_contribution`
      *
@@ -1263,6 +1294,55 @@ export function getValidatorApi(
       };
     },
 
+    async getPtcDuties({epoch, indices}) {
+      notWhileSyncing();
+
+      if (indices.length === 0) {
+        throw new ApiError(400, "No validator to get PTC duties");
+      }
+
+      const startSlot = computeStartSlotAtEpoch(epoch);
+      const fork = config.getForkName(startSlot);
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `PTC duties are not supported before Gloas fork=${fork}`);
+      }
+
+      await waitForNextClosestEpoch();
+
+      if (epoch > chain.clock.currentEpoch + 1) {
+        throw new ApiError(400, "Cannot get PTC duties for epoch more than one ahead");
+      }
+
+      const head = chain.forkChoice.getHead();
+      const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.getDuties);
+      if (!isStatePostGloas(state)) {
+        throw new ApiError(400, `PTC duties are not available before Gloas fork=${state.forkName}`);
+      }
+
+      const pubkeys = getPubkeysForIndices(state, indices);
+      const ptcs = state.getEpochPTCs(epoch);
+      const duties: routes.validator.PtcDuty[] = [];
+      for (let i = 0, len = indices.length; i < len; i++) {
+        const validatorIndex = indices[i];
+        for (let j = 0; j < SLOTS_PER_EPOCH; j++) {
+          if (ptcs[j].indexOf(validatorIndex) !== -1) {
+            duties.push({pubkey: pubkeys[i], validatorIndex, slot: j + startSlot});
+            break;
+          }
+        }
+      }
+
+      const dependentRoot = fromHex(state.getShufflingDecisionRoot(epoch)) || (await getGenesisBlockRoot(state));
+
+      return {
+        data: duties,
+        meta: {
+          dependentRoot: toRootHex(dependentRoot),
+          executionOptimistic: isOptimisticBlock(head),
+        },
+      };
+    },
+
     /**
      * `POST /eth/v1/validator/duties/sync/{epoch}`
      *

package/src/chain/blocks/importBlock.ts

@@ -135,8 +135,9 @@ export async function importBlock(
   // Some block event handlers require state being in state cache so need to do this before emitting EventType.block
   this.regen.processState(blockRootHex, postState);
 
-  // For Gloas blocks, create PayloadEnvelopeInput so it's available for later payload import
-  if (fork >= ForkSeq.gloas) {
+  // For range sync, PayloadEnvelope is created before reaching this
+  // we also don't need to trigger getBlobs() in that case
+  if (fork >= ForkSeq.gloas && !opts.fromRangeSync) {
     const payloadInput = this.seenPayloadEnvelopeInputCache.add({
       blockRootHex,
       block: block as SignedBeaconBlock<ForkPostGloas>,

package/src/chain/blocks/importExecutionPayload.ts

@@ -1,7 +1,8 @@
 import {routes} from "@lodestar/api";
-import {ExecutionStatus, PayloadExecutionStatus} from "@lodestar/fork-choice";
-import {isStatePostGloas} from "@lodestar/state-transition";
-import {fromHex} from "@lodestar/utils";
+import {ExecutionStatus, PayloadExecutionStatus, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
+import {DataAvailabilityStatus, isStatePostGloas} from "@lodestar/state-transition";
+import {fromHex, isErrorAborted} from "@lodestar/utils";
+import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {ExecutionPayloadStatus} from "../../execution/index.js";
 import {isQueueErrorAborted} from "../../util/queue/index.js";
 import {BeaconChain} from "../chain.js";
@@ -75,21 +76,24 @@ function toForkChoiceExecutionStatus(status: ExecutionPayloadStatus): PayloadExe
  * The envelope is only verified here, no state mutation. State effects from the payload
  * are applied on the next block via processParentExecutionPayload.
  *
+ * The DA wait must have run upstream (range sync awaits DA in `verifyBlocksInEpoch` for the
+ * whole segment; gossip / API path uses the `processExecutionPayload` wrapper below).
+ *
  * Steps:
  * 1. Emit `execution_payload_available` event for payload attestation
  * 2. Get the ProtoBlock from fork choice
- * 3. Wait for data columns to be available
- * 4. Regenerate state for envelope verification
- * 5. Verify envelope (fields against state, signature, and EL in parallel where possible)
- * 6. Persist verified payload envelope to hot DB (waits for write-queue space for backpressure)
- * 7. Update fork choice (transitions the block's PENDING variant to FULL)
+ * 3. Regenerate state for envelope verification
+ * 4. Verify envelope (fields against state, signature, and EL in parallel where possible)
+ * 5. Persist verified payload envelope to hot DB (waits for write-queue space for backpressure)
+ * 6. Update fork choice (transitions the block's PENDING variant to FULL)
+ * 7. Queue notifyForkchoiceUpdate to engine api
  * 8. Record metrics for payload envelope and column sources
  * 9. Emit `execution_payload` event
  */
 export async function importExecutionPayload(
   this: BeaconChain,
   payloadInput: PayloadEnvelopeInput,
-  signal: AbortSignal,
+  dataAvailabilityStatus: DataAvailabilityStatus,
   opts: ImportPayloadOpts = {}
 ): Promise<void> {
   const signedEnvelope = payloadInput.getPayloadEnvelope();
@@ -119,11 +123,7 @@ export async function importExecutionPayload(
     });
   }
 
-  // 3. Wait for data columns to be available.
-  // The helper is shared with future gloas sync services; take the single-item batch form here.
-  await verifyPayloadsDataAvailability([payloadInput], signal);
-
-  // 4. Regenerate state for envelope verification
+  // 3. Regenerate state for envelope verification
   const blockState = await this.regen.getBlockSlotState(
     protoBlock,
     protoBlock.slot,
@@ -137,7 +137,7 @@ export async function importExecutionPayload(
     });
   }
 
-  // 5. Verify envelope fields against state first to fail fast before the EL + BLS work.
+  // 4. Verify envelope fields against state first to fail fast before the EL + BLS work.
   // When validSignature is true, gossip/API has already verified both the signature and the
   // executionRequestsRoot, so we skip those checks here.
   try {
@@ -154,7 +154,7 @@ export async function importExecutionPayload(
     );
   }
 
-  // 5a. Run EL and signature verification in parallel
+  // 4a. Run EL and signature verification in parallel
   const [execResult, signatureValid] = await Promise.all([
     this.executionEngine.notifyNewPayload(
       fork,
@@ -176,12 +176,12 @@ export async function importExecutionPayload(
         ),
   ]);
 
-  // 5b. Check signature verification result
+  // 4b. Check signature verification result
   if (!signatureValid) {
     throw new PayloadError({code: PayloadErrorCode.INVALID_SIGNATURE});
   }
 
-  // 5c. Handle EL response
+  // 4c. Handle EL response
   switch (execResult.status) {
     case ExecutionPayloadStatus.VALID:
       break;
@@ -207,7 +207,7 @@ export async function importExecutionPayload(
       });
   }
 
-  // 6. Persist payload envelope to hot DB. Wait for write-queue space here to apply backpressure
+  // 5. Persist payload envelope to hot DB. Wait for write-queue space here to apply backpressure
   // on the import pipeline during sync, then perform the write asynchronously to avoid blocking.
   await this.unfinalizedPayloadEnvelopeWrites.waitForSpace();
   this.unfinalizedPayloadEnvelopeWrites.push(payloadInput).catch((e) => {
@@ -220,9 +220,27 @@ export async function importExecutionPayload(
     }
   });
 
-  // 7. Update fork choice, transitions the block's PENDING variant to FULL
+  // 6. Update fork choice, transitions the block's PENDING variant to FULL
   const execStatus = toForkChoiceExecutionStatus(execResult.status);
-  this.forkChoice.onExecutionPayload(blockRootHex, blockHashHex, envelope.payload.blockNumber, execStatus);
+  this.forkChoice.onExecutionPayload(
+    blockRootHex,
+    blockHashHex,
+    envelope.payload.blockNumber,
+    execStatus,
+    dataAvailabilityStatus
+  );
+
+  // 7. Queue notifyForkchoiceUpdate to engine api
+  const head = this.forkChoice.getHead();
+  if (!this.opts.disableImportExecutionFcU && blockRootHex === head.blockRoot) {
+    const safeBlockHash = getSafeExecutionBlockHash(this.forkChoice);
+    const finalizedBlockHash = this.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
+    this.executionEngine.notifyForkchoiceUpdate(fork, blockHashHex, safeBlockHash, finalizedBlockHash).catch((e) => {
+      if (!isErrorAborted(e) && !isQueueErrorAborted(e)) {
+        this.logger.error("Error pushing notifyForkchoiceUpdate()", {blockHashHex, finalizedBlockHash}, e);
+      }
+    });
+  }
 
   // 8. Record metrics for payload envelope and column sources
   this.metrics?.importPayload.bySource.inc({source: payloadInput.getPayloadEnvelopeSource().source});
@@ -249,3 +267,21 @@ export async function importExecutionPayload(
     blockHash: blockHashHex,
   });
 }
+
+/**
+ * Process an execution payload envelope end-to-end: wait for DA, then import.
+ *
+ * Used by the PayloadEnvelopeProcessor queue (gossip / API / unknown-payload sync) — i.e.
+ * callers that have NOT already awaited DA themselves. Range sync's inline dispatch in
+ * processBlocks skips this wrapper and calls `importExecutionPayload` directly, since
+ * `verifyBlocksInEpoch` already awaited DA for the segment.
+ */
+export async function processExecutionPayload(
+  this: BeaconChain,
+  payloadInput: PayloadEnvelopeInput,
+  signal: AbortSignal,
+  opts: ImportPayloadOpts = {}
+): Promise<void> {
+  const {dataAvailabilityStatuses} = await verifyPayloadsDataAvailability([payloadInput], signal);
+  await importExecutionPayload.call(this, payloadInput, dataAvailabilityStatuses[0], opts);
+}

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,16 +57,13 @@ 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);
 
@@ -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
@@ -92,7 +116,7 @@ export async function processBlocks(
         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
@@ -103,6 +127,22 @@ export async function processBlocks(
     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()) {
+          // 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});
+      }
+
       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>();
 
@@ -87,6 +88,7 @@ export class PayloadEnvelopeInput {
     sampledColumns: ColumnIndex[];
     custodyColumns: ColumnIndex[];
     timeCreatedSec: number;
+    daOutOfRange: boolean;
   }) {
     this.blockRootHex = props.blockRootHex;
     this.slot = props.slot;
@@ -97,13 +99,14 @@ 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};
@@ -125,6 +128,7 @@ export class PayloadEnvelopeInput {
       sampledColumns: props.sampledColumns,
       custodyColumns: props.custodyColumns,
       timeCreatedSec: props.timeCreatedSec,
+      daOutOfRange: props.daOutOfRange,
     });
   }
 

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
@@ -30,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, signal, opts);
+        return processExecutionPayload.call(chain, payloadInput, signal, opts);
       },
       {maxLength: QUEUE_MAX_LENGTH, noYieldIfOneItem: true, signal},
       metrics?.payloadEnvelopeProcessorQueue ?? undefined

package/src/chain/blocks/types.ts

@@ -1,5 +1,5 @@
 import type {ChainForkConfig} from "@lodestar/config";
-import {BlockExecutionStatus} 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";
@@ -107,5 +107,5 @@ export type FullyVerifiedBlock = {
   /** Seen timestamp seconds */
   seenTimestampSec: number;
   /** If the execution payload couldn't be verified because of EL syncing status, used in optimistic sync */
-  executionStatus: BlockExecutionStatus;
+  executionStatus: BlockExecutionStatus | PayloadExecutionStatus;
 };