@lodestar/beacon-node 1.38.0-dev.8475d71f09 → 1.38.0-dev.889b1c4475

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -6,19 +6,11 @@ import {
   LVHValidResponse,
   MaybeValidExecutionStatus,
   ProtoBlock,
-  assertValidTerminalPowBlock,
 } from "@lodestar/fork-choice";
-import {ForkSeq, SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  isExecutionBlockBodyType,
-  isExecutionEnabled,
-  isExecutionStateType,
-  isMergeTransitionBlock as isMergeTransitionBlockFn,
-} from "@lodestar/state-transition";
-import {Slot, bellatrix, electra} from "@lodestar/types";
+import {ForkSeq} from "@lodestar/params";
+import {CachedBeaconStateAllForks, isExecutionBlockBodyType, isExecutionStateType} from "@lodestar/state-transition";
+import {bellatrix, electra} from "@lodestar/types";
 import {ErrorAborted, Logger, toRootHex} from "@lodestar/utils";
-import {IEth1ForBlockProduction} from "../../eth1/index.js";
 import {ExecutionPayloadStatus, IExecutionEngine} from "../../execution/engine/interface.js";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
@@ -29,7 +21,6 @@ import {IBlockInput} from "./blockInput/types.js";
 import {ImportBlockOpts} from "./types.js";
 
 export type VerifyBlockExecutionPayloadModules = {
-  eth1: IEth1ForBlockProduction;
   executionEngine: IExecutionEngine;
   clock: IClock;
   logger: Logger;
@@ -44,9 +35,8 @@ export type SegmentExecStatus =
       execAborted: null;
       executionStatuses: MaybeValidExecutionStatus[];
       executionTime: number;
-      mergeBlockFound: bellatrix.BeaconBlock | null;
     }
-  | {execAborted: ExecAbortType; invalidSegmentLVH?: LVHInvalidResponse; mergeBlockFound: null};
+  | {execAborted: ExecAbortType; invalidSegmentLVH?: LVHInvalidResponse};
 
 type VerifyExecutionErrorResponse =
   | {executionStatus: ExecutionStatus.Invalid; lvhResponse: LVHInvalidResponse; execError: BlockError}
