@lodestar/beacon-node 1.38.0 → 1.39.0-dev.3bf4734ba9

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

@@ -1,5 +1,5 @@
+import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {routes} from "@lodestar/api";
-import {BeaconConfig} from "@lodestar/config";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
   ForkName,
@@ -25,7 +25,7 @@ import {
   hasMarkers,
   isInInactivityLeak,
 } from "@lodestar/state-transition";
-import {Epoch, ValidatorIndex} from "@lodestar/types";
+import {ValidatorIndex} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 
 export type AttestationsRewards = routes.beacon.AttestationsRewards;
@@ -38,9 +38,8 @@ const defaultAttestationsReward = {head: 0, target: 0, source: 0, inclusionDelay
 const defaultAttestationsPenalty = {target: 0, source: 0};
 
 export async function computeAttestationsRewards(
-  _epoch: Epoch,
+  pubkey2index: PubkeyIndexMap,
   state: CachedBeaconStateAllForks,
-  _config: BeaconConfig,
   validatorIds?: (ValidatorIndex | string)[]
 ): Promise<AttestationsRewards> {
   const fork = state.config.getForkName(state.slot);
@@ -53,6 +52,7 @@ export async function computeAttestationsRewards(
 
   const [idealRewards, penalties] = computeIdealAttestationsRewardsAndPenaltiesAltair(stateAltair, transitionCache);
   const totalRewards = computeTotalAttestationsRewardsAltair(
+    pubkey2index,
     stateAltair,
     transitionCache,
     idealRewards,
@@ -139,6 +139,7 @@ function computeIdealAttestationsRewardsAndPenaltiesAltair(
 
 // Same calculation as `getRewardsAndPenaltiesAltair` but returns the breakdown of rewards instead of aggregated
 function computeTotalAttestationsRewardsAltair(
+  pubkey2index: PubkeyIndexMap,
   state: CachedBeaconStateAltair,
   transitionCache: EpochTransitionCache,
   idealRewards: IdealAttestationsReward[],
@@ -149,7 +150,7 @@ function computeTotalAttestationsRewardsAltair(
   const {flags} = transitionCache;
   const {epochCtx, config} = state;
   const validatorIndices = validatorIds
-    .map((id) => (typeof id === "number" ? id : epochCtx.pubkey2index.get(fromHex(id))))
+    .map((id) => (typeof id === "number" ? id : pubkey2index.get(fromHex(id))))
     .filter((index) => index !== undefined); // Validator indices to include in the result
 
   const inactivityPenaltyDenominator = config.INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR;

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(

package/src/chain/validation/attesterSlashing.ts

@@ -43,7 +43,7 @@ export async function validateAttesterSlashing(
   // [REJECT] All of the conditions within process_attester_slashing pass validation.
   try {
     // verifySignature = false, verified in batch below
-    assertValidAttesterSlashing(state, attesterSlashing, false);
+    assertValidAttesterSlashing(chain.index2pubkey, state, attesterSlashing, false);
   } catch (e) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID,
@@ -51,7 +51,7 @@ export async function validateAttesterSlashing(
     });
   }
 
-  const signatureSets = getAttesterSlashingSignatureSets(state, attesterSlashing);
+  const signatureSets = getAttesterSlashingSignatureSets(chain.index2pubkey, state, attesterSlashing);
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID,

package/src/chain/validation/blobSidecar.ts

@@ -137,7 +137,11 @@ export async function validateGossipBlobSidecar(
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
   const signature = blobSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blobSlot, blockHex, signature)) {
-    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(blockState, blobSidecar.signedBlockHeader);
+    const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      chain.index2pubkey,
+      blockState,
+      blobSidecar.signedBlockHeader
+    );
     // Don't batch so verification is not delayed
     if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
       throw new BlobSidecarGossipError(GossipAction.REJECT, {
@@ -240,7 +244,11 @@ export async function validateBlockBlobSidecars(
     const signature = firstSidecarSignedBlockHeader.signature;
     if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRootHex, signature)) {
       const headState = await chain.getHeadState();
-      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+        chain.index2pubkey,
+        headState,
+        firstSidecarSignedBlockHeader
+      );
 
       if (
         !(await chain.bls.verifySignatureSets([signatureSet], {

package/src/chain/validation/block.ts

@@ -6,7 +6,6 @@ import {
   computeTimeAtSlot,
   getBlockProposerSignatureSet,
   isExecutionBlockBodyType,
-  isExecutionEnabled,
   isExecutionStateType,
 } from "@lodestar/state-transition";
 import {SignedBeaconBlock, deneb} from "@lodestar/types";
@@ -140,7 +139,7 @@ export async function validateGossipBlock(
   if (fork === ForkName.bellatrix) {
     if (!isExecutionBlockBodyType(block.body)) throw Error("Not merge block type");
     const executionPayload = block.body.executionPayload;
-    if (isExecutionStateType(blockState) && isExecutionEnabled(blockState, block)) {
+    if (isExecutionStateType(blockState)) {
       const expectedTimestamp = computeTimeAtSlot(config, blockSlot, chain.genesisTime);
       if (executionPayload.timestamp !== computeTimeAtSlot(config, blockSlot, chain.genesisTime)) {
         throw new BlockGossipError(GossipAction.REJECT, {
@@ -154,7 +153,7 @@ export async function validateGossipBlock(
 
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRoot, signedBlock.signature)) {
-    const signatureSet = getBlockProposerSignatureSet(blockState, signedBlock);
+    const signatureSet = getBlockProposerSignatureSet(chain.index2pubkey, blockState, signedBlock);
     // Don't batch so verification is not delayed
     if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: true}))) {
       throw new BlockGossipError(GossipAction.REJECT, {

package/src/chain/validation/dataColumnSidecar.ts

@@ -135,6 +135,7 @@ export async function validateGossipDataColumnSidecar(
   const signature = dataColumnSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockHeader.slot, blockRootHex, signature)) {
     const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      chain.index2pubkey,
       blockState,
       dataColumnSidecar.signedBlockHeader
     );
@@ -336,7 +337,11 @@ export async function validateBlockDataColumnSidecars(
     const signature = firstSidecarSignedBlockHeader.signature;
     if (!chain.seenBlockInputCache.isVerifiedProposerSignature(slot, rootHex, signature)) {
       const headState = await chain.getHeadState();
-      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(headState, firstSidecarSignedBlockHeader);
+      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+        chain.index2pubkey,
+        headState,
+        firstSidecarSignedBlockHeader
+      );
 
       if (
         !(await chain.bls.verifySignatureSets([signatureSet], {

package/src/chain/validation/proposerSlashing.ts

@@ -44,7 +44,7 @@ async function validateProposerSlashing(
     });
   }
 
-  const signatureSets = getProposerSlashingSignatureSets(state, proposerSlashing);
+  const signatureSets = getProposerSlashingSignatureSets(chain.index2pubkey, state, proposerSlashing);
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true, priority: prioritizeBls}))) {
     throw new ProposerSlashingError(GossipAction.REJECT, {
       code: ProposerSlashingErrorCode.INVALID,

package/src/chain/validation/signatureSets/contributionAndProof.ts

@@ -2,16 +2,17 @@ import {DOMAIN_CONTRIBUTION_AND_PROOF} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getContributionAndProofSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedContributionAndProof: altair.SignedContributionAndProof
 ): ISignatureSet {
-  const {epochCtx} = state;
   const domain = state.config.getDomain(
     state.slot,
     DOMAIN_CONTRIBUTION_AND_PROOF,
@@ -20,7 +21,7 @@ export function getContributionAndProofSignatureSet(
   const signingData = signedContributionAndProof.message;
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedContributionAndProof.message.aggregatorIndex],
+    pubkey: index2pubkey[signedContributionAndProof.message.aggregatorIndex],
     signingRoot: computeSigningRoot(ssz.altair.ContributionAndProof, signingData, domain),
     signature: signedContributionAndProof.signature,
   };

package/src/chain/validation/signatureSets/syncCommittee.ts

@@ -2,12 +2,14 @@ import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   syncCommittee: altair.SyncCommitteeMessage
 ): ISignatureSet {
@@ -15,7 +17,7 @@ export function getSyncCommitteeSignatureSet(
 
   return {
     type: SignatureSetType.single,
-    pubkey: state.epochCtx.index2pubkey[syncCommittee.validatorIndex],
+    pubkey: index2pubkey[syncCommittee.validatorIndex],
     signingRoot: computeSigningRoot(ssz.Root, syncCommittee.beaconBlockRoot, domain),
     signature: syncCommittee.signature,
   };

package/src/chain/validation/signatureSets/syncCommitteeSelectionProof.ts

@@ -2,16 +2,18 @@ import {DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   ISignatureSet,
+  Index2PubkeyCache,
   SignatureSetType,
   computeSigningRoot,
 } from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSelectionProofSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   contributionAndProof: altair.ContributionAndProof
 ): ISignatureSet {
-  const {epochCtx, config} = state;
+  const {config} = state;
   const slot = contributionAndProof.contribution.slot;
   const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF, slot);
   const signingData: altair.SyncAggregatorSelectionData = {
@@ -20,7 +22,7 @@ export function getSyncCommitteeSelectionProofSignatureSet(
   };
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[contributionAndProof.aggregatorIndex],
+    pubkey: index2pubkey[contributionAndProof.aggregatorIndex],
     signingRoot: computeSigningRoot(ssz.altair.SyncAggregatorSelectionData, signingData, domain),
     signature: contributionAndProof.selectionProof,
   };

package/src/chain/validation/syncCommittee.ts

@@ -89,7 +89,7 @@ async function validateSyncCommitteeSigOnly(
   syncCommittee: altair.SyncCommitteeMessage,
   prioritizeBls = false
 ): Promise<void> {
-  const signatureSet = getSyncCommitteeSignatureSet(headState, syncCommittee);
+  const signatureSet = getSyncCommitteeSignatureSet(chain.index2pubkey, headState, syncCommittee);
   if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
     throw new SyncCommitteeError(GossipAction.REJECT, {
       code: SyncCommitteeErrorCode.INVALID_SIGNATURE,

package/src/chain/validation/syncCommitteeContributionAndProof.ts

@@ -21,6 +21,7 @@ export async function validateSyncCommitteeGossipContributionAndProof(
   const contributionAndProof = signedContributionAndProof.message;
   const {contribution, aggregatorIndex} = contributionAndProof;
   const {subcommitteeIndex, slot} = contribution;
+  const {index2pubkey} = chain;
 
   const headState = chain.getHeadState();
   validateGossipSyncCommitteeExceptSig(chain, headState, subcommitteeIndex, {
@@ -73,16 +74,14 @@ export async function validateSyncCommitteeGossipContributionAndProof(
   // i.e. state.validators[contribution_and_proof.aggregator_index].pubkey in get_sync_subcommittee_pubkeys(state, contribution.subcommittee_index).
   // > Checked in validateGossipSyncCommitteeExceptSig()
 
-  const participantPubkeys = syncCommitteeParticipantIndices.map(
-    (validatorIndex) => headState.epochCtx.index2pubkey[validatorIndex]
-  );
+  const participantPubkeys = syncCommitteeParticipantIndices.map((validatorIndex) => index2pubkey[validatorIndex]);
   const signatureSets = [
     // [REJECT] The contribution_and_proof.selection_proof is a valid signature of the SyncAggregatorSelectionData
     // derived from the contribution by the validator with index contribution_and_proof.aggregator_index.
-    getSyncCommitteeSelectionProofSignatureSet(headState, contributionAndProof),
+    getSyncCommitteeSelectionProofSignatureSet(index2pubkey, headState, contributionAndProof),
 
     // [REJECT] The aggregator signature, signed_contribution_and_proof.signature, is valid.
-    getContributionAndProofSignatureSet(headState, signedContributionAndProof),
+    getContributionAndProofSignatureSet(index2pubkey, headState, signedContributionAndProof),
 
     // [REJECT] The aggregate signature is valid for the message beacon_block_root and aggregate pubkey derived from
     // the participation info in aggregation_bits for the subcommittee specified by the contribution.subcommittee_index.

package/src/chain/validation/voluntaryExit.ts

@@ -59,7 +59,7 @@ async function validateVoluntaryExit(
     });
   }
 
-  const signatureSet = getVoluntaryExitSignatureSet(state, voluntaryExit);
+  const signatureSet = getVoluntaryExitSignatureSet(chain.index2pubkey, state, voluntaryExit);
   if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
     throw new VoluntaryExitError(GossipAction.REJECT, {
       code: VoluntaryExitErrorCode.INVALID_SIGNATURE,

package/src/eth1/index.ts

@@ -1,9 +1,6 @@
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {Root} from "@lodestar/types";
-import {fromHex} from "@lodestar/utils";
 import {Eth1DepositDataTracker, Eth1DepositDataTrackerModules} from "./eth1DepositDataTracker.js";
-import {Eth1MergeBlockTracker, Eth1MergeBlockTrackerModules} from "./eth1MergeBlockTracker.js";
-import {Eth1DataAndDeposits, IEth1ForBlockProduction, IEth1Provider, PowMergeBlock, TDProgress} from "./interface.js";
+import {Eth1DataAndDeposits, IEth1ForBlockProduction, IEth1Provider} from "./interface.js";
 import {Eth1Options} from "./options.js";
 import {Eth1Provider} from "./provider/eth1Provider.js";
 export {Eth1Provider};
@@ -23,23 +20,6 @@ export type {IEth1ForBlockProduction, IEth1Provider};
 //
 // - Fetch ALL deposit events from the deposit contract to build the deposit tree and validate future merkle proofs.
 //   Then it must follow deposit events at a distance roughly similar to the `ETH1_FOLLOW_DISTANCE` parameter above.
-//
-// - [New bellatrix]: After BELLATRIX_FORK_EPOCH, it must fetch the block with hash
-//   `state.eth1_data.block_hash` to compute `terminal_total_difficulty`. Note this may change with
-//   https://github.com/ethereum/consensus-specs/issues/2603.
-//
-// - [New bellatrix]: On block production post BELLATRIX_FORK_EPOCH, pre merge, the beacon node must find the merge block
-//   crossing the `terminal_total_difficulty` boundary and include it in the block. After the merge block production
-//   will just use `execution_engine.assemble_block` without fetching individual blocks.
-//
-// - [New bellatrix]: Fork-choice must validate the merge block ensuring it crossed the `terminal_total_difficulty`
-//   boundary, so it must fetch the POW block referenced in the merge block + its POW parent block.
-//
-// With the merge the beacon node has to follow the eth1 chain at two distances:
-// 1. At `ETH1_FOLLOW_DISTANCE` for eth1Data to be re-org safe
-// 2. At the head to get the first merge block, tolerating possible re-orgs
-//
-// Then both streams of blocks should not be merged since it's harder to guard against re-orgs from (2) to (1).
 
 export function initializeEth1ForBlockProduction(
   opts: Eth1Options,
@@ -59,12 +39,8 @@ export function initializeEth1ForBlockProduction(
 
 export class Eth1ForBlockProduction implements IEth1ForBlockProduction {
   private readonly eth1DepositDataTracker: Eth1DepositDataTracker | null;
-  private readonly eth1MergeBlockTracker: Eth1MergeBlockTracker;
 
-  constructor(
-    opts: Eth1Options,
-    modules: Eth1DepositDataTrackerModules & Eth1MergeBlockTrackerModules & {eth1Provider?: IEth1Provider}
-  ) {
+  constructor(opts: Eth1Options, modules: Eth1DepositDataTrackerModules & {eth1Provider?: IEth1Provider}) {
     const eth1Provider =
       modules.eth1Provider ||
       new Eth1Provider(
@@ -77,8 +53,6 @@ export class Eth1ForBlockProduction implements IEth1ForBlockProduction {
     this.eth1DepositDataTracker = opts.disableEth1DepositDataTracker
       ? null
       : new Eth1DepositDataTracker(opts, modules, eth1Provider);
-
-    this.eth1MergeBlockTracker = new Eth1MergeBlockTracker(modules, eth1Provider);
   }
 
   async getEth1DataAndDeposits(state: CachedBeaconStateAllForks): Promise<Eth1DataAndDeposits> {
@@ -88,23 +62,6 @@ export class Eth1ForBlockProduction implements IEth1ForBlockProduction {
     return this.eth1DepositDataTracker.getEth1DataAndDeposits(state);
   }
 
-  async getTerminalPowBlock(): Promise<Root | null> {
-    const block = await this.eth1MergeBlockTracker.getTerminalPowBlock();
-    return block && fromHex(block.blockHash);
-  }
-
-  getPowBlock(powBlockHash: string): Promise<PowMergeBlock | null> {
-    return this.eth1MergeBlockTracker.getPowBlock(powBlockHash);
-  }
-
-  getTDProgress(): TDProgress | null {
-    return this.eth1MergeBlockTracker.getTDProgress();
-  }
-
-  startPollingMergeBlock(): void {
-    this.eth1MergeBlockTracker.startPollingMergeBlock();
-  }
-
   isPollingEth1Data(): boolean {
     return this.eth1DepositDataTracker?.isPollingEth1Data() ?? false;
   }
@@ -127,30 +84,10 @@ export class Eth1ForBlockProductionDisabled implements IEth1ForBlockProduction {
     return {eth1Data: state.eth1Data, deposits: []};
   }
 
-  /**
-   * Will miss the oportunity to propose the merge block but will still produce valid blocks
-   */
-  async getTerminalPowBlock(): Promise<Root | null> {
-    return null;
-  }
-
-  /** Will not be able to validate the merge block */
-  async getPowBlock(_powBlockHash: string): Promise<PowMergeBlock | null> {
-    throw Error("eth1 must be enabled to verify merge block");
-  }
-
-  getTDProgress(): TDProgress | null {
-    return null;
-  }
-
   isPollingEth1Data(): boolean {
     return false;
   }
 
-  startPollingMergeBlock(): void {
-    // Ignore
-  }
-
   stopPollingEth1Data(): void {
     // Ignore
   }