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

package/src/chain/blocks/blockInput/blockInput.ts

@@ -895,8 +895,11 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
     return this.getAllColumnsWithSource().map(({columnSidecar}) => columnSidecar);
   }
 
+  /**
+   * Strictly checks missing sampled columns. Does NOT short-circuit on `state.hasAllData`.
+   */
   getMissingSampledColumnMeta(): MissingColumnMeta {
-    if (this.state.hasAllData) {
+    if (this.state.hasComputedAllData) {
       return {
         missing: [],
         versionedHashes: this.state.versionedHashes,

package/src/chain/blocks/importBlock.ts

@@ -69,8 +69,8 @@ export async function importBlock(
   fullyVerifiedBlock: FullyVerifiedBlock,
   opts: ImportBlockOpts
 ): Promise<void> {
-  const {blockInput, postState, parentBlockSlot, executionStatus, dataAvailabilityStatus, indexedAttestations} =
-    fullyVerifiedBlock;
+  const {blockInput, postState, parentBlockSlot, dataAvailabilityStatus, indexedAttestations} = fullyVerifiedBlock;
+  let {executionStatus} = fullyVerifiedBlock;
   const block = blockInput.getBlock();
   const source = blockInput.getBlockSource();
   const {slot: blockSlot} = block.message;
@@ -105,12 +105,23 @@ 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,
-    fork >= ForkSeq.gloas ? ExecutionStatus.PayloadSeparated : executionStatus,
+    executionStatus,
     dataAvailabilityStatus
   );
 
@@ -118,24 +129,6 @@ 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 range sync we skip triggerGetBlobs because column fetching is handled in the range path.
-  if (fork >= ForkSeq.gloas && !opts.fromRangeSync) {
-    const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
-    // PayloadEnvelopeInput is supposed to have right after we have block
-    // there are 4 sources of them: gossip, by root, by range and api
-    if (!payloadInput) {
-      throw Error(`PayloadEnvelopeInput not seeded for block ${blockRootHex} before importBlock`);
-    }
-
-    // Immediately attempt fetch of data columns from execution engine as the bid contains kzg commitments
-    // which is all the information we need so there is no reason to delay until execution payload arrives
-    // TODO GLOAS: If we want EL retries after this initial attempt, add an explicit retry policy here
-    // (for example later in the slot). Do not couple retries to incoming gossip columns.
-    // Columns fetched here feed payloadInput.addColumn, which resolves waitForAllData for any
-    // in-flight importExecutionPayload. No processExecutionPayload trigger needed from this path.
-    this.getBlobsTracker.triggerGetBlobs(payloadInput);
-  }
-
   this.metrics?.importBlock.bySource.inc({source: source.source});
   this.logger.verbose("Added block to forkchoice and state cache", {slot: blockSlot, root: blockRootHex});
 

package/src/chain/blocks/importExecutionPayload.ts

@@ -1,7 +1,7 @@
 import {routes} from "@lodestar/api";
 import {ExecutionStatus, PayloadExecutionStatus, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {DataAvailabilityStatus, isStatePostGloas} from "@lodestar/state-transition";
-import {fromHex, isErrorAborted} from "@lodestar/utils";
+import {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";
@@ -61,7 +61,6 @@ 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;
@@ -160,7 +159,7 @@ export async function importExecutionPayload(
       fork,
       envelope.payload,
       payloadInput.getVersionedHashes(),
-      fromHex(protoBlock.parentRoot),
+      envelope.parentBeaconBlockRoot,
       envelope.executionRequests
     ),
 
@@ -255,8 +254,7 @@ export async function importExecutionPayload(
       builderIndex: envelope.builderIndex,
       blockHash: blockHashHex,
       blockRoot: blockRootHex,
-      // TODO GLOAS: revisit once we support optimistic import
-      executionOptimistic: false,
+      executionOptimistic: execStatus === ExecutionStatus.Syncing,
     });
   }
 

package/src/chain/blocks/index.ts

@@ -65,7 +65,7 @@ export async function processBlocks(
   }
 
   try {
-    const {relevantBlocks, parentSlots, parentBlock} = verifyBlocksSanityChecks(this, blocks, opts);
+    const {relevantBlocks, parentSlots, parentBlock} = verifyBlocksSanityChecks(this, blocks, payloadEnvelopes, opts);
 
     // No relevant blocks, skip verifyBlocksInEpoch()
     if (relevantBlocks.length === 0 || parentBlock === null) {
@@ -109,8 +109,10 @@ export async function processBlocks(
     }
 
     const {executionStatuses} = segmentExecStatus;
-    const fullyVerifiedBlocks = relevantBlocks.map(
-      (block, i): FullyVerifiedBlock => ({
+    const verifiedBlocksBySlot = new Map<Slot, FullyVerifiedBlock>();
+    for (let i = 0; i < relevantBlocks.length; i++) {
+      const block = relevantBlocks[i];
+      verifiedBlocksBySlot.set(block.getBlock().message.slot, {
         blockInput: block,
         postState: postStates[i],
         parentBlockSlot: parentSlots[i],
@@ -121,14 +123,23 @@ export async function processBlocks(
         indexedAttestations: indexedAttestationsByBlock[i],
         // TODO: Make this param mandatory and capture in gossip
         seenTimestampSec: opts.seenTimestampSec ?? Math.floor(Date.now() / 1000),
-      })
-    );
+      });
+    }
 
-    for (const fullyVerifiedBlock of fullyVerifiedBlocks) {
-      // TODO: Consider batching importBlock too if it takes significant time
-      await importBlock.call(this, fullyVerifiedBlock, opts);
+    // Iterate slots from the original `blocks` input (which spans the entire batch including
+    // slots filtered out of `relevantBlocks`). The first batch of a checkpoint sync may contain
+    // a payload at the anchor slot whose block is already in fork-choice (added by
+    // initializeForkChoice as PENDING+EMPTY) and therefore not in verifiedBlocksBySlot — the
+    // payload still needs to be imported here to populate the anchor's FULL variant so
+    // subsequent slots can find their parent payload.
+    const slots = Array.from(new Set(blocks.map((b) => b.getBlock().message.slot)));
+    for (const slot of slots) {
+      const fullyVerifiedBlock = verifiedBlocksBySlot.get(slot);
+      if (fullyVerifiedBlock !== undefined) {
+        // TODO: Consider batching importBlock too if it takes significant time
+        await importBlock.call(this, fullyVerifiedBlock, opts);
+      }
 
-      const slot = fullyVerifiedBlock.blockInput.getBlock().message.slot;
       const payloadInput = payloadEnvelopes?.get(slot);
       if (payloadInput?.hasPayloadEnvelope()) {
         if (!payloadInput.isComplete()) {

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

@@ -311,8 +311,11 @@ export class PayloadEnvelopeInput {
     return this.state.hasAllData;
   }
 
+  /**
+   * Strictly checks missing sampled columns. Does NOT short-circuit on `state.hasAllData`.
+   */
   getMissingSampledColumnMeta(): MissingColumnMeta {
-    if (this.state.hasAllData) {
+    if (this.state.hasComputedAllData) {
       return {missing: [], versionedHashes: this.versionedHashes};
     }
 

package/src/chain/blocks/types.ts

@@ -94,7 +94,8 @@ export type ImportBlockOpts = {
  *
  * `executionStatus` reflects the outcome of execution payload verification at block-import time:
  * - pre-gloas: Valid | Syncing | PreMerge (from EL notifyNewPayload against the in-block payload)
- * - post-gloas: PayloadSeparated (payload arrives separately as an envelope and is imported later)
+ * - post-gloas: inherited from parent's chain (Valid/Syncing) by importBlock; payload arrives
+ *   separately as an envelope and creates the FULL variant later via onExecutionPayload
  */
 export type FullyVerifiedBlock = {
   blockInput: IBlockInput;

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

@@ -41,6 +41,14 @@ export function assertLinearChainSegment(
   // - EMPTY variant (no envelope for slot): execution hash is unchanged
   // null only for pre-merge parents, which cannot precede gloas blocks.
   let currentExecHash: string | null = parentBlock.executionPayloadBlockHash;
+  // Checkpoint sync first batch: parent is the anchor PENDING whose executionPayloadBlockHash
+  // is the inherited parentBlockHash semantic (= grandparent's payload), not its own payload.
+  // If parent's own payload envelope arrives in this batch, advance currentExecHash to that
+  // payload's blockHash so the segment validation sees the true EL chain head.
+  const parentPayloadInput = payloadEnvelopes?.get(parentBlock.slot);
+  if (parentPayloadInput?.hasPayloadEnvelope()) {
+    currentExecHash = parentPayloadInput.getBlockHashHex();
+  }
   // Track the execution hash before the last FULL advancement so we can recover
   // if the next block reveals that envelope was orphaned.
   let prevExecHash: string | null = currentExecHash;

package/src/chain/blocks/verifyBlock.ts

@@ -125,15 +125,17 @@ export async function verifyBlocksInEpoch(
     }> =
       fork >= ForkSeq.gloas
         ? (async () => {
-            const payloadInputsForDa: PayloadEnvelopeInput[] = [];
-            for (const input of blockInputs) {
-              const pi = payloadEnvelopes?.get(input.slot);
-              if (pi !== undefined) payloadInputsForDa.push(pi);
-            }
+            // Validate DA for ALL payloads in the Map, not just those paired with blockInputs.
+            // A checkpoint-sync batch may include a payload for a slot whose block was filtered
+            // out of relevantBlocks (e.g., the anchor at the finalized slot); that payload still
+            // needs DA validation so it can be imported in processBlocks.
+            const payloadInputsForDa: PayloadEnvelopeInput[] =
+              payloadEnvelopes !== null ? Array.from(payloadEnvelopes.values()) : [];
             const {dataAvailabilityStatuses, availableTime} = await verifyPayloadsDataAvailability(
               payloadInputsForDa,
               abortController.signal
             );
+
             const payloadDAStatuses = new Map<Slot, DataAvailabilityStatus>();
             for (let i = 0; i < payloadInputsForDa.length; i++) {
               payloadDAStatuses.set(payloadInputsForDa[i].slot, dataAvailabilityStatuses[i]);

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -46,8 +46,7 @@ type VerifyBlockExecutionResponse =
   | VerifyExecutionErrorResponse
   | {executionStatus: ExecutionStatus.Valid; lvhResponse: LVHValidResponse; execError: null}
   | {executionStatus: ExecutionStatus.Syncing; lvhResponse?: LVHValidResponse; execError: null}
-  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null}
-  | {executionStatus: ExecutionStatus.PayloadSeparated; lvhResponse: undefined; execError: null};
+  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null};
 
 /**
  * Verifies 1 or more execution payloads from a linear sequence of blocks.
@@ -145,9 +144,10 @@ export async function verifyBlockExecutionPayload(
 ): Promise<VerifyBlockExecutionResponse> {
   const block = blockInput.getBlock();
 
-  // Gloas block doesn't have execution payload. Return right away
+  // Gloas block doesn't have execution payload. Return Syncing as a placeholder; the actual
+  // status for gloas PENDING/EMPTY is derived from parent's chain in importBlock.
   if (isBlockInputNoData(blockInput)) {
-    return {executionStatus: ExecutionStatus.PayloadSeparated, lvhResponse: undefined, execError: null};
+    return {executionStatus: ExecutionStatus.Syncing, lvhResponse: undefined, execError: null};
   }
 
   /** Not null if execution is enabled */
@@ -198,6 +198,7 @@ export async function verifyBlockExecutionPayload(
         executionStatus,
         latestValidExecHash: execResult.latestValidHash,
         invalidateFromParentBlockRoot: blockInput.parentRootHex,
+        invalidateFromParentBlockHash: toRootHex(executionPayloadEnabled.parentHash),
       };
       const execError = new BlockError(block, {
         code: BlockErrorCode.EXECUTION_ENGINE_ERROR,
@@ -281,6 +282,7 @@ function getSegmentErrorResponse(
         executionStatus: ExecutionStatus.Invalid,
         latestValidExecHash: lvhResponse.latestValidExecHash,
         invalidateFromParentBlockRoot: parentBlock.blockRoot,
+        invalidateFromParentBlockHash: parentBlock.executionPayloadBlockHash,
       };
     }
   }

package/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -7,6 +7,7 @@ import {IClock} from "../../util/clock.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {IChainOptions} from "../options.js";
 import {IBlockInput} from "./blockInput/types.js";
+import {PayloadEnvelopeInput} from "./payloadEnvelopeInput/payloadEnvelopeInput.js";
 import {ImportBlockOpts} from "./types.js";
 
 /**
@@ -30,6 +31,7 @@ export function verifyBlocksSanityChecks(
     blacklistedBlocks: Map<RootHex, Slot | null>;
   },
   blocks: IBlockInput[],
+  payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
   opts: ImportBlockOpts
 ): {
   relevantBlocks: IBlockInput[];
@@ -100,13 +102,21 @@ export function verifyBlocksSanityChecks(
         const parentBlockHash = toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash);
         const parentBlockWithPayload = chain.forkChoice.getBlockHexAndBlockHash(parentRoot, parentBlockHash);
         if (!parentBlockWithPayload) {
-          throw new BlockError(block, {
-            code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
-            parentRoot,
-            parentBlockHash,
-          });
+          // Checkpoint sync: parent's FULL variant may not be in fork-choice yet because the
+          // anchor block is initialized with PENDING+EMPTY only. The parent's payload arrives
+          // in the same batch via payloadEnvelopes and will be imported by processBlocks. If
+          // a matching payload is in the Map, accept the parent as known.
+          const parentPayloadInput = payloadEnvelopes?.get(parentBlockDefaultStatus.slot);
+          if (parentPayloadInput?.getBlockHashHex() !== parentBlockHash) {
+            throw new BlockError(block, {
+              code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN,
+              parentRoot,
+              parentBlockHash,
+            });
+          }
+        } else {
+          parentBlock = parentBlockWithPayload;
         }
-        parentBlock = parentBlockWithPayload;
       }
       // Parent is known to the fork-choice
       parentBlockSlot = parentBlock.slot;

package/src/chain/blocks/verifyExecutionPayloadEnvelope.ts

@@ -20,7 +20,7 @@ export type VerifyExecutionPayloadEnvelopeOpts = {
  * performed outside this function, see `verifyExecutionPayloadEnvelopeSignature` and
  * `importExecutionPayload` which run both in parallel with this check.
  *
- * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/fork-choice.md#new-verify_execution_payload_envelope
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/fork-choice.md#new-verify_execution_payload_envelope
  */
 export function verifyExecutionPayloadEnvelope(
   config: BeaconConfig,
@@ -43,6 +43,11 @@ export function verifyExecutionPayloadEnvelope(
       `Envelope's block is not the latest block header envelope=${toRootHex(envelope.beaconBlockRoot)} latestBlockHeader=${toRootHex(headerRoot)}`
     );
   }
+  if (!byteArrayEquals(envelope.parentBeaconBlockRoot, state.latestBlockHeader.parentRoot)) {
+    throw new Error(
+      `Envelope's parent_beacon_block_root mismatch envelope=${toRootHex(envelope.parentBeaconBlockRoot)} state=${toRootHex(state.latestBlockHeader.parentRoot)}`
+    );
+  }
 
   // Verify consistency with the committed bid
   const bid = state.latestExecutionPayloadBid;
@@ -108,7 +113,7 @@ export function verifyExecutionPayloadEnvelope(
 /**
  * Verify the BLS signature of an execution payload envelope.
  *
- * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/fork-choice.md#new-verify_execution_payload_envelope_signature
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/fork-choice.md#new-verify_execution_payload_envelope_signature
  */
 export async function verifyExecutionPayloadEnvelopeSignature(
   config: BeaconConfig,

package/src/chain/chain.ts

@@ -335,15 +335,6 @@ export class BeaconChain implements IBeaconChain {
       metrics,
       logger,
     });
-    this.seenPayloadEnvelopeInputCache = new SeenPayloadEnvelopeInput({
-      config,
-      clock,
-      chainEvents: emitter,
-      signal,
-      serializedCache: this.serializedCache,
-      metrics,
-      logger,
-    });
 
     this._earliestAvailableSlot = anchorState.slot;
 
@@ -423,6 +414,18 @@ export class BeaconChain implements IBeaconChain {
     this.payloadEnvelopeProcessor = new PayloadEnvelopeProcessor(this, metrics, signal);
 
     this.forkChoice = forkChoice;
+
+    this.seenPayloadEnvelopeInputCache = new SeenPayloadEnvelopeInput({
+      config,
+      clock,
+      forkChoice,
+      chainEvents: emitter,
+      signal,
+      serializedCache: this.serializedCache,
+      metrics,
+      logger,
+    });
+
     this.clock = clock;
     this.regen = regen;
     this.bls = bls;

package/src/chain/errors/proposerPreferences.ts

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

package/src/chain/prepareNextSlot.ts

@@ -222,7 +222,7 @@ export class PrepareNextSlotScheduler {
           // and head.parent (proposer-boost-reorg fallback). Anything older is evicted.
           const updatedHeadParent = this.chain.forkChoice.getBlockHexDefaultStatus(updatedHead.parentRoot);
           if (updatedHeadParent) {
-            this.chain.seenPayloadEnvelopeInputCache.pruneBelow(updatedHeadParent.slot);
+            this.chain.seenPayloadEnvelopeInputCache.pruneBelowParent(updatedHeadParent);
           }
         }
 

package/src/chain/produceBlock/produceBlockBody.ts

@@ -111,6 +111,7 @@ export type ProduceFullGloas = {
   executionRequests: electra.ExecutionRequests;
   blobsBundle: BlobsBundle<ForkPostGloas>;
   cells: fulu.Cell[][];
+  parentBlockRoot: Root;
 };
 export type ProduceFullFulu = {
   type: BlockType.Full;
@@ -311,6 +312,7 @@ export async function produceBlockBody<T extends BlockType>(
     gloasResult.executionRequests = executionRequests;
     gloasResult.blobsBundle = blobsBundle;
     gloasResult.cells = cells;
+    gloasResult.parentBlockRoot = fromHex(parentBlock.blockRoot);
 
     const fetchedTime = Date.now() / 1000 - computeTimeAtSlot(this.config, blockSlot, this.genesisTime);
     this.metrics?.blockPayload.payloadFetchedTime.observe({prepType}, fetchedTime);

package/src/chain/regen/queued.ts

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

package/src/chain/regen/regen.ts

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

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -1,7 +1,7 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {CheckpointWithHex, IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {RootHex, Slot} from "@lodestar/types";
+import {RootHex} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
@@ -16,6 +16,7 @@ export {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 export type SeenPayloadEnvelopeInputModules = {
   config: ChainForkConfig;
   clock: IClock;
+  forkChoice: IForkChoice;
   chainEvents: ChainEventEmitter;
   signal: AbortSignal;
   serializedCache: SerializedCache;
@@ -39,6 +40,7 @@ export type SeenPayloadEnvelopeInputModules = {
 export class SeenPayloadEnvelopeInput {
   private readonly config: ChainForkConfig;
   private readonly clock: IClock;
+  private readonly forkChoice: IForkChoice;
   private readonly chainEvents: ChainEventEmitter;
   private readonly signal: AbortSignal;
   private readonly serializedCache: SerializedCache;
@@ -46,9 +48,19 @@ export class SeenPayloadEnvelopeInput {
   private readonly logger?: Logger;
   private payloadInputs = new Map<RootHex, PayloadEnvelopeInput>();
 
-  constructor({config, clock, chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+  constructor({
+    config,
+    clock,
+    forkChoice,
+    chainEvents,
+    signal,
+    serializedCache,
+    metrics,
+    logger,
+  }: SeenPayloadEnvelopeInputModules) {
     this.config = config;
     this.clock = clock;
+    this.forkChoice = forkChoice;
     this.chainEvents = chainEvents;
     this.signal = signal;
     this.serializedCache = serializedCache;
@@ -67,14 +79,27 @@ export class SeenPayloadEnvelopeInput {
       });
     }
 
-    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.onFinalized);
+    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.pruneFinalized);
     this.signal.addEventListener("abort", () => {
-      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.onFinalized);
+      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.pruneFinalized);
     });
   }
 
-  private onFinalized = (checkpoint: CheckpointWithHex): void => {
-    this.pruneBelow(computeStartSlotAtEpoch(checkpoint.epoch));
+  private pruneFinalized = (checkpoint: CheckpointWithHex): void => {
+    const finalizedSlot = computeStartSlotAtEpoch(checkpoint.epoch);
+    let deletedCount = 0;
+    for (const [, input] of this.payloadInputs) {
+      if (input.slot < finalizedSlot) {
+        this.evictPayloadInput(input);
+        deletedCount++;
+      }
+    }
+
+    this.logger?.debug("SeenPayloadEnvelopeInput.pruneFinalized deleted entries", {
+      finalizedSlot,
+      finalizedRoot: checkpoint.rootHex,
+      deletedCount,
+    });
   };
 
   add(props: Omit<CreateFromBlockProps, "daOutOfRange">): PayloadEnvelopeInput {
@@ -110,15 +135,19 @@ export class SeenPayloadEnvelopeInput {
     return this.payloadInputs.size;
   }
 
-  pruneBelow(slot: Slot): void {
-    let deletedCount = 0;
-    for (const [, input] of this.payloadInputs) {
-      if (input.slot < slot) {
-        this.evictPayloadInput(input);
-        deletedCount++;
+  pruneBelowParent(parentBlock: ProtoBlock): void {
+    for (const block of this.forkChoice.getAllAncestorBlocks(parentBlock.blockRoot, parentBlock.payloadStatus)) {
+      if (block.slot < parentBlock.slot) {
+        const input = this.payloadInputs.get(block.blockRoot);
+        if (input) {
+          this.evictPayloadInput(input);
+          this.logger?.verbose("SeenPayloadEnvelopeInput.pruneBelowParent deleted", {
+            slot: block.slot,
+            root: block.blockRoot,
+          });
+        }
       }
     }
-    this.logger?.debug("SeenPayloadEnvelopeInput.pruneBelow deleted entries", {slot, deletedCount});
   }
 
   private evictPayloadInput(payloadInput: PayloadEnvelopeInput): void {

package/src/chain/seenCache/seenProposerPreferences.ts

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