@lodestar/beacon-node 1.43.0-dev.4358217e12 → 1.43.0-dev.4451fec75a

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/initState.ts

@@ -1,7 +1,8 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ZERO_HASH} from "@lodestar/params";
+import {ForkPostGloas, ForkSeq, ZERO_HASH} from "@lodestar/params";
 import {
   BeaconStateAllForks,
+  BeaconStateGloas,
   IBeaconStateView,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
@@ -52,6 +53,13 @@ export function createGenesisBlock(config: ChainForkConfig, genesisState: Beacon
   const genesisBlock = types.SignedBeaconBlock.defaultValue();
   const stateRoot = genesisState.hashTreeRoot();
   genesisBlock.message.stateRoot = stateRoot;
+
+  if (config.getForkSeq(GENESIS_SLOT) >= ForkSeq.gloas) {
+    const gloasBlock = genesisBlock as SignedBeaconBlock<ForkPostGloas>;
+    const gloasState = genesisState as BeaconStateGloas;
+    gloasBlock.message.body.signedExecutionPayloadBid.message = gloasState.latestExecutionPayloadBid.toValue();
+  }
+
   return genesisBlock;
 }
 

package/src/chain/lightClient/index.ts

@@ -1,12 +1,6 @@
 import {BitArray} from "@chainsafe/ssz";
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {
-  LightClientUpdateSummary,
-  isBetterUpdate,
-  toLightClientUpdateSummary,
-  upgradeLightClientHeader,
-} from "@lodestar/light-client/spec";
 import {
   ForkName,
   ForkPostAltair,
@@ -27,6 +21,12 @@ import {
   computeSyncPeriodAtSlot,
   executionPayloadToPayloadHeader,
 } from "@lodestar/state-transition";
+import {
+  LightClientUpdateSummary,
+  isBetterUpdate,
+  toLightClientUpdateSummary,
+  upgradeLightClientHeader,
+} from "@lodestar/state-transition/light-client";
 import {
   BeaconBlock,
   BeaconBlockBody,

package/src/chain/opPools/payloadAttestationPool.ts

@@ -57,7 +57,7 @@ export class PayloadAttestationPool {
   add(
     message: gloas.PayloadAttestationMessage,
     payloadAttDataRootHex: RootHex,
-    validatorCommitteeIndex: number
+    validatorCommitteeIndices: number[]
   ): InsertOutcome {
     const slot = message.data.slot;
     const lowestPermissibleSlot = this.lowestPermissibleSlot;
@@ -85,10 +85,10 @@ export class PayloadAttestationPool {
     const aggregate = aggregateByDataRoot.get(payloadAttDataRootHex);
     if (aggregate) {
       // Aggregate msg into aggregate
-      return aggregateMessageInto(message, validatorCommitteeIndex, aggregate);
+      return aggregateMessageInto(message, validatorCommitteeIndices, aggregate);
     }
     // Create a new aggregate with data
-    aggregateByDataRoot.set(payloadAttDataRootHex, messageToAggregate(message, validatorCommitteeIndex));
+    aggregateByDataRoot.set(payloadAttDataRootHex, messageToAggregate(message, validatorCommitteeIndices));
 
     return InsertOutcome.NewData;
   }
@@ -119,31 +119,80 @@ export class PayloadAttestationPool {
       .map(fastToPayloadAttestation);
   }
 
+  getAll(slot?: Slot): gloas.PayloadAttestation[] {
+    const aggregates: AggregateFast[] = [];
+
+    const addAggregates = (aggregateByDataRootByBlockRoot: Map<BlockRootHex, Map<DataRootHex, AggregateFast>>) => {
+      for (const aggregateByDataRoot of aggregateByDataRootByBlockRoot.values()) {
+        aggregates.push(...aggregateByDataRoot.values());
+      }
+    };
+
+    if (slot !== undefined) {
+      const aggregateByDataRootByBlockRoot = this.aggregateByDataRootByBlockRootBySlot.get(slot);
+      if (aggregateByDataRootByBlockRoot) {
+        addAggregates(aggregateByDataRootByBlockRoot);
+      }
+    } else {
+      for (const aggregateByDataRootByBlockRoot of this.aggregateByDataRootByBlockRootBySlot.values()) {
+        addAggregates(aggregateByDataRootByBlockRoot);
+      }
+    }
+
+    return aggregates
+      .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
+      .map(fastToPayloadAttestation);
+  }
+
   prune(clockSlot: Slot): void {
     pruneBySlot(this.aggregateByDataRootByBlockRootBySlot, clockSlot, SLOTS_RETAINED);
     this.lowestPermissibleSlot = clockSlot;
   }
 }
 
-function messageToAggregate(message: gloas.PayloadAttestationMessage, validatorCommitteeIndex: number): AggregateFast {
+function messageToAggregate(
+  message: gloas.PayloadAttestationMessage,
+  validatorCommitteeIndices: number[]
+): AggregateFast {
+  const aggregationBits = BitArray.fromBitLen(PTC_SIZE);
+  for (const index of validatorCommitteeIndices) {
+    aggregationBits.set(index, true);
+  }
+  const sig = signatureFromBytesNoCheck(message.signature);
+  // The validator signed once but occupies `validatorCommitteeIndices.length` PTC positions.
+  // Verification aggregates the pubkey once per set bit, so the signature must be aggregated
+  // the same number of times for the BLS check to balance — same pattern as sync committee.
+  const signature =
+    validatorCommitteeIndices.length === 1
+      ? sig
+      : aggregateSignatures(new Array(validatorCommitteeIndices.length).fill(sig));
   return {
-    aggregationBits: BitArray.fromSingleBit(PTC_SIZE, validatorCommitteeIndex),
+    aggregationBits,
     data: message.data,
-    signature: signatureFromBytesNoCheck(message.signature),
+    signature,
   };
 }
 
 function aggregateMessageInto(
   message: gloas.PayloadAttestationMessage,
-  validatorCommitteeIndex: number,
+  validatorCommitteeIndices: number[],
   aggregate: AggregateFast
 ): InsertOutcome {
-  if (aggregate.aggregationBits.get(validatorCommitteeIndex) === true) {
+  // Gossip dedup via `seenPayloadAttesters` is keyed by (epoch, validatorIndex), so the same
+  // validator's message is never processed twice — all of its bits are set together or none.
+  // Checking the first index is sufficient.
+  if (aggregate.aggregationBits.get(validatorCommitteeIndices[0]) === true) {
     return InsertOutcome.AlreadyKnown;
   }
 
-  aggregate.aggregationBits.set(validatorCommitteeIndex, true);
-  aggregate.signature = aggregateSignatures([aggregate.signature, signatureFromBytesNoCheck(message.signature)]);
+  for (const index of validatorCommitteeIndices) {
+    aggregate.aggregationBits.set(index, true);
+  }
+  const sig = signatureFromBytesNoCheck(message.signature);
+  aggregate.signature = aggregateSignatures([
+    aggregate.signature,
+    ...new Array(validatorCommitteeIndices.length).fill(sig),
+  ]);
 
   return InsertOutcome.Aggregated;
 }

package/src/chain/prepareNextSlot.ts

@@ -4,13 +4,14 @@ import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostBellatrix} from "@lodestar/params";
 import {
   IBeaconStateView,
+  IBeaconStateViewBellatrix,
   StateHashTreeRootSource,
   computeEpochAtSlot,
   computeTimeAtSlot,
   isStatePostBellatrix,
   isStatePostGloas,
 } from "@lodestar/state-transition";
-import {Bytes32, Slot, electra} from "@lodestar/types";
+import {Bytes32, Slot} from "@lodestar/types";
 import {Logger, fromHex, isErrorAborted, sleep} from "@lodestar/utils";
 import {GENESIS_SLOT, ZERO_HASH_HEX} from "../constants/constants.js";
 import {BuilderStatus} from "../execution/builder/http.js";
@@ -165,19 +166,26 @@ export class PrepareNextSlotScheduler {
         }
 
         let parentBlockHash: Bytes32;
-        let isExtendingPayload = false;
+        // Apply parent payload once here as it's reused by EL prep and SSE emit below
+        let stateAfterParentPayload: IBeaconStateViewBellatrix = updatedPrepareState;
         if (isStatePostGloas(updatedPrepareState)) {
-          isExtendingPayload = this.chain.forkChoice.shouldExtendPayload(updatedHead.blockRoot);
-          parentBlockHash = isExtendingPayload
-            ? updatedPrepareState.latestExecutionPayloadBid.blockHash
-            : updatedPrepareState.latestExecutionPayloadBid.parentBlockHash;
+          if (this.chain.forkChoice.shouldExtendPayload(updatedHead.blockRoot)) {
+            parentBlockHash = updatedPrepareState.latestExecutionPayloadBid.blockHash;
+            // Skip applying parent payload unless we're proposing the next slot or have to emit payload_attributes events
+            if (feeRecipient !== undefined || this.chain.opts.emitPayloadAttributes === true) {
+              const parentExecutionRequests = await this.chain.getParentExecutionRequests(
+                updatedHead.slot,
+                updatedHead.blockRoot
+              );
+              stateAfterParentPayload = updatedPrepareState.withParentPayloadApplied(parentExecutionRequests);
+            }
+          } else {
+            parentBlockHash = updatedPrepareState.latestExecutionPayloadBid.parentBlockHash;
+          }
         } else {
           parentBlockHash = updatedPrepareState.latestExecutionPayloadHeader.blockHash;
         }
 
-        // Reused by the SSE emit below to avoid a second DB lookup on cache miss
-        let parentExecutionRequests: electra.ExecutionRequests | undefined;
-
         if (feeRecipient) {
           const preparationTime =
             computeTimeAtSlot(this.config, prepareSlot, this.chain.genesisTime) - Date.now() / 1000;
@@ -187,13 +195,6 @@ export class PrepareNextSlotScheduler {
           const finalizedBlockHash =
             this.chain.forkChoice.getFinalizedBlock().executionPayloadBlockHash ?? ZERO_HASH_HEX;
 
-          if (isExtendingPayload) {
-            parentExecutionRequests = await this.chain.getParentExecutionRequests(
-              updatedHead.slot,
-              updatedHead.blockRoot
-            );
-          }
-
           // awaiting here instead of throwing an async call because there is no other task
           // left for scheduler and this gives nice semantics to catch and log errors in the
           // try/catch wrapper here.
@@ -205,9 +206,8 @@ export class PrepareNextSlotScheduler {
             parentBlockHash,
             safeBlockHash,
             finalizedBlockHash,
-            updatedPrepareState,
-            feeRecipient,
-            parentExecutionRequests
+            stateAfterParentPayload,
+            feeRecipient
           );
           this.logger.verbose("PrepareNextSlotScheduler prepared new payload", {
             prepareSlot,
@@ -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);
           }
         }
 
@@ -234,20 +234,12 @@ export class PrepareNextSlotScheduler {
           (feeRecipient || this.chain.opts.emitPayloadAttributes === true) &&
           this.chain.emitter.listenerCount(routes.events.EventType.payloadAttributes)
         ) {
-          // if we didn't fetch above (not proposing), SSE still needs it here
-          if (!parentExecutionRequests && isExtendingPayload) {
-            parentExecutionRequests = await this.chain.getParentExecutionRequests(
-              updatedHead.slot,
-              updatedHead.blockRoot
-            );
-          }
           const data = getPayloadAttributesForSSE(fork as ForkPostBellatrix, this.chain, {
-            prepareState: updatedPrepareState,
+            prepareState: stateAfterParentPayload,
             prepareSlot,
             parentBlockRoot: fromHex(updatedHead.blockRoot),
             parentBlockHash,
             feeRecipient: feeRecipient ?? "0x0000000000000000000000000000000000000000",
-            parentExecutionRequests,
           });
           this.chain.emitter.emit(routes.events.EventType.payloadAttributes, {data, version: fork});
         }

package/src/chain/produceBlock/produceBlockBody.ts

@@ -49,7 +49,7 @@ import {
   ssz,
 } from "@lodestar/types";
 import {Logger, byteArrayEquals, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
-import {ZERO_HASH, ZERO_HASH_HEX} from "../../constants/index.js";
+import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../execution/engine/utils.js";
 import {
   IExecutionBuilder,
@@ -111,6 +111,7 @@ export type ProduceFullGloas = {
   executionRequests: electra.ExecutionRequests;
   blobsBundle: BlobsBundle<ForkPostGloas>;
   cells: fulu.Cell[][];
+  parentBlockRoot: Root;
 };
 export type ProduceFullFulu = {
   type: BlockType.Full;
@@ -214,19 +215,19 @@ export async function produceBlockBody<T extends BlockType>(
     });
 
     // Get execution payload from EL
+    let parentBlockHash: Bytes32;
+    let parentExecutionRequests: electra.ExecutionRequests;
+    // Apply parent payload once here as it's reused by EL prep and voluntary exit filtering below
+    let stateAfterParentPayload: IBeaconStateViewBellatrix = currentState;
     const isExtendingPayload = this.forkChoice.shouldExtendPayload(toRootHex(parentBlockRoot));
-    let parentBlockHash = isExtendingPayload
-      ? currentState.latestExecutionPayloadBid.blockHash
-      : currentState.latestExecutionPayloadBid.parentBlockHash;
-    // At gloas genesis the committed bid has no prior EL block to reference
-    // (`bid.parentBlockHash` is zero). Fall back to `bid.blockHash` (= eth1 genesis hash) so the
-    // FCU to the EL carries a valid head. Post-genesis bids always reference a non-zero parent.
-    if (isStatePostGloas(currentState) && byteArrayEquals(parentBlockHash, ZERO_HASH)) {
+    if (isExtendingPayload) {
       parentBlockHash = currentState.latestExecutionPayloadBid.blockHash;
+      parentExecutionRequests = await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot);
+      stateAfterParentPayload = currentState.withParentPayloadApplied(parentExecutionRequests);
+    } else {
+      parentBlockHash = currentState.latestExecutionPayloadBid.parentBlockHash;
+      parentExecutionRequests = ssz.electra.ExecutionRequests.defaultValue();
     }
-    const parentExecutionRequests = isExtendingPayload
-      ? await this.getParentExecutionRequests(parentBlock.slot, parentBlock.blockRoot)
-      : ssz.electra.ExecutionRequests.defaultValue();
     const prepareRes = await prepareExecutionPayload(
       this,
       this.logger,
@@ -235,9 +236,8 @@ export async function produceBlockBody<T extends BlockType>(
       parentBlockHash,
       safeBlockHash,
       finalizedBlockHash ?? ZERO_HASH_HEX,
-      currentState,
-      feeRecipient,
-      parentExecutionRequests
+      stateAfterParentPayload,
+      feeRecipient
     );
 
     const {prepType, payloadId} = prepareRes;
@@ -296,6 +296,14 @@ export async function produceBlockBody<T extends BlockType>(
       blockSlot - 1
     );
     gloasBody.parentExecutionRequests = parentExecutionRequests;
+    // Drop voluntary exits that parent_execution_requests have invalidated (e.g. a withdrawal
+    // request initiating an exit on the same validator). Op pool selected against the unapplied
+    // state, so re-validate against the post-apply state to avoid producing an invalid block.
+    if (isExtendingPayload && commonBlockBody.voluntaryExits.length > 0) {
+      gloasBody.voluntaryExits = commonBlockBody.voluntaryExits.filter((signedVoluntaryExit) =>
+        stateAfterParentPayload.isValidVoluntaryExit(signedVoluntaryExit, false)
+      );
+    }
     blockBody = gloasBody as AssembledBodyType<T>;
 
     // Store execution payload data required to construct execution payload envelope later
@@ -304,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);
@@ -631,9 +640,12 @@ export async function prepareExecutionPayload(
   parentBlockHash: Bytes32,
   safeBlockHash: RootHex,
   finalizedBlockHash: RootHex,
+  /**
+   * Post-gloas, when extending a full parent, callers must apply
+   * parent execution payload first (see `withParentPayloadApplied`).
+   */
   state: IBeaconStateViewBellatrix,
-  suggestedFeeRecipient: string,
-  parentExecutionRequests?: electra.ExecutionRequests
+  suggestedFeeRecipient: string
 ): Promise<{prepType: PayloadPreparationType; payloadId: PayloadId}> {
   const timestamp = computeTimeAtSlot(chain.config, state.slot, state.genesisTime);
   const prevRandao = state.getRandaoMix(state.epoch);
@@ -670,7 +682,6 @@ export async function prepareExecutionPayload(
       parentBlockRoot,
       parentBlockHash,
       feeRecipient: suggestedFeeRecipient,
-      parentExecutionRequests,
     });
 
     payloadId = await chain.executionEngine.notifyForkchoiceUpdate(
@@ -729,14 +740,16 @@ export function getPayloadAttributesForSSE(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
-    parentExecutionRequests,
   }: {
+    /**
+     * Post-gloas, when extending a full parent, callers must apply
+     * parent execution payload first (see `withParentPayloadApplied`).
+     */
     prepareState: IBeaconStateViewBellatrix;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     parentBlockHash: Bytes32;
     feeRecipient: string;
-    parentExecutionRequests?: electra.ExecutionRequests;
   }
 ): SSEPayloadAttributes {
   const payloadAttributes = preparePayloadAttributes(fork, chain, {
@@ -745,7 +758,6 @@ export function getPayloadAttributesForSSE(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
-    parentExecutionRequests,
   });
 
   let parentBlockNumber: number;
@@ -784,14 +796,16 @@ function preparePayloadAttributes(
     parentBlockRoot,
     parentBlockHash,
     feeRecipient,
-    parentExecutionRequests,
   }: {
+    /**
+     * Post-gloas, when extending a full parent, callers must apply
+     * parent execution payload first (see `withParentPayloadApplied`).
+     */
     prepareState: IBeaconStateViewBellatrix;
     prepareSlot: Slot;
     parentBlockRoot: Root;
     parentBlockHash: Bytes32;
     feeRecipient: string;
-    parentExecutionRequests?: electra.ExecutionRequests;
   }
 ): SSEPayloadAttributes["payloadAttributes"] {
   const timestamp = computeTimeAtSlot(chain.config, prepareSlot, prepareState.genesisTime);
@@ -810,11 +824,13 @@ function preparePayloadAttributes(
     if (isStatePostGloas(prepareState)) {
       const isExtendingPayload = byteArrayEquals(parentBlockHash, prepareState.latestExecutionPayloadBid.blockHash);
       if (isExtendingPayload) {
-        if (parentExecutionRequests === undefined) {
-          throw new Error("parentExecutionRequests required when extending full parent");
+        // applyParentExecutionPayload sets latestBlockHash = parentBid.blockHash, so a mismatch
+        // here means the caller did not apply parent payload to prepareState
+        if (!byteArrayEquals(prepareState.latestBlockHash, prepareState.latestExecutionPayloadBid.blockHash)) {
+          throw new Error("Expected state with parent execution payload applied for withdrawals");
         }
         (payloadAttributes as capella.SSEPayloadAttributes["payloadAttributes"]).withdrawals =
-          prepareState.getExpectedWithdrawalsForFullParent(parentExecutionRequests);
+          prepareState.getExpectedWithdrawals().expectedWithdrawals;
       } else {
         // When the parent block is empty, state.payloadExpectedWithdrawals holds a batch
         // already deducted from CL balances but never credited on the EL (the envelope

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,