@@ -72,7 +62,6 @@ export async function verifyBlocksExecutionPayload(
   opts: BlockProcessOpts & ImportBlockOpts
 ): Promise<SegmentExecStatus> {
   const executionStatuses: MaybeValidExecutionStatus[] = [];
-  let mergeBlockFound: bellatrix.BeaconBlock | null = null;
   const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
   const lastBlock = blockInputs.at(-1);
 
@@ -96,57 +85,9 @@ export async function verifyBlocksExecutionPayload(
   // will either validate or prune invalid blocks
   //
   // We need to track and keep updating if its safe to optimistically import these blocks.
-  // The following is how we determine for a block if its safe:
-  //
-  // (but we need to modify this check for this segment of blocks because it checks if the
-  //  parent of any block imported in forkchoice is post-merge and currently we could only
-  //  have blocks[0]'s parent imported in the chain as this is no longer one by one verify +
-  //  import.)
-  //
   //
   // When to import such blocks:
   // From: https://github.com/ethereum/consensus-specs/pull/2844
-  // A block MUST NOT be optimistically imported, unless either of the following
-  // conditions are met:
-  //
-  // 1. Parent of the block has execution
-  //
-  //     Since with the sync optimizations, the previous block might not have been in the
-  //     forkChoice yet, so the below check could fail for safeSlotsToImportOptimistically
-  //
-  //     Luckily, we can depend on the preState0 to see if we are already post merge w.r.t
-  //     the blocks we are importing.
-  //
-  //     Or in other words if
-  //       - block status is syncing
-  //       - and we are not in a post merge world and is parent is not optimistically safe
-  //       - and we are syncing close to the chain head i.e. clock slot
-  //       - and parent is optimistically safe
-  //
-  //      then throw error
-  //
-  //
-  //       - if we haven't yet imported a post merge ancestor in forkchoice i.e.
-  //       - and we are syncing close to the clockSlot, i.e. merge Transition could be underway
-  //
-  //
-  // 2. The current slot (as per the system clock) is at least
-  //    SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY ahead of the slot of the block being
-  //    imported.
-  //    This means that the merge transition could be underway and we can't afford to import
-  //    a block which is not fully validated as it could affect liveliness of the network.
-  //
-  //
-  // For this segment of blocks:
-  //   We are optimistically safe with respect to this entire block segment if:
-  //    - all the blocks are way behind the current slot
-  //    - or we have already imported a post-merge parent of first block of this chain in forkchoice
-  const currentSlot = chain.clock.currentSlot;
-  const safeSlotsToImportOptimistically = opts.safeSlotsToImportOptimistically ?? SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY;
-  let isOptimisticallySafe =
-    parentBlock.executionStatus !== ExecutionStatus.PreMerge ||
-    lastBlock.slot + safeSlotsToImportOptimistically < currentSlot;
-
   for (let blockIndex = 0; blockIndex < blockInputs.length; blockIndex++) {
     const blockInput = blockInputs[blockIndex];
     // If blocks are invalid in consensus the main promise could resolve before this loop ends.
@@ -154,14 +95,7 @@ export async function verifyBlocksExecutionPayload(
     if (signal.aborted) {
       throw new ErrorAborted("verifyBlockExecutionPayloads");
     }
-    const verifyResponse = await verifyBlockExecutionPayload(
-      chain,
-      blockInput,
-      preState0,
-      opts,
-      isOptimisticallySafe,
-      currentSlot
-    );
+    const verifyResponse = await verifyBlockExecutionPayload(chain, blockInput, preState0);
 
     // If execError has happened, then we need to extract the segmentExecStatus and return
     if (verifyResponse.execError !== null) {
@@ -170,75 +104,7 @@ export async function verifyBlocksExecutionPayload(
 
     // If we are here then its because executionStatus is one of MaybeValidExecutionStatus
     const {executionStatus} = verifyResponse;
-    // It becomes optimistically  safe for following blocks if a post-merge block is deemed fit
-    // for import. If it would not have been safe verifyBlockExecutionPayload would have
-    // returned execError and loop would have been aborted
-    if (executionStatus !== ExecutionStatus.PreMerge) {
-      isOptimisticallySafe = true;
-    }
     executionStatuses.push(executionStatus);
-
-    const blockBody = blockInput.getBlock().message.body;
-    const isMergeTransitionBlock =
-      // If the merge block is found, stop the search as the isMergeTransitionBlockFn condition
-      // will still evaluate to true for the following blocks leading to errors (while syncing)
-      // as the preState0 still belongs to the pre state of the first block on segment
-      mergeBlockFound === null &&
-      isExecutionStateType(preState0) &&
-      isExecutionBlockBodyType(blockBody) &&
-      isMergeTransitionBlockFn(preState0, blockBody);
-
-    // If this is a merge transition block, check to ensure if it references
-    // a valid terminal PoW block.
-    //
-    // However specs define this check to be run inside forkChoice's onBlock
-    // (https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/fork-choice.md#on_block)
-    // but we perform the check here (as inspired from the lighthouse impl)
-    //
-    // Reasons:
-    //  1. If the block is not valid, we should fail early and not wait till
-    //     forkChoice import.
-    //  2. It makes logical sense to pair it with the block validations and
-    //     deal it with the external services like eth1 tracker here than
-    //     in import block
-    if (isMergeTransitionBlock) {
-      const mergeBlock = blockInput.getBlock().message as bellatrix.BeaconBlock;
-      const mergeBlockHash = toRootHex(chain.config.getForkTypes(mergeBlock.slot).BeaconBlock.hashTreeRoot(mergeBlock));
-      const powBlockRootHex = toRootHex(mergeBlock.body.executionPayload.parentHash);
-      const powBlock = await chain.eth1.getPowBlock(powBlockRootHex).catch((error) => {
-        // Lets just warn the user here, errors if any will be reported on
-        // `assertValidTerminalPowBlock` checks
-        chain.logger.warn(
-          "Error fetching terminal PoW block referred in the merge transition block",
-          {powBlockHash: powBlockRootHex, mergeBlockHash},
-          error
-        );
-        return null;
-      });
-
-      const powBlockParent =
-        powBlock &&
-        (await chain.eth1.getPowBlock(powBlock.parentHash).catch((error) => {
-          // Lets just warn the user here, errors if any will be reported on
-          // `assertValidTerminalPowBlock` checks
-          chain.logger.warn(
-            "Error fetching parent of the terminal PoW block referred in the merge transition block",
-            {powBlockParentHash: powBlock.parentHash, powBlock: powBlockRootHex, mergeBlockHash},
-            error
-          );
-          return null;
-        }));
-
-      // executionStatus will never == ExecutionStatus.PreMerge if it's the mergeBlock. But gotta make TS happy =D
-      if (executionStatus === ExecutionStatus.PreMerge) {
-        throw Error("Merge block must not have executionStatus == PreMerge");
-      }
-
-      assertValidTerminalPowBlock(chain.config, mergeBlock, {executionStatus, powBlock, powBlockParent});
-      // Valid execution payload, but may not be in a valid beacon chain block. Delay printing the POS ACTIVATED banner
-      // to the end of the verify block routine, which confirms that this block is fully valid.
-      mergeBlockFound = mergeBlock;
-    }
   }
 
   const executionTime = Date.now();
@@ -265,7 +131,6 @@ export async function verifyBlocksExecutionPayload(
     execAborted: null,
     executionStatuses,
     executionTime,
-    mergeBlockFound,
   };
 }
 
@@ -275,28 +140,18 @@ export async function verifyBlocksExecutionPayload(
 export async function verifyBlockExecutionPayload(
   chain: VerifyBlockExecutionPayloadModules,
   blockInput: IBlockInput,
-  preState0: CachedBeaconStateAllForks,
-  opts: BlockProcessOpts,
-  isOptimisticallySafe: boolean,
-  currentSlot: Slot
+  preState0: CachedBeaconStateAllForks
 ): Promise<VerifyBlockExecutionResponse> {
   const block = blockInput.getBlock();
   /** Not null if execution is enabled */
   const executionPayloadEnabled =
-    isExecutionStateType(preState0) &&
-    isExecutionBlockBodyType(block.message.body) &&
-    // Safe to use with a state previous to block's preState. isMergeComplete can only transition from false to true.
-    // - If preState0 is after merge block: condition is true, and will always be true
-    // - If preState0 is before merge block: the block could lie but then state transition function will throw above
-    // It is kinda safe to send non-trusted payloads to the execution client because at most it can trigger sync.
-    // TODO: If this becomes a problem, do some basic verification beforehand, like checking the proposer signature.
-    isExecutionEnabled(preState0, block.message)
+    isExecutionStateType(preState0) && isExecutionBlockBodyType(block.message.body)
       ? block.message.body.executionPayload
       : null;
 
   if (!executionPayloadEnabled) {
-    // isExecutionEnabled() -> false
-    return {executionStatus: ExecutionStatus.PreMerge, execError: null} as VerifyBlockExecutionResponse;
+    // Pre-merge block, no execution payload to verify
+    return {executionStatus: ExecutionStatus.PreMerge, lvhResponse: undefined, execError: null};
   }
 
   // TODO: Handle better notifyNewPayload() returning error is syncing
@@ -343,24 +198,10 @@ export async function verifyBlockExecutionPayload(
     }
 
     // Accepted and Syncing have the same treatment, as final validation of block is pending
+    // Post-merge, we're always safe to optimistically import
     case ExecutionPayloadStatus.ACCEPTED:
-    case ExecutionPayloadStatus.SYNCING: {
-      // Check if the entire segment was deemed safe or, this block specifically itself if not in
-      // the safeSlotsToImportOptimistically window of current slot, then we can import else
-      // we need to throw and not import his block
-      const safeSlotsToImportOptimistically =
-        opts.safeSlotsToImportOptimistically ?? SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY;
-      if (!isOptimisticallySafe && blockInput.slot + safeSlotsToImportOptimistically >= currentSlot) {
-        const execError = new BlockError(block, {
-          code: BlockErrorCode.EXECUTION_ENGINE_ERROR,
-          execStatus: ExecutionPayloadStatus.UNSAFE_OPTIMISTIC_STATUS,
-          errorMessage: `not safe to import ${execResult.status} payload within ${opts.safeSlotsToImportOptimistically} of currentSlot`,
-        });
-        return {executionStatus: null, execError} as VerifyBlockExecutionResponse;
-      }
-
+    case ExecutionPayloadStatus.SYNCING:
       return {executionStatus: ExecutionStatus.Syncing, execError: null};
-    }
 
     // If the block has is not valid, or it referenced an invalid terminal block then the
     // block is invalid, however it has no bearing on any forkChoice cleanup

package/src/chain/blocks/verifyBlocksSignatures.ts

@@ -1,4 +1,4 @@
-import {CachedBeaconStateAllForks, getBlockSignatureSets} from "@lodestar/state-transition";
+import {CachedBeaconStateAllForks, Index2PubkeyCache, getBlockSignatureSets} from "@lodestar/state-transition";
 import {IndexedAttestation, SignedBeaconBlock} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
@@ -15,6 +15,7 @@ import {ImportBlockOpts} from "./types.js";
  * Since all data is known in advance all signatures are verified at once in parallel.
  */
 export async function verifyBlocksSignatures(
+  index2pubkey: Index2PubkeyCache,
   bls: IBlsVerifier,
   logger: Logger,
   metrics: Metrics | null,
@@ -38,7 +39,7 @@ export async function verifyBlocksSignatures(
       : //
         // Verify signatures per block to track which block is invalid
         bls.verifySignatureSets(
-          getBlockSignatureSets(preState0, block, indexedAttestationsByBlock[i], {
+          getBlockSignatureSets(index2pubkey, preState0, block, indexedAttestationsByBlock[i], {
             skipProposerSignature: opts.validProposerSignature,
           })
         );

package/src/chain/chain.ts

@@ -3,7 +3,7 @@ import {PrivateKey} from "@libp2p/interface";
 import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {CompositeTypeAny, TreeView, Type} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
-import {CheckpointWithHex, ExecutionStatus, IForkChoice, ProtoBlock, UpdateHeadOpt} from "@lodestar/fork-choice";
+import {CheckpointWithHex, IForkChoice, ProtoBlock, UpdateHeadOpt} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
 import {EFFECTIVE_BALANCE_INCREMENT, GENESIS_SLOT, SLOTS_PER_EPOCH, isForkPostElectra} from "@lodestar/params";
 import {
@@ -757,7 +757,7 @@ export class BeaconChain implements IBeaconChain {
       RegenCaller.produceBlock
     );
     const proposerIndex = state.epochCtx.getBeaconProposer(slot);
-    const proposerPubKey = state.epochCtx.index2pubkey[proposerIndex].toBytes();
+    const proposerPubKey = this.index2pubkey[proposerIndex].toBytes();
 
     const {body, produceResult, executionPayloadValue, shouldOverrideBuilder} = await produceBlockBody.call(
       this,
@@ -1177,17 +1177,6 @@ export class BeaconChain implements IBeaconChain {
     this.seenAggregatedAttestations.prune(epoch);
     this.seenBlockAttesters.prune(epoch);
     this.beaconProposerCache.prune(epoch);
-
-    // Poll for merge block in the background to speed-up block production. Only if:
-    // - after BELLATRIX_FORK_EPOCH
-    // - Beacon node synced
-    // - head state not isMergeTransitionComplete
-    if (this.config.BELLATRIX_FORK_EPOCH - epoch < 1) {
-      const head = this.forkChoice.getHead();
-      if (epoch - computeEpochAtSlot(head.slot) < 5 && head.executionStatus === ExecutionStatus.PreMerge) {
-        this.eth1.startPollingMergeBlock();
-      }
-    }
   }
 
   protected onNewHead(head: ProtoBlock): void {
@@ -1372,6 +1361,6 @@ export class BeaconChain implements IBeaconChain {
 
     preState = processSlots(preState, block.slot); // Dial preState's slot to block.slot
 
-    return computeSyncCommitteeRewards(block, preState.clone(), validatorIds);
+    return computeSyncCommitteeRewards(this.index2pubkey, block, preState.clone(), validatorIds);
   }
 }

package/src/chain/forkChoice/index.ts

@@ -18,7 +18,6 @@ import {
   getBlockRootAtSlot,
   getEffectiveBalanceIncrementsZeroInactive,
   isExecutionStateType,
-  isMergeTransitionComplete,
 } from "@lodestar/state-transition";
 import {Slot, ssz} from "@lodestar/types";
 import {Logger, toRootHex} from "@lodestar/utils";
@@ -135,7 +134,7 @@ export function initializeForkChoiceFromFinalizedState(
         unrealizedFinalizedEpoch: finalizedCheckpoint.epoch,
         unrealizedFinalizedRoot: toRootHex(finalizedCheckpoint.root),
 
-        ...(isExecutionStateType(state) && isMergeTransitionComplete(state)
+        ...(isExecutionStateType(state)
           ? {
               executionPayloadBlockHash: toRootHex(state.latestExecutionPayloadHeader.blockHash),
               executionPayloadNumber: state.latestExecutionPayloadHeader.blockNumber,
@@ -216,7 +215,7 @@ export function initializeForkChoiceFromUnfinalizedState(
     unrealizedFinalizedEpoch: finalizedCheckpoint.epoch,
     unrealizedFinalizedRoot: toRootHex(finalizedCheckpoint.root),
 
-    ...(isExecutionStateType(unfinalizedState) && isMergeTransitionComplete(unfinalizedState)
+    ...(isExecutionStateType(unfinalizedState)
       ? {
           executionPayloadBlockHash: toRootHex(unfinalizedState.latestExecutionPayloadHeader.blockHash),
           executionPayloadNumber: unfinalizedState.latestExecutionPayloadHeader.blockNumber,

package/src/chain/opPools/aggregatedAttestationPool.ts

@@ -22,6 +22,7 @@ import {
 import {
   CachedBeaconStateAllForks,
   CachedBeaconStateAltair,
+  CachedBeaconStateGloas,
   CachedBeaconStatePhase0,
   EffectiveBalanceIncrements,
   RootCache,
@@ -486,7 +487,10 @@ export class AggregatedAttestationPool {
             consolidation.attData,
             inclusionDistance,
             stateEpoch,
-            rootCache
+            rootCache,
+            ForkSeq[fork] >= ForkSeq.gloas
+              ? (state as CachedBeaconStateGloas).executionPayloadAvailability.toBoolArray()
+              : null
           );
 
           const weight =

package/src/chain/options.ts

@@ -1,4 +1,3 @@
-import {SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY} from "@lodestar/params";
 import {defaultOptions as defaultValidatorOptions} from "@lodestar/validator";
 import {DEFAULT_ARCHIVE_MODE} from "./archiveStore/constants.js";
 import {ArchiveMode, ArchiveStoreOpts} from "./archiveStore/interface.js";
@@ -56,10 +55,6 @@ export type BlockProcessOpts = {
    * Will double processing times. Use only for debugging purposes.
    */
   disableBlsBatchVerify?: boolean;
-  /**
-   * Override SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY
-   */
-  safeSlotsToImportOptimistically?: number;
   /**
    * Assert progressive balances the same to EpochTransitionCache
    */
@@ -109,7 +104,6 @@ export const defaultChainOptions: IChainOptions = {
   proposerBoost: true,
   proposerBoostReorg: true,
   computeUnrealized: true,
-  safeSlotsToImportOptimistically: SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY,
   suggestedFeeRecipient: defaultValidatorOptions.suggestedFeeRecipient,
   serveHistoricalState: false,
   assertCorrectProgressiveBalances: false,

package/src/chain/prepareNextSlot.ts

@@ -197,7 +197,7 @@ export class PrepareNextSlotScheduler {
           this.chain.opts.emitPayloadAttributes === true &&
           this.chain.emitter.listenerCount(routes.events.EventType.payloadAttributes)
         ) {
-          const data = await getPayloadAttributesForSSE(fork as ForkPostBellatrix, this.chain, {
+          const data = getPayloadAttributesForSSE(fork as ForkPostBellatrix, this.chain, {
             prepareState: updatedPrepareState,
             prepareSlot,
             parentBlockRoot: fromHex(headRoot),

package/src/chain/produceBlock/produceBlockBody.ts

@@ -17,10 +17,8 @@ import {
   CachedBeaconStateCapella,
   CachedBeaconStateExecutions,
   computeTimeAtSlot,
-  getCurrentEpoch,
   getExpectedWithdrawals,
   getRandaoMix,
-  isMergeTransitionComplete,
 } from "@lodestar/state-transition";
 import {
   BLSPubkey,
@@ -44,12 +42,9 @@ import {
   deneb,
   electra,
   fulu,
-  ssz,
-  sszTypesFor,
 } from "@lodestar/types";
 import {Logger, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
-import {ZERO_HASH, ZERO_HASH_HEX} from "../../constants/index.js";
-import {IEth1ForBlockProduction} from "../../eth1/index.js";
+import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../eth1/provider/utils.js";
 import {
   IExecutionBuilder,
@@ -337,14 +332,6 @@ export async function produceBlockBody<T extends BlockType>(
           feeRecipient
         );
 
-        if (prepareRes.isPremerge) {
-          return {
-            ...prepareRes,
-            executionPayload: sszTypesFor(fork).ExecutionPayload.defaultValue(),
-            executionPayloadValue: BigInt(0),
-          };
-        }
-
         const {prepType, payloadId} = prepareRes;
         Object.assign(logMeta, {executionPayloadPrepType: prepType});
 
@@ -366,37 +353,14 @@ export async function produceBlockBody<T extends BlockType>(
 
         return {...prepareRes, ...payloadRes};
       })().catch((e) => {
-        // catch payload fetch here, because there is still a recovery path possible if we
-        // are pre-merge. We don't care the same for builder segment as the execution block
-        // will takeover if the builder flow was activated and errors
         this.metrics?.blockPayload.payloadFetchErrors.inc();
-
-        if (!isMergeTransitionComplete(currentState as CachedBeaconStateBellatrix)) {
-          this.logger?.warn(
-            "Fetch payload from the execution failed, however since we are still pre-merge proceeding with an empty one.",
-            {},
-            e as Error
-          );
-          // ok we don't have an execution payload here, so we can assign an empty one
-          // if pre-merge
-          return {
-            isPremerge: true as const,
-            executionPayload: sszTypesFor(fork).ExecutionPayload.defaultValue(),
-            executionPayloadValue: BigInt(0),
-          };
-        }
-        // since merge transition is complete, we need a valid payload even if with an
-        // empty (transactions) one. defaultValue isn't gonna cut it!
         throw e;
       });
 
       const [engineRes, commonBlockBody] = await Promise.all([enginePromise, commonBlockBodyPromise]);
       blockBody = Object.assign({}, commonBlockBody) as AssembledBodyType<BlockType.Blinded>;
 
-      if (engineRes.isPremerge) {
-        (blockBody as BeaconBlockBody<ForkPostBellatrix & ForkPreGloas>).executionPayload = engineRes.executionPayload;
-        executionPayloadValue = engineRes.executionPayloadValue;
-      } else {
+      {
         const {prepType, payloadId, executionPayload, blobsBundle, executionRequests} = engineRes;
         shouldOverrideBuilder = engineRes.shouldOverrideBuilder;
 
@@ -504,15 +468,10 @@ export async function produceBlockBody<T extends BlockType>(
 }
 
 /**
- * Produce ExecutionPayload for pre-merge, merge, and post-merge.
- *
- * Expects `eth1MergeBlockFinder` to be actively searching for blocks well in advance to being called.
- *
- * @returns PayloadId = pow block found, null = pow NOT found
+ * Produce ExecutionPayload for post-merge.
  */
 export async function prepareExecutionPayload(
   chain: {
-    eth1: IEth1ForBlockProduction;
     executionEngine: IExecutionEngine;
     config: ChainForkConfig;
   },
@@ -523,14 +482,8 @@ export async function prepareExecutionPayload(
   finalizedBlockHash: RootHex,
   state: CachedBeaconStateExecutions,
   suggestedFeeRecipient: string
-): Promise<{isPremerge: true} | {isPremerge: false; prepType: PayloadPreparationType; payloadId: PayloadId}> {
-  const parentHashRes = await getExecutionPayloadParentHash(chain, state);
-  if (parentHashRes.isPremerge) {
-    // Return null only if the execution is pre-merge
-    return {isPremerge: true};
-  }
-
-  const {parentHash} = parentHashRes;
+): Promise<{prepType: PayloadPreparationType; payloadId: PayloadId}> {
+  const parentHash = state.latestExecutionPayloadHeader.blockHash;
   const timestamp = computeTimeAtSlot(chain.config, state.slot, state.genesisTime);
   const prevRandao = getRandaoMix(state, state.epochCtx.epoch);
 
@@ -586,12 +539,11 @@ export async function prepareExecutionPayload(
   // We are only returning payloadId here because prepareExecutionPayload is also called from
   // prepareNextSlot, which is an advance call to execution engine to start building payload
   // Actual payload isn't produced till getPayload is called.
-  return {isPremerge: false, payloadId, prepType};
+  return {payloadId, prepType};
 }
 
 async function prepareExecutionPayloadHeader(
   chain: {
-    eth1: IEth1ForBlockProduction;
     executionBuilder?: IExecutionBuilder;
     config: ChainForkConfig;
   },
@@ -608,53 +560,13 @@ async function prepareExecutionPayloadHeader(
     throw Error("executionBuilder required");
   }
 
-  const parentHashRes = await getExecutionPayloadParentHash(chain, state);
-  if (parentHashRes.isPremerge) {
-    throw Error("External builder disabled pre-merge");
-  }
-
-  const {parentHash} = parentHashRes;
+  const parentHash = state.latestExecutionPayloadHeader.blockHash;
   return chain.executionBuilder.getHeader(fork, state.slot, parentHash, proposerPubKey);
 }
 
-export async function getExecutionPayloadParentHash(
-  chain: {
-    eth1: IEth1ForBlockProduction;
-    config: ChainForkConfig;
-  },
-  state: CachedBeaconStateExecutions
-): Promise<{isPremerge: true} | {isPremerge: false; parentHash: Root}> {
-  // Use different POW block hash parent for block production based on merge status.
-  // Returned value of null == using an empty ExecutionPayload value
-  if (isMergeTransitionComplete(state)) {
-    // Post-merge, normal payload
-    return {isPremerge: false, parentHash: state.latestExecutionPayloadHeader.blockHash};
-  }
-
-  if (
-    !ssz.Root.equals(chain.config.TERMINAL_BLOCK_HASH, ZERO_HASH) &&
-    getCurrentEpoch(state) < chain.config.TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
-  ) {
-    throw new Error(
-      `InvalidMergeTBH epoch: expected >= ${
-        chain.config.TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
-      }, actual: ${getCurrentEpoch(state)}`
-    );
-  }
-
-  const terminalPowBlockHash = await chain.eth1.getTerminalPowBlock();
-  if (terminalPowBlockHash === null) {
-    // Pre-merge, no prepare payload call is needed
-    return {isPremerge: true};
-  }
-  // Signify merge via producing on top of the last PoW block
-  return {isPremerge: false, parentHash: terminalPowBlockHash};
-}
-
-export async function getPayloadAttributesForSSE(
+export function getPayloadAttributesForSSE(
   fork: ForkPostBellatrix,
   chain: {
-    eth1: IEth1ForBlockProduction;
     config: ChainForkConfig;
   },
   {
@@ -663,30 +575,23 @@ export async function getPayloadAttributesForSSE(
     parentBlockRoot,
     feeRecipient,
   }: {prepareState: CachedBeaconStateExecutions; prepareSlot: Slot; parentBlockRoot: Root; feeRecipient: string}
-): Promise<SSEPayloadAttributes> {
-  const parentHashRes = await getExecutionPayloadParentHash(chain, prepareState);
-
-  if (!parentHashRes.isPremerge) {
-    const {parentHash} = parentHashRes;
-    const payloadAttributes = preparePayloadAttributes(fork, chain, {
-      prepareState,
-      prepareSlot,
-      parentBlockRoot,
-      feeRecipient,
-    });
-
-    const ssePayloadAttributes: SSEPayloadAttributes = {
-      proposerIndex: prepareState.epochCtx.getBeaconProposer(prepareSlot),
-      proposalSlot: prepareSlot,
-      parentBlockNumber: prepareState.latestExecutionPayloadHeader.blockNumber,
-      parentBlockRoot,
-      parentBlockHash: parentHash,
-      payloadAttributes,
-    };
-    return ssePayloadAttributes;
-  }
-
-  throw Error("The execution is still pre-merge");
+): SSEPayloadAttributes {
+  const parentHash = prepareState.latestExecutionPayloadHeader.blockHash;
+  const payloadAttributes = preparePayloadAttributes(fork, chain, {
+    prepareState,
+    prepareSlot,
+    parentBlockRoot,
+    feeRecipient,
+  });
+  const ssePayloadAttributes: SSEPayloadAttributes = {
+    proposerIndex: prepareState.epochCtx.getBeaconProposer(prepareSlot),
+    proposalSlot: prepareSlot,
+    parentBlockNumber: prepareState.latestExecutionPayloadHeader.blockNumber,
+    parentBlockRoot,
+    parentBlockHash: parentHash,
+    payloadAttributes,
+  };
+  return ssePayloadAttributes;
 }
 
 function preparePayloadAttributes(

package/src/chain/rewards/syncCommitteeRewards.ts

@@ -1,12 +1,13 @@
 import {routes} from "@lodestar/api";
 import {ForkName, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
-import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "@lodestar/state-transition";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair, Index2PubkeyCache} from "@lodestar/state-transition";
 import {BeaconBlock, ValidatorIndex, altair} from "@lodestar/types";
 
 export type SyncCommitteeRewards = routes.beacon.SyncCommitteeRewards;
 type BalanceRecord = {val: number}; // Use val for convenient way to increment/decrement balance
 
 export async function computeSyncCommitteeRewards(
+  index2pubkey: Index2PubkeyCache,
   block: BeaconBlock,
   preState: CachedBeaconStateAllForks,
   validatorIds: (ValidatorIndex | string)[] = []
@@ -18,7 +19,6 @@ export async function computeSyncCommitteeRewards(
 
   const altairBlock = block as altair.BeaconBlock;
   const preStateAltair = preState as CachedBeaconStateAltair;
-  const {index2pubkey} = preStateAltair.epochCtx;
 
   // Bound syncCommitteeValidatorIndices in case it goes beyond SYNC_COMMITTEE_SIZE just to be safe
   const syncCommitteeValidatorIndices = preStateAltair.epochCtx.currentSyncCommitteeIndexed.validatorIndices.slice(