@lodestar/beacon-node 1.38.0 → 1.39.0-dev.2fe8de2346

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

@@ -1511,7 +1511,7 @@ export function getValidatorApi(
 
       const filteredRegistrations = registrations.filter((registration) => {
         const {pubkey} = registration.message;
-        const validatorIndex = headState.epochCtx.pubkey2index.get(pubkey);
+        const validatorIndex = chain.pubkey2index.get(pubkey);
         if (validatorIndex === null) return false;
 
         const validator = headState.validators.getReadonly(validatorIndex);

package/src/chain/blocks/verifyBlock.ts

@@ -1,4 +1,3 @@
-import {ChainForkConfig} from "@lodestar/config";
 import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
 import {ForkName, isForkPostFulu} from "@lodestar/params";
 import {
@@ -7,8 +6,7 @@ import {
   computeEpochAtSlot,
   isStateValidatorsNodesPopulated,
 } from "@lodestar/state-transition";
-import {IndexedAttestation, bellatrix, deneb} from "@lodestar/types";
-import {Logger, toRootHex} from "@lodestar/utils";
+import {IndexedAttestation, deneb} from "@lodestar/types";
 import type {BeaconChain} from "../chain.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {BlockProcessOpts} from "../options.js";
@@ -18,7 +16,6 @@ import {ImportBlockOpts} from "./types.js";
 import {DENEB_BLOWFISH_BANNER} from "./utils/blowfishBanner.js";
 import {ELECTRA_GIRAFFE_BANNER} from "./utils/giraffeBanner.js";
 import {CAPELLA_OWL_BANNER} from "./utils/ownBanner.js";
-import {POS_PANDA_MERGE_TRANSITION_BANNER} from "./utils/pandaMergeTransitionBanner.js";
 import {FULU_ZEBRA_BANNER} from "./utils/zebraBanner.js";
 import {verifyBlocksDataAvailability} from "./verifyBlocksDataAvailability.js";
 import {SegmentExecStatus, verifyBlocksExecutionPayload} from "./verifyBlocksExecutionPayloads.js";
@@ -103,7 +100,6 @@ export async function verifyBlocksInEpoch(
         : Promise.resolve({
             execAborted: null,
             executionStatuses: blocks.map((_blk) => ExecutionStatus.Syncing),
-            mergeBlockFound: null,
           } as SegmentExecStatus);
 
     // Store indexed attestations for each block to avoid recomputing them during import
@@ -143,6 +139,7 @@ export async function verifyBlocksInEpoch(
       // All signatures at once
       opts.skipVerifyBlockSignatures !== true
         ? verifyBlocksSignatures(
+            this.index2pubkey,
             this.bls,
             this.logger,
             this.metrics,
@@ -162,12 +159,6 @@ export async function verifyBlocksInEpoch(
     ]);
 
     if (opts.verifyOnly !== true) {
-      if (segmentExecStatus.execAborted === null && segmentExecStatus.mergeBlockFound !== null) {
-        // merge block found and is fully valid = state transition + signatures + execution payload.
-        // TODO: Will this banner be logged during syncing?
-        logOnPowBlock(this.logger, this.config, segmentExecStatus.mergeBlockFound);
-      }
-
       const fromForkBoundary = this.config.getForkBoundaryAtEpoch(computeEpochAtSlot(parentBlock.slot));
       const toForkBoundary = this.config.getForkBoundaryAtEpoch(computeEpochAtSlot(lastBlock.message.slot));
 
@@ -250,16 +241,3 @@ export async function verifyBlocksInEpoch(
     abortController.abort();
   }
 }
-
-function logOnPowBlock(logger: Logger, config: ChainForkConfig, mergeBlock: bellatrix.BeaconBlock): void {
-  const mergeBlockHash = toRootHex(config.getForkTypes(mergeBlock.slot).BeaconBlock.hashTreeRoot(mergeBlock));
-  const mergeExecutionHash = toRootHex(mergeBlock.body.executionPayload.blockHash);
-  const mergePowHash = toRootHex(mergeBlock.body.executionPayload.parentHash);
-  logger.info(POS_PANDA_MERGE_TRANSITION_BANNER);
-  logger.info("Execution transitioning from PoW to PoS!!!");
-  logger.info("Importing block referencing terminal PoW block", {
-    blockHash: mergeBlockHash,
-    executionHash: mergeExecutionHash,
-    powHash: mergePowHash,
-  });
-}

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 {
@@ -43,7 +43,6 @@ import {Logger, fromHex, gweiToWei, isErrorAborted, pruneSetToMax, sleep, toRoot
 import {ProcessShutdownCallback} from "@lodestar/validator";
 import {GENESIS_EPOCH, ZERO_HASH} from "../constants/index.js";
 import {IBeaconDb} from "../db/index.js";
-import {IEth1ForBlockProduction} from "../eth1/index.js";
 import {BuilderStatus} from "../execution/builder/http.js";
 import {IExecutionBuilder, IExecutionEngine} from "../execution/index.js";
 import {Metrics} from "../metrics/index.js";
@@ -117,7 +116,6 @@ const DEFAULT_MAX_CACHED_PRODUCED_RESULTS = 4;
 export class BeaconChain implements IBeaconChain {
   readonly genesisTime: UintNum64;
   readonly genesisValidatorsRoot: Root;
-  readonly eth1: IEth1ForBlockProduction;
   readonly executionEngine: IExecutionEngine;
   readonly executionBuilder?: IExecutionBuilder;
   // Expose config for convenience in modularized functions
@@ -216,7 +214,6 @@ export class BeaconChain implements IBeaconChain {
       validatorMonitor,
       anchorState,
       isAnchorStateFinalized,
-      eth1,
       executionEngine,
       executionBuilder,
     }: {
@@ -233,7 +230,6 @@ export class BeaconChain implements IBeaconChain {
       validatorMonitor: ValidatorMonitor | null;
       anchorState: BeaconStateAllForks;
       isAnchorStateFinalized: boolean;
-      eth1: IEth1ForBlockProduction;
       executionEngine: IExecutionEngine;
       executionBuilder?: IExecutionBuilder;
     }
@@ -248,7 +244,6 @@ export class BeaconChain implements IBeaconChain {
     this.genesisTime = anchorState.genesisTime;
     this.anchorStateLatestBlockSlot = anchorState.latestBlockHeader.slot;
     this.genesisValidatorsRoot = anchorState.genesisValidatorsRoot;
-    this.eth1 = eth1;
     this.executionEngine = executionEngine;
     this.executionBuilder = executionBuilder;
     const signal = this.abortController.signal;
@@ -294,7 +289,7 @@ export class BeaconChain implements IBeaconChain {
     // Restore state caches
     // anchorState may already by a CachedBeaconState. If so, don't create the cache again, since deserializing all
     // pubkeys takes ~30 seconds for 350k keys (mainnet 2022Q2).
-    // When the BeaconStateCache is created in eth1 genesis builder it may be incorrect. Until we can ensure that
+    // When the BeaconStateCache is created in initializeBeaconStateFromEth1 it may be incorrect. Until we can ensure that
     // it's safe to re-use _ANY_ BeaconStateCache, this option is disabled by default and only used in tests.
     const cachedState =
       isCachedBeaconState(anchorState) && opts.skipCreateStateCacheIfAvailable
@@ -417,15 +412,6 @@ export class BeaconChain implements IBeaconChain {
       signal
     );
 
-    // Stop polling eth1 data if anchor state is in Electra AND deposit_requests_start_index is reached
-    const anchorStateFork = this.config.getForkName(anchorState.slot);
-    if (isForkPostElectra(anchorStateFork)) {
-      const {eth1DepositIndex, depositRequestsStartIndex} = anchorState as BeaconStateElectra;
-      if (eth1DepositIndex === Number(depositRequestsStartIndex)) {
-        this.eth1.stopPollingEth1Data();
-      }
-    }
-
     // always run PrepareNextSlotScheduler except for fork_choice spec tests
     if (!opts?.disablePrepareNextSlot) {
       new PrepareNextSlotScheduler(this, this.config, metrics, this.logger, signal);
@@ -757,7 +743,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 +1163,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 {
@@ -1355,7 +1330,7 @@ export class BeaconChain implements IBeaconChain {
       throw Error(`State is not in cache for slot ${slot}`);
     }
 
-    const rewards = await computeAttestationsRewards(epoch, cachedState, this.config, validatorIds);
+    const rewards = await computeAttestationsRewards(this.pubkey2index, cachedState, validatorIds);
 
     return {rewards, executionOptimistic, finalized};
   }
@@ -1372,6 +1347,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/initState.ts

@@ -1,37 +1,11 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {ZERO_HASH} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  CachedBeaconStateAllForks,
-  computeEpochAtSlot,
-  computeStartSlotAtEpoch,
-} from "@lodestar/state-transition";
+import {BeaconStateAllForks, computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {SignedBeaconBlock, ssz} from "@lodestar/types";
 import {Logger, toHex, toRootHex} from "@lodestar/utils";
 import {GENESIS_SLOT} from "../constants/index.js";
 import {IBeaconDb} from "../db/index.js";
-import {Eth1Provider} from "../eth1/index.js";
-import {Eth1Options} from "../eth1/options.js";
 import {Metrics} from "../metrics/index.js";
-import {GenesisBuilder} from "./genesis/genesis.js";
-import {GenesisResult} from "./genesis/interface.js";
-
-export async function persistGenesisResult(
-  db: IBeaconDb,
-  genesisResult: GenesisResult,
-  genesisBlock: SignedBeaconBlock
-): Promise<void> {
-  await Promise.all([
-    db.stateArchive.add(genesisResult.state),
-    db.blockArchive.add(genesisBlock),
-    db.depositDataRoot.putList(genesisResult.depositTree.getAllReadonlyValues()),
-    db.eth1Data.put(genesisResult.block.timestamp, {
-      ...genesisResult.block,
-      depositCount: genesisResult.depositTree.length,
-      depositRoot: genesisResult.depositTree.hashTreeRoot(),
-    }),
-  ]);
-}
 
 export async function persistAnchorState(
   config: ChainForkConfig,
@@ -75,76 +49,6 @@ export function createGenesisBlock(config: ChainForkConfig, genesisState: Beacon
   return genesisBlock;
 }
 
-/**
- * Initialize and persist a genesis state and related data
- */
-export async function initStateFromEth1({
-  config,
-  db,
-  logger,
-  opts,
-  signal,
-}: {
-  config: ChainForkConfig;
-  db: IBeaconDb;
-  logger: Logger;
-  opts: Eth1Options;
-  signal: AbortSignal;
-}): Promise<CachedBeaconStateAllForks> {
-  logger.info("Listening to eth1 for genesis state");
-
-  const statePreGenesis = await db.preGenesisState.get();
-  const depositTree = await db.depositDataRoot.getDepositRootTree();
-  const lastProcessedBlockNumber = await db.preGenesisStateLastProcessedBlock.get();
-
-  const builder = new GenesisBuilder({
-    config,
-    eth1Provider: new Eth1Provider(config, {...opts, logger}, signal),
-    logger,
-    signal,
-    pendingStatus:
-      statePreGenesis && depositTree !== undefined && lastProcessedBlockNumber != null
-        ? {state: statePreGenesis, depositTree, lastProcessedBlockNumber}
-        : undefined,
-  });
-
-  try {
-    const genesisResult = await builder.waitForGenesis();
-
-    // Note: .hashTreeRoot() automatically commits()
-    const genesisBlock = createGenesisBlock(config, genesisResult.state);
-    const types = config.getForkTypes(GENESIS_SLOT);
-    const stateRoot = genesisResult.state.hashTreeRoot();
-    const blockRoot = types.BeaconBlock.hashTreeRoot(genesisBlock.message);
-
-    logger.info("Initializing genesis state", {
-      stateRoot: toRootHex(stateRoot),
-      blockRoot: toRootHex(blockRoot),
-      validatorCount: genesisResult.state.validators.length,
-    });
-
-    await persistGenesisResult(db, genesisResult, genesisBlock);
-
-    logger.verbose("Clearing pending genesis state if any");
-    await db.preGenesisState.delete();
-    await db.preGenesisStateLastProcessedBlock.delete();
-
-    return genesisResult.state;
-  } catch (e) {
-    if (builder.lastProcessedBlockNumber != null) {
-      logger.info("Persisting genesis state", {block: builder.lastProcessedBlockNumber});
-
-      // Commit changed before serializing
-      builder.state.commit();
-
-      await db.preGenesisState.put(builder.state);
-      await db.depositDataRoot.putList(builder.depositTree.getAllReadonlyValues());
-      await db.preGenesisStateLastProcessedBlock.put(builder.lastProcessedBlockNumber);
-    }
-    throw e;
-  }
-}
-
 /**
  * Restore the latest beacon state from db
  */

package/src/chain/interface.ts

@@ -25,7 +25,6 @@ import {
   phase0,
 } from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
-import {IEth1ForBlockProduction} from "../eth1/index.js";
 import {IExecutionBuilder, IExecutionEngine} from "../execution/index.js";
 import {Metrics} from "../metrics/metrics.js";
 import {BufferPool} from "../util/bufferPool.js";
@@ -88,7 +87,6 @@ export interface IBeaconChain {
   readonly genesisTime: UintNum64;
   readonly genesisValidatorsRoot: Root;
   readonly earliestAvailableSlot: Slot;
-  readonly eth1: IEth1ForBlockProduction;
   readonly executionEngine: IExecutionEngine;
   readonly executionBuilder?: IExecutionBuilder;
   // Expose config for convenience in modularized functions

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,