@lodestar/beacon-node 1.38.0-rc.0 → 1.39.0-dev.0321dbcf04

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -6,19 +6,16 @@ import {
   LVHValidResponse,
   MaybeValidExecutionStatus,
   ProtoBlock,
-  assertValidTerminalPowBlock,
 } from "@lodestar/fork-choice";
-import {ForkSeq, SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY} from "@lodestar/params";
+import {ForkSeq} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   isExecutionBlockBodyType,
   isExecutionEnabled,
   isExecutionStateType,
-  isMergeTransitionBlock as isMergeTransitionBlockFn,
 } from "@lodestar/state-transition";
-import {Slot, bellatrix, electra} from "@lodestar/types";
+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 +26,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 +40,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 +67,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 +90,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 +100,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 +109,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 +136,6 @@ export async function verifyBlocksExecutionPayload(
     execAborted: null,
     executionStatuses,
     executionTime,
-    mergeBlockFound,
   };
 }
 
@@ -275,28 +145,20 @@ 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)
       ? 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 +205,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,5 @@
-import {CachedBeaconStateAllForks, getBlockSignatureSets} from "@lodestar/state-transition";
+import {BeaconConfig} from "@lodestar/config";
+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 +16,8 @@ import {ImportBlockOpts} from "./types.js";
  * Since all data is known in advance all signatures are verified at once in parallel.
  */
 export async function verifyBlocksSignatures(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
   bls: IBlsVerifier,
   logger: Logger,
   metrics: Metrics | null,
@@ -25,6 +28,7 @@ export async function verifyBlocksSignatures(
 ): Promise<{verifySignaturesTime: number}> {
   const isValidPromises: Promise<boolean>[] = [];
   const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
+  const currentSyncCommitteeIndexed = preState0.epochCtx.currentSyncCommitteeIndexed;
 
   // Verifies signatures after running state transition, so all SyncCommittee signed roots are known at this point.
   // We must ensure block.slot <= state.slot before running getAllBlockSignatureSets().
@@ -38,9 +42,16 @@ export async function verifyBlocksSignatures(
       : //
         // Verify signatures per block to track which block is invalid
         bls.verifySignatureSets(
-          getBlockSignatureSets(preState0, block, indexedAttestationsByBlock[i], {
-            skipProposerSignature: opts.validProposerSignature,
-          })
+          getBlockSignatureSets(
+            config,
+            index2pubkey,
+            currentSyncCommitteeIndexed,
+            block,
+            indexedAttestationsByBlock[i],
+            {
+              skipProposerSignature: opts.validProposerSignature,
+            }
+          )
         );
 
     // getBlockSignatureSets() takes 45ms in benchmarks for 2022Q2 mainnet blocks (100 sigs). When syncing a 32 blocks

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 {
@@ -14,13 +14,14 @@ import {
   EpochShuffling,
   Index2PubkeyCache,
   computeAnchorCheckpoint,
+  computeAttestationsRewards,
+  computeBlockRewards,
   computeEndSlotAtEpoch,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
-  createCachedBeaconState,
+  computeSyncCommitteeRewards,
   getEffectiveBalanceIncrementsZeroInactive,
   getEffectiveBalancesFromStateBytes,
-  isCachedBeaconState,
   processSlots,
 } from "@lodestar/state-transition";
 import {
@@ -38,12 +39,12 @@ import {
   Wei,
   isBlindedBeaconBlock,
   phase0,
+  rewards,
 } from "@lodestar/types";
 import {Logger, fromHex, gweiToWei, isErrorAborted, pruneSetToMax, sleep, toRootHex} from "@lodestar/utils";
 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";
@@ -80,9 +81,6 @@ import {AssembledBlockType, BlockType, ProduceResult} from "./produceBlock/index
 import {BlockAttributes, produceBlockBody, produceCommonBlockBody} from "./produceBlock/produceBlockBody.js";
 import {QueuedStateRegenerator, RegenCaller} from "./regen/index.js";
 import {ReprocessController} from "./reprocess.js";
-import {AttestationsRewards, computeAttestationsRewards} from "./rewards/attestationsRewards.js";
-import {BlockRewards, computeBlockRewards} from "./rewards/blockRewards.js";
-import {SyncCommitteeRewards, computeSyncCommitteeRewards} from "./rewards/syncCommitteeRewards.js";
 import {
   SeenAggregators,
   SeenAttesters,
@@ -117,7 +115,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
@@ -144,7 +141,7 @@ export class BeaconChain implements IBeaconChain {
   readonly aggregatedAttestationPool: AggregatedAttestationPool;
   readonly syncCommitteeMessagePool: SyncCommitteeMessagePool;
   readonly syncContributionAndProofPool;
-  readonly opPool = new OpPool();
+  readonly opPool: OpPool;
 
   // Gossip seen cache
   readonly seenAttesters = new SeenAttesters();
@@ -206,6 +203,8 @@ export class BeaconChain implements IBeaconChain {
     {
       privateKey,
       config,
+      pubkey2index,
+      index2pubkey,
       db,
       dbName,
       dataDir,
@@ -216,12 +215,13 @@ export class BeaconChain implements IBeaconChain {
       validatorMonitor,
       anchorState,
       isAnchorStateFinalized,
-      eth1,
       executionEngine,
       executionBuilder,
     }: {
       privateKey: PrivateKey;
       config: BeaconConfig;
+      pubkey2index: PubkeyIndexMap;
+      index2pubkey: Index2PubkeyCache;
       db: IBeaconDb;
       dbName: string;
       dataDir: string;
@@ -231,9 +231,8 @@ export class BeaconChain implements IBeaconChain {
       clock?: IClock;
       metrics: Metrics | null;
       validatorMonitor: ValidatorMonitor | null;
-      anchorState: BeaconStateAllForks;
+      anchorState: CachedBeaconStateAllForks;
       isAnchorStateFinalized: boolean;
-      eth1: IEth1ForBlockProduction;
       executionEngine: IExecutionEngine;
       executionBuilder?: IExecutionBuilder;
     }
@@ -248,7 +247,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;
@@ -265,6 +263,7 @@ export class BeaconChain implements IBeaconChain {
     this.aggregatedAttestationPool = new AggregatedAttestationPool(this.config, metrics);
     this.syncCommitteeMessagePool = new SyncCommitteeMessagePool(config, clock, this.opts?.preaggregateSlotDistance);
     this.syncContributionAndProofPool = new SyncContributionAndProofPool(config, clock, metrics, logger);
+    this.opPool = new OpPool(config);
 
     this.seenAggregatedAttestations = new SeenAggregatedAttestations(metrics);
     this.seenContributionAndProof = new SeenContributionAndProof(metrics);
@@ -291,39 +290,25 @@ export class BeaconChain implements IBeaconChain {
       logger,
     });
 
-    // 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
-    // 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
-        ? anchorState
-        : createCachedBeaconState(anchorState, {
-            config,
-            pubkey2index: new PubkeyIndexMap(),
-            index2pubkey: [],
-          });
-    this._earliestAvailableSlot = cachedState.slot;
-
-    this.shufflingCache = cachedState.epochCtx.shufflingCache = new ShufflingCache(metrics, logger, this.opts, [
+    this._earliestAvailableSlot = anchorState.slot;
+    this.shufflingCache = anchorState.epochCtx.shufflingCache = new ShufflingCache(metrics, logger, this.opts, [
       {
-        shuffling: cachedState.epochCtx.previousShuffling,
-        decisionRoot: cachedState.epochCtx.previousDecisionRoot,
+        shuffling: anchorState.epochCtx.previousShuffling,
+        decisionRoot: anchorState.epochCtx.previousDecisionRoot,
       },
       {
-        shuffling: cachedState.epochCtx.currentShuffling,
-        decisionRoot: cachedState.epochCtx.currentDecisionRoot,
+        shuffling: anchorState.epochCtx.currentShuffling,
+        decisionRoot: anchorState.epochCtx.currentDecisionRoot,
       },
       {
-        shuffling: cachedState.epochCtx.nextShuffling,
-        decisionRoot: cachedState.epochCtx.nextDecisionRoot,
+        shuffling: anchorState.epochCtx.nextShuffling,
+        decisionRoot: anchorState.epochCtx.nextDecisionRoot,
       },
     ]);
 
-    // Persist single global instance of state caches
-    this.pubkey2index = cachedState.epochCtx.pubkey2index;
-    this.index2pubkey = cachedState.epochCtx.index2pubkey;
+    // Global cache of validators pubkey/index mapping
+    this.pubkey2index = pubkey2index;
+    this.index2pubkey = index2pubkey;
 
     const fileDataStore = opts.nHistoricalStatesFileDataStore ?? true;
     const blockStateCache = this.opts.nHistoricalStates
@@ -339,6 +324,7 @@ export class BeaconChain implements IBeaconChain {
       this.cpStateDatastore = fileDataStore ? new FileCPStateDatastore(dataDir) : new DbCPStateDatastore(this.db);
       checkpointStateCache = new PersistentCheckpointStateCache(
         {
+          config,
           metrics,
           logger,
           clock,
@@ -353,15 +339,15 @@ export class BeaconChain implements IBeaconChain {
     }
 
     const {checkpoint} = computeAnchorCheckpoint(config, anchorState);
-    blockStateCache.add(cachedState);
-    blockStateCache.setHeadState(cachedState);
-    checkpointStateCache.add(checkpoint, cachedState);
+    blockStateCache.add(anchorState);
+    blockStateCache.setHeadState(anchorState);
+    checkpointStateCache.add(checkpoint, anchorState);
 
     const forkChoice = initializeForkChoice(
       config,
       emitter,
       clock.currentSlot,
-      cachedState,
+      anchorState,
       isAnchorStateFinalized,
       opts,
       this.justifiedBalancesGetter.bind(this),
@@ -417,15 +403,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 +734,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 +1154,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 {
@@ -1320,7 +1286,7 @@ export class BeaconChain implements IBeaconChain {
     }
   }
 
-  async getBlockRewards(block: BeaconBlock | BlindedBeaconBlock): Promise<BlockRewards> {
+  async getBlockRewards(block: BeaconBlock | BlindedBeaconBlock): Promise<rewards.BlockRewards> {
     let preState = this.regen.getPreStateSync(block);
 
     if (preState === null) {
@@ -1331,13 +1297,13 @@ export class BeaconChain implements IBeaconChain {
 
     const postState = this.regen.getStateSync(toRootHex(block.stateRoot)) ?? undefined;
 
-    return computeBlockRewards(block, preState.clone(), postState?.clone());
+    return computeBlockRewards(this.config, block, preState.clone(), postState?.clone());
   }
 
   async getAttestationsRewards(
     epoch: Epoch,
     validatorIds?: (ValidatorIndex | string)[]
-  ): Promise<{rewards: AttestationsRewards; executionOptimistic: boolean; finalized: boolean}> {
+  ): Promise<{rewards: rewards.AttestationsRewards; executionOptimistic: boolean; finalized: boolean}> {
     // We use end slot of (epoch + 1) to ensure we have seen all attestations. On-time or late. Any late attestation beyond this slot is not considered
     const slot = computeEndSlotAtEpoch(epoch + 1);
     const stateResult = await this.getStateBySlot(slot, {allowRegen: false}); // No regen if state not in cache
@@ -1355,7 +1321,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.config, this.pubkey2index, cachedState, validatorIds);
 
     return {rewards, executionOptimistic, finalized};
   }
@@ -1363,7 +1329,7 @@ export class BeaconChain implements IBeaconChain {
   async getSyncCommitteeRewards(
     block: BeaconBlock | BlindedBeaconBlock,
     validatorIds?: (ValidatorIndex | string)[]
-  ): Promise<SyncCommitteeRewards> {
+  ): Promise<rewards.SyncCommitteeRewards> {
     let preState = this.regen.getPreStateSync(block);
 
     if (preState === null) {
@@ -1372,6 +1338,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.config, this.index2pubkey, block, preState.clone(), validatorIds);
   }
 }