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

package/src/chain/blocks/types.ts

@@ -90,7 +90,7 @@ export type ImportBlockOpts = {
 
 type FullyVerifiedBlockBase = {
   blockInput: IBlockInput;
-  postBlockState: IBeaconStateView;
+  postState: IBeaconStateView;
   parentBlockSlot: Slot;
   proposerBalanceDelta: number;
   dataAvailabilityStatus: DataAvailabilityStatus;

package/src/chain/blocks/verifyPayloadsDataAvailability.ts

@@ -0,0 +1,38 @@
+import {DataAvailabilityStatus} from "@lodestar/state-transition";
+import {gloas} from "@lodestar/types";
+import {PayloadEnvelopeInput} from "../seenCache/seenPayloadEnvelopeInput.js";
+
+// we can now wait for full 12 seconds because sync and reconstruction will try pulling
+// the data columns from the network anyway while the envelope is being processed
+export const PAYLOAD_DATA_AVAILABILITY_TIMEOUT = 12_000;
+
+/**
+ * Verifies that all payload envelope inputs have their data columns available.
+ * - Waits a max of PAYLOAD_DATA_AVAILABILITY_TIMEOUT for all data to be available
+ * - Returns the time at which all data was available
+ * - Returns the data availability status for each payload input
+ */
+export async function verifyPayloadsDataAvailability(
+  payloadInputs: PayloadEnvelopeInput[],
+  signal: AbortSignal
+): Promise<{
+  dataAvailabilityStatuses: DataAvailabilityStatus[];
+  availableTime: number;
+}> {
+  const promises: Promise<gloas.DataColumnSidecar[]>[] = [];
+  for (const payloadInput of payloadInputs) {
+    if (!payloadInput.hasAllData()) {
+      promises.push(payloadInput.waitForAllData(PAYLOAD_DATA_AVAILABILITY_TIMEOUT, signal));
+    }
+  }
+  await Promise.all(promises);
+
+  const availableTime = Math.max(0, Math.max(...payloadInputs.map((payloadInput) => payloadInput.getTimeComplete())));
+  const dataAvailabilityStatuses: DataAvailabilityStatus[] = payloadInputs.map((payloadInput) =>
+    payloadInput.getBlobKzgCommitments().length === 0
+      ? DataAvailabilityStatus.NotRequired
+      : DataAvailabilityStatus.Available
+  );
+
+  return {dataAvailabilityStatuses, availableTime};
+}

package/src/chain/chain.ts

@@ -5,7 +5,6 @@ import {BeaconConfig} from "@lodestar/config";
 import {CheckpointWithPayloadStatus, IForkChoice, ProtoBlock, UpdateHeadOpt} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
 import {
-  BUILDER_INDEX_SELF_BUILD,
   EFFECTIVE_BALANCE_INCREMENT,
   type ForkPostFulu,
   type ForkPostGloas,
@@ -24,7 +23,6 @@ import {
   getEffectiveBalancesFromStateBytes,
   isStatePostAltair,
   isStatePostElectra,
-  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {
   BeaconBlock,
@@ -93,8 +91,8 @@ import {
 } from "./opPools/index.js";
 import {IChainOptions} from "./options.js";
 import {PrepareNextSlotScheduler} from "./prepareNextSlot.js";
-import {computeNewStateRoot, computePayloadEnvelopeStateRoot} from "./produceBlock/computeNewStateRoot.js";
-import {AssembledBlockType, BlockType, ProduceFullGloas, ProduceResult} from "./produceBlock/index.js";
+import {computeNewStateRoot} from "./produceBlock/computeNewStateRoot.js";
+import {AssembledBlockType, BlockType, ProduceResult} from "./produceBlock/index.js";
 import {BlockAttributes, produceBlockBody, produceCommonBlockBody} from "./produceBlock/produceBlockBody.js";
 import {QueuedStateRegenerator, RegenCaller} from "./regen/index.js";
 import {ReprocessController} from "./reprocess.js";
@@ -118,7 +116,7 @@ import {DbCPStateDatastore, checkpointToDatastoreKey} from "./stateCache/datasto
 import {FileCPStateDatastore} from "./stateCache/datastore/file.js";
 import {CPStateDatastore} from "./stateCache/datastore/types.js";
 import {FIFOBlockStateCache} from "./stateCache/fifoBlockStateCache.js";
-import {PersistentCheckpointStateCache, fcCheckpointToHexPayload} from "./stateCache/persistentCheckpointsCache.js";
+import {PersistentCheckpointStateCache} from "./stateCache/persistentCheckpointsCache.js";
 import {CheckpointStateCache} from "./stateCache/types.js";
 import {ValidatorMonitor} from "./validatorMonitor.js";
 
@@ -685,8 +683,8 @@ export class BeaconChain implements IBeaconChain {
     checkpoint: CheckpointWithPayloadStatus
   ): {state: IBeaconStateView; executionOptimistic: boolean; finalized: boolean} | null {
     // finalized or justified checkpoint states maynot be available with PersistentCheckpointStateCache, use getCheckpointStateOrBytes() api to get Uint8Array
-    const checkpointHexPayload = fcCheckpointToHexPayload(checkpoint);
-    const cachedStateCtx = this.regen.getCheckpointStateSync(checkpointHexPayload);
+    const checkpointHex = {epoch: checkpoint.epoch, rootHex: checkpoint.rootHex};
+    const cachedStateCtx = this.regen.getCheckpointStateSync(checkpointHex);
     if (cachedStateCtx) {
       const block = this.forkChoice.getBlockDefaultStatus(
         ssz.phase0.BeaconBlockHeader.hashTreeRoot(cachedStateCtx.latestBlockHeader)
@@ -705,8 +703,8 @@ export class BeaconChain implements IBeaconChain {
   async getStateOrBytesByCheckpoint(
     checkpoint: CheckpointWithPayloadStatus
   ): Promise<{state: IBeaconStateView | Uint8Array; executionOptimistic: boolean; finalized: boolean} | null> {
-    const checkpointHexPayload = fcCheckpointToHexPayload(checkpoint);
-    const cachedStateCtx = await this.regen.getCheckpointStateOrBytes(checkpointHexPayload);
+    const checkpointHex = {epoch: checkpoint.epoch, rootHex: checkpoint.rootHex};
+    const cachedStateCtx = await this.regen.getCheckpointStateOrBytes(checkpointHex);
     if (cachedStateCtx) {
       const block = this.forkChoice.getBlockDefaultStatus(checkpoint.root);
       const finalizedEpoch = this.forkChoice.getFinalizedCheckpoint().epoch;
@@ -1062,7 +1060,7 @@ export class BeaconChain implements IBeaconChain {
       body,
     } as AssembledBlockType<T>;
 
-    const {newStateRoot, proposerReward, postBlockState} = computeNewStateRoot(this.metrics, state, block);
+    const {newStateRoot, proposerReward} = computeNewStateRoot(this.metrics, state, block);
     block.stateRoot = newStateRoot;
     const blockRoot =
       produceResult.type === BlockType.Full
@@ -1071,26 +1069,9 @@ export class BeaconChain implements IBeaconChain {
     const blockRootHex = toRootHex(blockRoot);
 
     const fork = this.config.getForkName(slot);
-    if (isForkPostGloas(fork)) {
-      // TODO GLOAS: we should retire BlockType post-gloas, may need a new enum for self vs non-self built
-      if (produceResult.type !== BlockType.Full) {
-        throw Error(`Unexpected block type=${produceResult.type} for post-gloas fork=${fork}`);
-      }
-
-      const gloasResult = produceResult as ProduceFullGloas;
-      const envelope: gloas.ExecutionPayloadEnvelope = {
-        payload: gloasResult.executionPayload,
-        executionRequests: gloasResult.executionRequests,
-        builderIndex: BUILDER_INDEX_SELF_BUILD,
-        beaconBlockRoot: blockRoot,
-        slot,
-        stateRoot: ZERO_HASH,
-      };
-      if (!isStatePostGloas(postBlockState)) {
-        throw Error(`Expected gloas+ post-state for execution payload envelope, got fork=${postBlockState.forkName}`);
-      }
-      const payloadEnvelopeStateRoot = computePayloadEnvelopeStateRoot(this.metrics, postBlockState, envelope);
-      gloasResult.payloadEnvelopeStateRoot = payloadEnvelopeStateRoot;
+    // TODO GLOAS: we should retire BlockType post-gloas, may need a new enum for self vs non-self built
+    if (isForkPostGloas(fork) && produceResult.type !== BlockType.Full) {
+      throw Error(`Unexpected block type=${produceResult.type} for post-gloas fork=${fork}`);
     }
 
     // Track the produced block for consensus broadcast validations, later validation, etc.
@@ -1338,8 +1319,8 @@ export class BeaconChain implements IBeaconChain {
     checkpoint: CheckpointWithPayloadStatus,
     blockState: IBeaconStateView
   ): {state: IBeaconStateView; stateId: string; shouldWarn: boolean} {
-    const checkpointHexPayload = fcCheckpointToHexPayload(checkpoint);
-    const state = this.regen.getCheckpointStateSync(checkpointHexPayload);
+    const checkpointHex = {epoch: checkpoint.epoch, rootHex: checkpoint.rootHex};
+    const state = this.regen.getCheckpointStateSync(checkpointHex);
     if (state) {
       return {state, stateId: "checkpoint_state", shouldWarn: false};
     }

package/src/chain/emitter.ts

@@ -7,6 +7,7 @@ import {DataColumnSidecar, RootHex, deneb, phase0} from "@lodestar/types";
 import {SignedExecutionPayloadEnvelope} from "@lodestar/types/gloas";
 import {PeerIdStr} from "../util/peerId.js";
 import {BlockInputSource, IBlockInput} from "./blocks/blockInput/types.js";
+import {PayloadEnvelopeInput} from "./blocks/payloadEnvelopeInput/payloadEnvelopeInput.js";
 
 /**
  * Important chain events that occur during normal chain operation.
@@ -76,6 +77,11 @@ export enum ChainEvent {
    * cut-off window passes for waiting on gossip
    */
   incompleteBlockInput = "incompleteBlockInput",
+  /**
+   * Post-gloas: trigger BlockInputSync for payload envelopes whose envelope and/or sampled columns are partially
+   * received via gossip but are not complete by time the cut-off window passes for waiting on gossip
+   */
+  incompletePayloadEnvelope = "incompletePayloadEnvelope",
 }
 
 export type HeadEventData = routes.events.EventData[routes.events.EventType.head];
@@ -93,6 +99,11 @@ export type ChainEventData = {
   };
   [ChainEvent.unknownBlockRoot]: {rootHex: RootHex; peer?: PeerIdStr; source: BlockInputSource};
   [ChainEvent.incompleteBlockInput]: {blockInput: IBlockInput; peer: PeerIdStr; source: BlockInputSource};
+  [ChainEvent.incompletePayloadEnvelope]: {
+    payloadInput: PayloadEnvelopeInput;
+    peer: PeerIdStr;
+    source: BlockInputSource;
+  };
   [ChainEvent.unknownEnvelopeBlockRoot]: {rootHex: RootHex; peer?: PeerIdStr; source: BlockInputSource};
 };
 
@@ -116,6 +127,7 @@ export type IChainEvents = ApiEvents & {
   [ChainEvent.envelopeUnknownBlock]: (data: ChainEventData[ChainEvent.envelopeUnknownBlock]) => void;
   [ChainEvent.unknownBlockRoot]: (data: ChainEventData[ChainEvent.unknownBlockRoot]) => void;
   [ChainEvent.incompleteBlockInput]: (data: ChainEventData[ChainEvent.incompleteBlockInput]) => void;
+  [ChainEvent.incompletePayloadEnvelope]: (data: ChainEventData[ChainEvent.incompletePayloadEnvelope]) => void;
   [ChainEvent.unknownEnvelopeBlockRoot]: (data: ChainEventData[ChainEvent.unknownEnvelopeBlockRoot]) => void;
 };
 

package/src/chain/errors/attestationError.ts

@@ -147,6 +147,10 @@ export enum AttestationErrorCode {
    * Gloas: Current slot attestation is marking payload as present
    */
   PREMATURELY_INDICATED_PAYLOAD_PRESENT = "ATTESTATION_ERROR_PREMATURELY_INDICATED_PAYLOAD_PRESENT",
+  /**
+   * Gloas: index-1 attestation but the execution payload has not been seen yet
+   */
+  EXECUTION_PAYLOAD_NOT_SEEN = "ATTESTATION_ERROR_EXECUTION_PAYLOAD_NOT_SEEN",
 }
 
 export type AttestationErrorType =
@@ -185,7 +189,8 @@ export type AttestationErrorType =
   | {code: AttestationErrorCode.NON_ZERO_ATTESTATION_DATA_INDEX}
   | {code: AttestationErrorCode.ATTESTER_NOT_IN_COMMITTEE}
   | {code: AttestationErrorCode.INVALID_PAYLOAD_STATUS_VALUE; attDataIndex: number}
-  | {code: AttestationErrorCode.PREMATURELY_INDICATED_PAYLOAD_PRESENT};
+  | {code: AttestationErrorCode.PREMATURELY_INDICATED_PAYLOAD_PRESENT}
+  | {code: AttestationErrorCode.EXECUTION_PAYLOAD_NOT_SEEN; beaconBlockRoot: RootHex};
 
 export class AttestationError extends GossipActionError<AttestationErrorType> {
   getMetadata(): Record<string, string | number | null> {

package/src/chain/forkChoice/index.ts

@@ -105,10 +105,14 @@ export function initializeForkChoiceFromFinalizedState(
   const isForkPostGloas = computeEpochAtSlot(state.slot) >= config.GLOAS_FORK_EPOCH;
 
   // Determine justified checkpoint payload status
-  const justifiedPayloadStatus = getCheckpointPayloadStatus(config, state, justifiedCheckpoint.epoch);
+  const justifiedPayloadStatus = isForkPostGloas
+    ? PayloadStatus.PENDING
+    : getCheckpointPayloadStatus(config, state, justifiedCheckpoint.epoch);
 
   // Determine finalized checkpoint payload status
-  const finalizedPayloadStatus = getCheckpointPayloadStatus(config, state, finalizedCheckpoint.epoch);
+  const finalizedPayloadStatus = isForkPostGloas
+    ? PayloadStatus.PENDING
+    : getCheckpointPayloadStatus(config, state, finalizedCheckpoint.epoch);
 
   return new forkchoiceConstructor(
     config,

package/src/chain/prepareNextSlot.ts

@@ -1,6 +1,6 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {PayloadStatus, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
+import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostBellatrix} from "@lodestar/params";
 import {
   IBeaconStateView,
@@ -217,11 +217,7 @@ export class PrepareNextSlotScheduler {
       //  + if next slot is a skipped slot, it'd help getting target checkpoint state faster to validate attestations
       if (isEpochTransition) {
         this.metrics?.precomputeNextEpochTransition.count.inc({result: "success"}, 1);
-        // Determine payloadPresent from head block's payload status
-        // Pre-Gloas: payloadStatus is always FULL → payloadPresent = true
-        // Post-Gloas: FULL → true, EMPTY → false, PENDING → false (conservative, treat as block state)
-        const payloadPresent = headBlock.payloadStatus === PayloadStatus.FULL;
-        const previousHits = this.chain.regen.updatePreComputedCheckpoint(headRoot, nextEpoch, payloadPresent);
+        const previousHits = this.chain.regen.updatePreComputedCheckpoint(headRoot, nextEpoch);
         if (previousHits === 0) {
           this.metrics?.precomputeNextEpochTransition.waste.inc();
         }

package/src/chain/produceBlock/computeNewStateRoot.ts

@@ -1,12 +1,10 @@
 import {
   DataAvailabilityStatus,
   ExecutionPayloadStatus,
-  G2_POINT_AT_INFINITY,
   IBeaconStateView,
-  IBeaconStateViewGloas,
   StateHashTreeRootSource,
 } from "@lodestar/state-transition";
-import {BeaconBlock, BlindedBeaconBlock, Gwei, Root, gloas} from "@lodestar/types";
+import {BeaconBlock, BlindedBeaconBlock, Gwei, Root} from "@lodestar/types";
 import {ZERO_HASH} from "../../constants/index.js";
 import {Metrics} from "../../metrics/index.js";
 
@@ -19,11 +17,11 @@ export function computeNewStateRoot(
   metrics: Metrics | null,
   state: IBeaconStateView,
   block: BeaconBlock | BlindedBeaconBlock
-): {newStateRoot: Root; proposerReward: Gwei; postBlockState: IBeaconStateView} {
+): {newStateRoot: Root; proposerReward: Gwei; postState: IBeaconStateView} {
   // Set signature to zero to re-use stateTransition() function which requires the SignedBeaconBlock type
   const blockEmptySig = {message: block, signature: ZERO_HASH};
 
-  const postBlockState = state.stateTransition(
+  const postState = state.stateTransition(
     blockEmptySig,
     {
       // ExecutionPayloadStatus.valid: Assume payload valid, it has been produced by a trusted EL
@@ -42,49 +40,14 @@ export function computeNewStateRoot(
     {metrics}
   );
 
-  const {attestations, syncAggregate, slashing} = postBlockState.proposerRewards;
+  const {attestations, syncAggregate, slashing} = postState.proposerRewards;
   const proposerReward = BigInt(attestations + syncAggregate + slashing);
 
   const hashTreeRootTimer = metrics?.stateHashTreeRootTime.startTimer({
     source: StateHashTreeRootSource.computeNewStateRoot,
   });
-  const newStateRoot = postBlockState.hashTreeRoot();
+  const newStateRoot = postState.hashTreeRoot();
   hashTreeRootTimer?.();
 
-  return {newStateRoot, proposerReward, postBlockState};
-}
-
-/**
- * Compute the state root after processing an execution payload envelope.
- * Similar to `computeNewStateRoot` but for payload envelope processing.
- *
- */
-export function computePayloadEnvelopeStateRoot(
-  metrics: Metrics | null,
-  postBlockState: IBeaconStateViewGloas,
-  envelope: gloas.ExecutionPayloadEnvelope
-): Root {
-  const signedEnvelope: gloas.SignedExecutionPayloadEnvelope = {
-    message: envelope,
-    signature: G2_POINT_AT_INFINITY,
-  };
-
-  const processEnvelopeTimer = metrics?.blockPayload.executionPayloadEnvelopeProcessingTime.startTimer();
-  const postPayloadState = postBlockState.processExecutionPayloadEnvelope(signedEnvelope, {
-    // Signature is zero-ed (G2_POINT_AT_INFINITY), skip verification
-    verifySignature: false,
-    // State root is being computed here, the envelope doesn't have it yet
-    verifyStateRoot: false,
-    // Preserve cache in source state, since the resulting state is not added to the state cache
-    dontTransferCache: true,
-  });
-  processEnvelopeTimer?.();
-
-  const hashTreeRootTimer = metrics?.stateHashTreeRootTime.startTimer({
-    source: StateHashTreeRootSource.computePayloadEnvelopeStateRoot,
-  });
-  const stateRoot = postPayloadState.hashTreeRoot();
-  hashTreeRootTimer?.();
-
-  return stateRoot;
+  return {newStateRoot, proposerReward, postState};
 }

package/src/chain/produceBlock/produceBlockBody.ts

@@ -111,12 +111,6 @@ export type ProduceFullGloas = {
   executionRequests: electra.ExecutionRequests;
   blobsBundle: BlobsBundle<ForkPostGloas>;
   cells: fulu.Cell[][];
-  /**
-   * Cached payload envelope state root computed during block production.
-   * This is the state root after running `processExecutionPayloadEnvelope` on the
-   * post-block state, and later used to construct the `ExecutionPayloadEnvelope`.
-   */
-  payloadEnvelopeStateRoot: Root;
 };
 export type ProduceFullFulu = {
   type: BlockType.Full;

package/src/chain/regen/errors.ts

@@ -1,4 +1,3 @@
-import {PayloadStatus} from "@lodestar/fork-choice";
 import {Root, RootHex, Slot} from "@lodestar/types";
 
 export enum RegenErrorCode {
@@ -10,8 +9,6 @@ export enum RegenErrorCode {
   BLOCK_NOT_IN_DB = "REGEN_ERROR_BLOCK_NOT_IN_DB",
   STATE_TRANSITION_ERROR = "REGEN_ERROR_STATE_TRANSITION_ERROR",
   INVALID_STATE_ROOT = "REGEN_ERROR_INVALID_STATE_ROOT",
-  UNEXPECTED_PAYLOAD_STATUS = "REGEN_ERROR_UNEXPECTED_PAYLOAD_STATUS",
-  INTERNAL_ERROR = "REGEN_ERROR_INTERNAL_ERROR",
 }
 
 export type RegenErrorType =
@@ -22,9 +19,7 @@ export type RegenErrorType =
   | {code: RegenErrorCode.TOO_MANY_BLOCK_PROCESSED; stateRoot: RootHex | Root}
   | {code: RegenErrorCode.BLOCK_NOT_IN_DB; blockRoot: RootHex | Root}
   | {code: RegenErrorCode.STATE_TRANSITION_ERROR; error: Error}
-  | {code: RegenErrorCode.INVALID_STATE_ROOT; slot: Slot; expected: RootHex; actual: RootHex}
-  | {code: RegenErrorCode.UNEXPECTED_PAYLOAD_STATUS; blockRoot: RootHex | Root; payloadStatus: PayloadStatus}
-  | {code: RegenErrorCode.INTERNAL_ERROR; message: string};
+  | {code: RegenErrorCode.INVALID_STATE_ROOT; slot: Slot; expected: RootHex; actual: RootHex};
 
 export class RegenError extends Error {
   type: RegenErrorType;

package/src/chain/regen/interface.ts

@@ -2,7 +2,7 @@ import {routes} from "@lodestar/api";
 import {ProtoBlock} from "@lodestar/fork-choice";
 import {IBeaconStateView} from "@lodestar/state-transition";
 import {BeaconBlock, Epoch, RootHex, Slot, phase0} from "@lodestar/types";
-import {CheckpointHexPayload} from "../stateCache/types.js";
+import {CheckpointHex} from "../stateCache/types.js";
 
 export enum RegenCaller {
   getDuties = "getDuties",
@@ -40,20 +40,15 @@ export interface IStateRegenerator extends IStateRegeneratorInternal {
   dumpCacheSummary(): routes.lodestar.StateCacheItem[];
   getStateSync(stateRoot: RootHex): IBeaconStateView | null;
   getPreStateSync(block: BeaconBlock): IBeaconStateView | null;
-  getCheckpointStateOrBytes(cp: CheckpointHexPayload): Promise<IBeaconStateView | Uint8Array | null>;
-  getCheckpointStateSync(cp: CheckpointHexPayload): IBeaconStateView | null;
+  getCheckpointStateOrBytes(cp: CheckpointHex): Promise<IBeaconStateView | Uint8Array | null>;
+  getCheckpointStateSync(cp: CheckpointHex): IBeaconStateView | null;
   getClosestHeadState(head: ProtoBlock): IBeaconStateView | null;
   pruneOnCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void;
   pruneOnFinalized(finalizedEpoch: Epoch): void;
-  processBlockState(blockRootHex: RootHex, postState: IBeaconStateView): void;
-  processPayloadState(payloadState: IBeaconStateView): void;
-  /**
-   * payloadPresent is true if this is payload state, false if block state.
-   * payloadPresent is always true for pre-gloas.
-   */
-  addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView, payloadPresent: boolean): void;
+  processState(blockRootHex: RootHex, postState: IBeaconStateView): void;
+  addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView): void;
   updateHeadState(newHead: ProtoBlock, maybeHeadState: IBeaconStateView): void;
-  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch, payloadPresent: boolean): number | null;
+  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null;
 }
 
 /**

package/src/chain/regen/queued.ts

@@ -5,7 +5,7 @@ import {BeaconBlock, Epoch, RootHex, Slot, isGloasBeaconBlock, phase0} from "@lo
 import {Logger, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {JobItemQueue} from "../../util/queue/index.js";
-import {BlockStateCache, CheckpointHexPayload, CheckpointStateCache} from "../stateCache/types.js";
+import {BlockStateCache, CheckpointHex, CheckpointStateCache} from "../stateCache/types.js";
 import {RegenError, RegenErrorCode} from "./errors.js";
 import {
   IStateRegenerator,
@@ -125,14 +125,14 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     return null;
   }
 
-  async getCheckpointStateOrBytes(cp: CheckpointHexPayload): Promise<IBeaconStateView | Uint8Array | null> {
+  async getCheckpointStateOrBytes(cp: CheckpointHex): Promise<IBeaconStateView | Uint8Array | null> {
     return this.checkpointStateCache.getStateOrBytes(cp);
   }
 
   /**
    * Get checkpoint state from cache
    */
-  getCheckpointStateSync(cp: CheckpointHexPayload): IBeaconStateView | null {
+  getCheckpointStateSync(cp: CheckpointHex): IBeaconStateView | null {
     return this.checkpointStateCache.get(cp);
   }
 
@@ -153,22 +153,14 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     this.blockStateCache.deleteAllBeforeEpoch(finalizedEpoch);
   }
 
-  processBlockState(blockRootHex: RootHex, postState: IBeaconStateView): void {
+  processState(blockRootHex: RootHex, postState: IBeaconStateView): void {
     this.blockStateCache.add(postState);
     this.checkpointStateCache.processState(blockRootHex, postState).catch((e) => {
       this.logger.debug("Error processing block state", {blockRootHex, slot: postState.slot}, e);
     });
   }
 
-  /**
-   * Process payload state for caching after importing execution payload.
-   */
-  processPayloadState(payloadState: IBeaconStateView): void {
-    // Add payload state to block state cache (keyed by payload state root)
-    this.blockStateCache.add(payloadState);
-  }
-
-  addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView, _payloadPresent: boolean): void {
+  addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView): void {
     this.checkpointStateCache.add(cp, item);
   }
 
@@ -205,7 +197,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     }
   }
 
-  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch, _payloadPresent: boolean): number | null {
+  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null {
     return this.checkpointStateCache.updatePreComputedCheckpoint(rootHex, epoch);
   }
 

package/src/chain/regen/regen.ts

@@ -332,11 +332,6 @@ async function processSlotsByCheckpoint(
  * emitting "checkpoint" events after every epoch processed.
  *
  * Stops processing after no more full epochs can be processed.
- *
- * Output state variant:
- * - Post-Gloas: If slots are processed, returns block state (payloadPresent=false).
- *               If no slots processed, returns preState as-is (preserves variant).
- * - Pre-Gloas: Always payloadPresent=true (no block/payload distinction).
  */
 export async function processSlotsToNearestCheckpoint(
   modules: {
@@ -380,9 +375,6 @@ export async function processSlotsToNearestCheckpoint(
     // This may becomes the "official" checkpoint state if the 1st block of epoch is skipped
     const checkpointState = postState;
     const cp = getCheckpointFromState(checkpointState);
-    // processSlots() only does epoch transitions, never processes payloads
-    // Pre-Gloas: payloadPresent is always true (execution payload embedded in block)
-    // Post-Gloas: result is a block state (payloadPresent=false)
     checkpointStateCache.add(cp, checkpointState);
     // consumers should not mutate state ever
     emitter?.emit(ChainEvent.checkpoint, cp, checkpointState);

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -9,7 +9,7 @@ import {IClock} from "../../util/clock.js";
 import {serializeState} from "../serializeState.js";
 import {CPStateDatastore, DatastoreKey} from "./datastore/index.js";
 import {MapTracker} from "./mapMetrics.js";
-import {BlockStateCache, CacheItemType, CheckpointHex, CheckpointHexPayload, CheckpointStateCache} from "./types.js";
+import {BlockStateCache, CacheItemType, CheckpointHex, CheckpointStateCache} from "./types.js";
 
 export type PersistentCheckpointStateCacheOpts = {
   /** Keep max n state epochs in memory, persist the rest to disk */
@@ -843,19 +843,6 @@ export function toCheckpointHex(checkpoint: phase0.Checkpoint): CheckpointHex {
   };
 }
 
-/** TODO GLOAS: remove after rolling back regen dual-state changes */
-export function fcCheckpointToHexPayload(checkpoint: {
-  epoch: Epoch;
-  rootHex: RootHex;
-  payloadStatus?: number;
-}): CheckpointHexPayload {
-  return {
-    epoch: checkpoint.epoch,
-    rootHex: checkpoint.rootHex,
-    payloadPresent: true,
-  };
-}
-
 export function toCheckpointKey(cp: CheckpointHex): string {
   return `${cp.rootHex}:${cp.epoch}`;
 }

package/src/chain/stateCache/types.ts

@@ -4,9 +4,6 @@ import {Epoch, RootHex, phase0} from "@lodestar/types";
 
 export type CheckpointHex = {epoch: Epoch; rootHex: RootHex};
 
-/** TODO GLOAS: payloadPresent is ignored — remove after rolling back regen dual-state changes */
-export type CheckpointHexPayload = {epoch: Epoch; rootHex: RootHex; payloadPresent: boolean};
-
 /**
  * Lodestar currently keeps two state caches around.
  *

package/src/chain/validation/aggregateAndProof.ts

@@ -90,6 +90,19 @@ async function validateAggregateAndProof(
       });
     }
 
+    // [REJECT] If `aggregate.data.index == 1` (payload present for a past
+    //   block), the execution payload for `block` passes validation.
+    // [IGNORE] When `aggregate.data.index == 1` (payload present for a past block),
+    // the corresponding execution payload for `block` has been seen (a client MAY queue
+    // attestations for processing once the payload is retrieved and SHOULD request the
+    // payload envelope via `ExecutionPayloadEnvelopesByRoot`).
+    if (block !== null && attData.index === 1 && !chain.seenPayloadEnvelope(toRootHex(attData.beaconBlockRoot))) {
+      throw new AttestationError(GossipAction.IGNORE, {
+        code: AttestationErrorCode.EXECUTION_PAYLOAD_NOT_SEEN,
+        beaconBlockRoot: toRootHex(attData.beaconBlockRoot),
+      });
+    }
+
     // [REJECT] len(committee_indices) == 1, where committee_indices = get_committee_indices(aggregate)
     committeeIndex = (aggregate as electra.Attestation).committeeBits.getSingleTrueBit();
     if (committeeIndex === null) {

package/src/chain/validation/attestation.ts

@@ -315,6 +315,19 @@ async function validateAttestationNoSignatureCheck(
             code: AttestationErrorCode.PREMATURELY_INDICATED_PAYLOAD_PRESENT,
           });
         }
+
+        // [REJECT] If `attestation.data.index == 1` (payload present for a past
+        //   block), the execution payload for `block` passes validation.
+        // [IGNORE] When `attestation.data.index == 1` (payload present for a past block),
+        // the corresponding execution payload for `block` has been seen (a client MAY queue
+        // attestations for processing once the payload is retrieved and SHOULD request the
+        // payload envelope via `ExecutionPayloadEnvelopesByRoot`).
+        if (block !== null && attData.index === 1 && !chain.seenPayloadEnvelope(toRootHex(attData.beaconBlockRoot))) {
+          throw new AttestationError(GossipAction.IGNORE, {
+            code: AttestationErrorCode.EXECUTION_PAYLOAD_NOT_SEEN,
+            beaconBlockRoot: toRootHex(attData.beaconBlockRoot),
+          });
+        }
       } else {
         // [REJECT] attestation.data.index == 0
         if (attData.index !== 0) {

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -32,7 +32,7 @@ async function validateExecutionPayloadEnvelope(
   const {payload} = envelope;
   const blockRootHex = toRootHex(envelope.beaconBlockRoot);
 
-  // [IGNORE] The envelope's block root `envelope.block_root` has been seen (via
+  // [IGNORE] The envelope's block root `envelope.beacon_block_root` has been seen (via
   // gossip or non-gossip sources) (a client MAY queue payload for processing once
   // the block is retrieved).
   // TODO GLOAS: Need to review this, we should queue the envelope for later
@@ -107,7 +107,7 @@ async function validateExecutionPayloadEnvelope(
     });
   }
 
-  // Get the post block state which is the pre-payload state to verify the builder's signature.
+  // Get the block state to verify the builder's signature.
   const blockState = await chain.regen
     .getState(block.stateRoot, RegenCaller.validateGossipPayloadEnvelope)
     .catch(() => {

package/src/network/processor/gossipHandlers.ts

@@ -745,13 +745,29 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           });
         }
 
-        chain.processExecutionPayload(payloadInput, {validSignature: true}).catch((e) => {
-          chain.logger.debug(
-            "Error processing execution payload from gossip data column",
-            {slot: dataColumnSlot, root: payloadInput.blockRootHex},
-            e as Error
-          );
-        });
+        // NOTE: we do NOT call chain.processExecutionPayload here. That is triggered only by
+        // envelope arrival (gossip or API). An in-flight importExecutionPayload is awaiting
+        // payloadInput.waitForAllData(); addColumn above will resolve it once hasAllData flips.
+
+        if (!payloadInput.isComplete()) {
+          const cutoffTimeMs = getCutoffTimeMs(chain, dataColumnSlot, BLOCK_AVAILABILITY_CUTOFF_MS);
+          // do not await here to not delay gossip validation
+          payloadInput.waitForEnvelopeAndAllData(cutoffTimeMs).catch((_e) => {
+            chain.logger.debug(
+              "Waited for envelope and data after receiving gossip column. Cut-off reached so emitting incompletePayloadEnvelope",
+              {
+                dataColumnIndex: index,
+                ...payloadInputMeta,
+              }
+            );
+            // TODO GLOAS: UnknownBlockSync to handle this event
+            chain.emitter.emit(ChainEvent.incompletePayloadEnvelope, {
+              payloadInput,
+              peer: peerIdStr,
+              source: BlockInputSource.gossip,
+            });
+          });
+        }
       } else {
         if (config.getForkSeq(dataColumnSlot) < ForkSeq.fulu) {
           throw new GossipActionError(GossipAction.REJECT, {code: "PRE_FULU_BLOCK"});