@lodestar/beacon-node 1.39.0-dev.882891d89c → 1.39.0-dev.b37f2bd1bd

package/src/chain/chain.ts

@@ -43,6 +43,7 @@ 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";
@@ -116,6 +117,7 @@ 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
@@ -142,7 +144,7 @@ export class BeaconChain implements IBeaconChain {
   readonly aggregatedAttestationPool: AggregatedAttestationPool;
   readonly syncCommitteeMessagePool: SyncCommitteeMessagePool;
   readonly syncContributionAndProofPool;
-  readonly opPool: OpPool;
+  readonly opPool = new OpPool();
 
   // Gossip seen cache
   readonly seenAttesters = new SeenAttesters();
@@ -214,6 +216,7 @@ export class BeaconChain implements IBeaconChain {
       validatorMonitor,
       anchorState,
       isAnchorStateFinalized,
+      eth1,
       executionEngine,
       executionBuilder,
     }: {
@@ -230,6 +233,7 @@ export class BeaconChain implements IBeaconChain {
       validatorMonitor: ValidatorMonitor | null;
       anchorState: BeaconStateAllForks;
       isAnchorStateFinalized: boolean;
+      eth1: IEth1ForBlockProduction;
       executionEngine: IExecutionEngine;
       executionBuilder?: IExecutionBuilder;
     }
@@ -244,6 +248,7 @@ 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;
@@ -260,7 +265,6 @@ 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);
@@ -290,7 +294,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 initializeBeaconStateFromEth1 it may be incorrect. Until we can ensure that
+    // 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
@@ -335,7 +339,6 @@ export class BeaconChain implements IBeaconChain {
       this.cpStateDatastore = fileDataStore ? new FileCPStateDatastore(dataDir) : new DbCPStateDatastore(this.db);
       checkpointStateCache = new PersistentCheckpointStateCache(
         {
-          config,
           metrics,
           logger,
           clock,
@@ -414,6 +417,15 @@ 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);
@@ -1308,7 +1320,7 @@ export class BeaconChain implements IBeaconChain {
 
     const postState = this.regen.getStateSync(toRootHex(block.stateRoot)) ?? undefined;
 
-    return computeBlockRewards(this.config, block, preState.clone(), postState?.clone());
+    return computeBlockRewards(block, preState.clone(), postState?.clone());
   }
 
   async getAttestationsRewards(
@@ -1332,7 +1344,7 @@ export class BeaconChain implements IBeaconChain {
       throw Error(`State is not in cache for slot ${slot}`);
     }
 
-    const rewards = await computeAttestationsRewards(this.config, this.pubkey2index, cachedState, validatorIds);
+    const rewards = await computeAttestationsRewards(this.pubkey2index, cachedState, validatorIds);
 
     return {rewards, executionOptimistic, finalized};
   }
@@ -1349,6 +1361,6 @@ export class BeaconChain implements IBeaconChain {
 
     preState = processSlots(preState, block.slot); // Dial preState's slot to block.slot
 
-    return computeSyncCommitteeRewards(this.config, this.index2pubkey, block, preState.clone(), validatorIds);
+    return computeSyncCommitteeRewards(this.index2pubkey, block, preState.clone(), validatorIds);
   }
 }

package/src/chain/genesis/genesis.ts

@@ -0,0 +1,190 @@
+import {Tree, toGindex} from "@chainsafe/persistent-merkle-tree";
+import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
+import {GENESIS_EPOCH, GENESIS_SLOT} from "@lodestar/params";
+import {
+  BeaconStateAllForks,
+  CachedBeaconStateAllForks,
+  applyDeposits,
+  applyEth1BlockHash,
+  applyTimestamp,
+  createCachedBeaconState,
+  createEmptyEpochCacheImmutableData,
+  getActiveValidatorIndices,
+  getGenesisBeaconState,
+  getTemporaryBlockHeader,
+} from "@lodestar/state-transition";
+import {phase0, ssz} from "@lodestar/types";
+import {Logger} from "@lodestar/utils";
+import {DepositTree} from "../../db/repositories/depositDataRoot.js";
+import {IEth1Provider} from "../../eth1/index.js";
+import {IEth1StreamParams} from "../../eth1/interface.js";
+import {getDepositsAndBlockStreamForGenesis, getDepositsStream} from "../../eth1/stream.js";
+import {GenesisResult, IGenesisBuilder} from "./interface.js";
+
+export type GenesisBuilderKwargs = {
+  config: ChainForkConfig;
+  eth1Provider: IEth1Provider;
+  logger: Logger;
+
+  /** Use to restore pending progress */
+  pendingStatus?: {
+    state: BeaconStateAllForks;
+    depositTree: DepositTree;
+    lastProcessedBlockNumber: number;
+  };
+
+  signal?: AbortSignal;
+  maxBlocksPerPoll?: number;
+};
+
+export class GenesisBuilder implements IGenesisBuilder {
+  // Expose state to persist on error
+  readonly state: CachedBeaconStateAllForks;
+  readonly depositTree: DepositTree;
+  /** Is null if no block has been processed yet */
+  lastProcessedBlockNumber: number | null = null;
+
+  private readonly config: BeaconConfig;
+  private readonly eth1Provider: IEth1Provider;
+  private readonly logger: Logger;
+  private readonly signal?: AbortSignal;
+  private readonly eth1Params: IEth1StreamParams;
+  private readonly depositCache = new Set<number>();
+  private readonly fromBlock: number;
+  private readonly logEvery = 30 * 1000;
+  private lastLog = 0;
+  /** Current count of active validators in the state */
+  private activatedValidatorCount: number;
+
+  constructor({config, eth1Provider, logger, signal, pendingStatus, maxBlocksPerPoll}: GenesisBuilderKwargs) {
+    // at genesis builder, there is no genesis validator so we don't have a real BeaconConfig
+    // but we need BeaconConfig to temporarily create CachedBeaconState, the cast here is safe since we don't use any getDomain here
+    // the use of state as CachedBeaconState is just for convenient, GenesisResult returns TreeView anyway
+    this.eth1Provider = eth1Provider;
+    this.logger = logger;
+    this.signal = signal;
+    this.eth1Params = {
+      ...config,
+      maxBlocksPerPoll: maxBlocksPerPoll ?? 10000,
+    };
+
+    let stateView: BeaconStateAllForks;
+
+    if (pendingStatus) {
+      this.logger.info("Restoring pending genesis state", {block: pendingStatus.lastProcessedBlockNumber});
+      stateView = pendingStatus.state;
+      this.depositTree = pendingStatus.depositTree;
+      this.fromBlock = Math.max(pendingStatus.lastProcessedBlockNumber + 1, this.eth1Provider.deployBlock);
+    } else {
+      stateView = getGenesisBeaconState(
+        config,
+        ssz.phase0.Eth1Data.defaultValue(),
+        getTemporaryBlockHeader(config, config.getForkTypes(GENESIS_SLOT).BeaconBlock.defaultValue())
+      );
+      this.depositTree = ssz.phase0.DepositDataRootList.defaultViewDU();
+      this.fromBlock = this.eth1Provider.deployBlock;
+    }
+
+    // TODO - PENDING: Ensure EpochCacheImmutableData is created only once
+    this.state = createCachedBeaconState(stateView, createEmptyEpochCacheImmutableData(config, stateView));
+    this.config = this.state.config;
+    this.activatedValidatorCount = getActiveValidatorIndices(stateView, GENESIS_EPOCH).length;
+  }
+
+  /**
+   * Get eth1 deposit events and blocks and apply to this.state until we found genesis.
+   */
+  async waitForGenesis(): Promise<GenesisResult> {
+    await this.eth1Provider.validateContract();
+
+    // Load data from data from this.db.depositData, this.db.depositDataRoot
+    // And start from a more recent fromBlock
+    const blockNumberValidatorGenesis = await this.waitForGenesisValidators();
+
+    const depositsAndBlocksStream = getDepositsAndBlockStreamForGenesis(
+      blockNumberValidatorGenesis,
+      this.eth1Provider,
+      this.eth1Params,
+      this.signal
+    );
+
+    for await (const [depositEvents, block] of depositsAndBlocksStream) {
+      this.applyDeposits(depositEvents);
+      applyTimestamp(this.config, this.state, block.timestamp);
+      applyEth1BlockHash(this.state, block.blockHash);
+      this.lastProcessedBlockNumber = block.blockNumber;
+
+      if (
+        this.state.genesisTime >= this.config.MIN_GENESIS_TIME &&
+        this.activatedValidatorCount >= this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
+      ) {
+        this.logger.info("Found genesis state", {blockNumber: block.blockNumber});
+        return {
+          state: this.state,
+          depositTree: this.depositTree,
+          block,
+        };
+      }
+
+      this.throttledLog(`Waiting for min genesis time ${block.timestamp} / ${this.config.MIN_GENESIS_TIME}`);
+    }
+
+    throw Error("depositsStream stopped without a valid genesis state");
+  }
+
+  /**
+   * First phase of waiting for genesis.
+   * Stream deposits events in batches as big as possible without querying block data
+   * @returns Block number at which there are enough active validators is state for genesis
+   */
+  private async waitForGenesisValidators(): Promise<number> {
+    const depositsStream = getDepositsStream(this.fromBlock, this.eth1Provider, this.eth1Params, this.signal);
+
+    for await (const {depositEvents, blockNumber} of depositsStream) {
+      this.applyDeposits(depositEvents);
+      this.lastProcessedBlockNumber = blockNumber;
+
+      if (this.activatedValidatorCount >= this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT) {
+        this.logger.info("Found enough genesis validators", {blockNumber});
+        return blockNumber;
+      }
+
+      this.throttledLog(
+        `Found ${this.state.validators.length} / ${this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT} validators to genesis`
+      );
+    }
+
+    throw Error("depositsStream stopped without a valid genesis state");
+  }
+
+  private applyDeposits(depositEvents: phase0.DepositEvent[]): void {
+    const newDeposits = depositEvents
+      .filter((depositEvent) => !this.depositCache.has(depositEvent.index))
+      .map((depositEvent) => {
+        this.depositCache.add(depositEvent.index);
+        this.depositTree.push(ssz.phase0.DepositData.hashTreeRoot(depositEvent.depositData));
+        const gindex = toGindex(this.depositTree.type.depth, BigInt(depositEvent.index));
+
+        // Apply changes from the push above
+        this.depositTree.commit();
+        const depositTreeNode = this.depositTree.node;
+        return {
+          proof: new Tree(depositTreeNode).getSingleProof(gindex),
+          data: depositEvent.depositData,
+        };
+      });
+
+    const {activatedValidatorCount} = applyDeposits(this.config, this.state, newDeposits, this.depositTree);
+    this.activatedValidatorCount += activatedValidatorCount;
+
+    // TODO: If necessary persist deposits here to this.db.depositData, this.db.depositDataRoot
+  }
+
+  /** Throttle genesis generation status log to prevent spamming */
+  private throttledLog(message: string): void {
+    if (Date.now() - this.lastLog > this.logEvery) {
+      this.lastLog = Date.now();
+      this.logger.info(message);
+    }
+  }
+}

package/src/chain/genesis/interface.ts

@@ -0,0 +1,14 @@
+import {CompositeViewDU, VectorCompositeType} from "@chainsafe/ssz";
+import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
+import {ssz} from "@lodestar/types";
+import {Eth1Block} from "../../eth1/interface.js";
+
+export type GenesisResult = {
+  state: CachedBeaconStateAllForks;
+  depositTree: CompositeViewDU<VectorCompositeType<typeof ssz.Root>>;
+  block: Eth1Block;
+};
+
+export interface IGenesisBuilder {
+  waitForGenesis: () => Promise<GenesisResult>;
+}

package/src/chain/initState.ts

@@ -1,11 +1,37 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {ZERO_HASH} from "@lodestar/params";
-import {BeaconStateAllForks, computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
+import {
+  BeaconStateAllForks,
+  CachedBeaconStateAllForks,
+  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,
@@ -49,6 +75,76 @@ 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,6 +25,7 @@ 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";
@@ -87,6 +88,7 @@ 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/opPools/aggregatedAttestationPool.ts

@@ -1,6 +1,6 @@
 import {Signature, aggregateSignatures} from "@chainsafe/blst";
 import {BitArray} from "@chainsafe/ssz";
-import {BeaconConfig} from "@lodestar/config";
+import {ChainForkConfig} from "@lodestar/config";
 import {IForkChoice} from "@lodestar/fork-choice";
 import {
   ForkName,
@@ -162,7 +162,7 @@ export class AggregatedAttestationPool {
   private lowestPermissibleSlot = 0;
 
   constructor(
-    private readonly config: BeaconConfig,
+    private readonly config: ChainForkConfig,
     private readonly metrics: Metrics | null = null
   ) {
     metrics?.opPool.aggregatedAttestationPool.attDataPerSlot.addCollect(() => this.onScrapeMetrics(metrics));
@@ -249,7 +249,7 @@ export class AggregatedAttestationPool {
     const stateEpoch = state.epochCtx.epoch;
     const statePrevEpoch = stateEpoch - 1;
 
-    const notSeenValidatorsFn = getNotSeenValidatorsFn(this.config, state);
+    const notSeenValidatorsFn = getNotSeenValidatorsFn(state);
     const validateAttestationDataFn = getValidateAttestationDataFn(forkChoice, state);
 
     const attestationsByScore: AttestationWithScore[] = [];
@@ -362,7 +362,7 @@ export class AggregatedAttestationPool {
     const statePrevEpoch = stateEpoch - 1;
     const rootCache = new RootCache(state);
 
-    const notSeenValidatorsFn = getNotSeenValidatorsFn(this.config, state);
+    const notSeenValidatorsFn = getNotSeenValidatorsFn(state);
     const validateAttestationDataFn = getValidateAttestationDataFn(forkChoice, state);
 
     const slots = Array.from(this.attestationGroupByIndexByDataHexBySlot.keys()).sort((a, b) => b - a);
@@ -656,7 +656,7 @@ export class MatchingDataAttestationGroup {
   private readonly attestations: AttestationWithIndex[] = [];
 
   constructor(
-    private readonly config: BeaconConfig,
+    private readonly config: ChainForkConfig,
     readonly committee: Uint32Array,
     readonly data: phase0.AttestationData
   ) {}
@@ -864,9 +864,9 @@ export function aggregateConsolidation({byCommittee, attData}: AttestationsConso
  * Pre-compute participation from a CachedBeaconStateAllForks, for use to check if an attestation's committee
  * has already attested or not.
  */
-export function getNotSeenValidatorsFn(config: BeaconConfig, state: CachedBeaconStateAllForks): GetNotSeenValidatorsFn {
+export function getNotSeenValidatorsFn(state: CachedBeaconStateAllForks): GetNotSeenValidatorsFn {
   const stateSlot = state.slot;
-  if (config.getForkName(stateSlot) === ForkName.phase0) {
+  if (state.config.getForkName(stateSlot) === ForkName.phase0) {
     // Get attestations to be included in a phase0 block.
     // As we are close to altair, this is not really important, it's mainly for e2e.
     // The performance is not great due to the different BeaconState data structure to altair.

package/src/chain/opPools/opPool.ts

@@ -1,4 +1,3 @@
-import {BeaconConfig} from "@lodestar/config";
 import {Id, Repository} from "@lodestar/db";
 import {
   BLS_WITHDRAWAL_PREFIX,
@@ -52,8 +51,6 @@ export class OpPool {
   /** Map of validator index -> SignedBLSToExecutionChange */
   private readonly blsToExecutionChanges = new Map<ValidatorIndex, SignedBLSToExecutionChangeVersioned>();
 
-  constructor(private readonly config: BeaconConfig) {}
-
   // Getters for metrics
 
   get attesterSlashingsSize(): number {
@@ -194,8 +191,9 @@ export class OpPool {
     phase0.SignedVoluntaryExit[],
     capella.SignedBLSToExecutionChange[],
   ] {
+    const {config} = state;
     const stateEpoch = computeEpochAtSlot(state.slot);
-    const stateFork = this.config.getForkSeq(state.slot);
+    const stateFork = config.getForkSeq(state.slot);
     const toBeSlashedIndices = new Set<ValidatorIndex>();
     const proposerSlashings: phase0.ProposerSlashing[] = [];
 
@@ -267,7 +265,7 @@ export class OpPool {
         // a future fork.
         isVoluntaryExitSignatureIncludable(
           stateFork,
-          this.config.getForkSeq(computeStartSlotAtEpoch(voluntaryExit.message.epoch))
+          config.getForkSeq(computeStartSlotAtEpoch(voluntaryExit.message.epoch))
         )
       ) {
         voluntaryExits.push(voluntaryExit);
@@ -370,13 +368,14 @@ export class OpPool {
    * Prune if validator has already exited at or before the finalized checkpoint of the head.
    */
   private pruneVoluntaryExits(headState: CachedBeaconStateAllForks): void {
-    const headStateFork = this.config.getForkSeq(headState.slot);
+    const {config} = headState;
+    const headStateFork = config.getForkSeq(headState.slot);
     const finalizedEpoch = headState.finalizedCheckpoint.epoch;
 
     for (const [key, voluntaryExit] of this.voluntaryExits.entries()) {
       // VoluntaryExit messages signed in the previous fork become invalid and can never be included in any future
       // block, so just drop as the head state advances into the next fork.
-      if (this.config.getForkSeq(computeStartSlotAtEpoch(voluntaryExit.message.epoch)) < headStateFork) {
+      if (config.getForkSeq(computeStartSlotAtEpoch(voluntaryExit.message.epoch)) < headStateFork) {
         this.voluntaryExits.delete(key);
       }
 
@@ -393,8 +392,9 @@ export class OpPool {
    * to opPool once gossipsub seen cache TTL passes.
    */
   private pruneBlsToExecutionChanges(headBlock: SignedBeaconBlock, headState: CachedBeaconStateAllForks): void {
+    const {config} = headState;
     const recentBlsToExecutionChanges =
-      this.config.getForkSeq(headBlock.message.slot) >= ForkSeq.capella
+      config.getForkSeq(headBlock.message.slot) >= ForkSeq.capella
         ? (headBlock as capella.SignedBeaconBlock).message.body.blsToExecutionChanges
         : [];
 

package/src/chain/prepareNextSlot.ts

@@ -1,8 +1,9 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
-import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ForkPostBellatrix, ForkSeq, SLOTS_PER_EPOCH, isForkPostElectra} from "@lodestar/params";
 import {
+  BeaconStateElectra,
   CachedBeaconStateAllForks,
   CachedBeaconStateExecutions,
   StateHashTreeRootSource,
@@ -221,6 +222,9 @@ export class PrepareNextSlotScheduler {
         }
         this.metrics?.precomputeNextEpochTransition.hits.set(previousHits ?? 0);
 
+        // Check if we can stop polling eth1 data
+        this.stopEth1Polling();
+
         this.logger.verbose("Completed PrepareNextSlotScheduler epoch transition", {
           nextEpoch,
           headSlot,
@@ -248,4 +252,27 @@ export class PrepareNextSlotScheduler {
     state.hashTreeRoot();
     hashTreeRootTimer?.();
   }
+
+  /**
+   * Stop eth1 data polling after eth1_deposit_index has reached deposit_requests_start_index in Electra as described in EIP-6110
+   */
+  stopEth1Polling(): void {
+    // Only continue if eth1 is still polling and finalized checkpoint is in Electra. State regen is expensive
+    if (this.chain.eth1.isPollingEth1Data()) {
+      const finalizedCheckpoint = this.chain.forkChoice.getFinalizedCheckpoint();
+      const checkpointFork = this.config.getForkInfoAtEpoch(finalizedCheckpoint.epoch).name;
+
+      if (isForkPostElectra(checkpointFork)) {
+        const finalizedState = this.chain.getStateByCheckpoint(finalizedCheckpoint)?.state;
+
+        if (
+          finalizedState !== undefined &&
+          finalizedState.eth1DepositIndex === Number((finalizedState as BeaconStateElectra).depositRequestsStartIndex)
+        ) {
+          // Signal eth1 to stop polling eth1Data
+          this.chain.eth1.stopPollingEth1Data();
+        }
+      }
+    }
+  }
 }

package/src/chain/produceBlock/produceBlockBody.ts

@@ -45,7 +45,7 @@ import {
 } from "@lodestar/types";
 import {Logger, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
-import {numToQuantity} from "../../execution/engine/utils.js";
+import {numToQuantity} from "../../eth1/provider/utils.js";
 import {
   IExecutionBuilder,
   IExecutionEngine,
@@ -78,6 +78,7 @@ export enum BlockProductionStep {
   voluntaryExits = "voluntaryExits",
   blsToExecutionChanges = "blsToExecutionChanges",
   attestations = "attestations",
+  eth1DataAndDeposits = "eth1DataAndDeposits",
   syncAggregate = "syncAggregate",
   executionPayload = "executionPayload",
 }
@@ -165,7 +166,7 @@ export async function produceBlockBody<T extends BlockType>(
   // even though shouldOverrideBuilder is relevant for the engine response, for simplicity of typing
   // we just return it undefined for the builder which anyway doesn't get consumed downstream
   let shouldOverrideBuilder: boolean | undefined;
-  const fork = this.config.getForkName(blockSlot);
+  const fork = currentState.config.getForkName(blockSlot);
   const produceResult = {
     type: blockType,
     fork,
@@ -644,7 +645,7 @@ export async function produceCommonBlockBody<T extends BlockType>(
       ? this.metrics?.executionBlockProductionTimeSteps
       : this.metrics?.builderBlockProductionTimeSteps;
 
-  const fork = this.config.getForkName(slot);
+  const fork = currentState.config.getForkName(slot);
 
   // TODO:
   // Iterate through the naive aggregation pool and ensure all the attestations from there
@@ -666,17 +667,20 @@ export async function produceCommonBlockBody<T extends BlockType>(
     step: BlockProductionStep.attestations,
   });
 
+  const endEth1DataAndDeposits = stepsMetrics?.startTimer();
+  const {eth1Data, deposits} = await this.eth1.getEth1DataAndDeposits(currentState);
+  endEth1DataAndDeposits?.({
+    step: BlockProductionStep.eth1DataAndDeposits,
+  });
+
   const blockBody: Omit<CommonBlockBody, "blsToExecutionChanges" | "syncAggregate"> = {
     randaoReveal,
     graffiti,
-    // Eth1 data voting is no longer required since electra
-    eth1Data: currentState.eth1Data,
+    eth1Data,
     proposerSlashings,
     attesterSlashings,
     attestations,
-    // Since electra, deposits are processed by the execution layer,
-    // we no longer support handling deposits from earlier forks.
-    deposits: [],
+    deposits,
     voluntaryExits,
   };