@lodestar/beacon-node 1.38.0 → 1.39.0-dev.100ab480bb

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,13 +42,10 @@ 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 {numToQuantity} from "../../eth1/provider/utils.js";
+import {ZERO_HASH_HEX} from "../../constants/index.js";
+import {numToQuantity} from "../../execution/engine/utils.js";
 import {
   IExecutionBuilder,
   IExecutionEngine,
@@ -83,7 +78,6 @@ export enum BlockProductionStep {
   voluntaryExits = "voluntaryExits",
   blsToExecutionChanges = "blsToExecutionChanges",
   attestations = "attestations",
-  eth1DataAndDeposits = "eth1DataAndDeposits",
   syncAggregate = "syncAggregate",
   executionPayload = "executionPayload",
 }
@@ -171,7 +165,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 = currentState.config.getForkName(blockSlot);
+  const fork = this.config.getForkName(blockSlot);
   const produceResult = {
     type: blockType,
     fork,
@@ -337,14 +331,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 +352,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 +467,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 +481,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 +538,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 +559,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 +574,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(
@@ -740,7 +644,7 @@ export async function produceCommonBlockBody<T extends BlockType>(
       ? this.metrics?.executionBlockProductionTimeSteps
       : this.metrics?.builderBlockProductionTimeSteps;
 
-  const fork = currentState.config.getForkName(slot);
+  const fork = this.config.getForkName(slot);
 
   // TODO:
   // Iterate through the naive aggregation pool and ensure all the attestations from there
@@ -762,20 +666,17 @@ 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,
-    eth1Data,
+    // Eth1 data voting is no longer required since electra
+    eth1Data: currentState.eth1Data,
     proposerSlashings,
     attesterSlashings,
     attestations,
-    deposits,
+    // Since electra, deposits are processed by the execution layer,
+    // we no longer support handling deposits from earlier forks.
+    deposits: [],
     voluntaryExits,
   };
 

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -1,4 +1,5 @@
 import {routes} from "@lodestar/api";
+import {BeaconConfig} from "@lodestar/config";
 import {
   CachedBeaconStateAllForks,
   computeStartSlotAtEpoch,
@@ -24,6 +25,7 @@ export type PersistentCheckpointStateCacheOpts = {
 };
 
 type PersistentCheckpointStateCacheModules = {
+  config: BeaconConfig;
   metrics?: Metrics | null;
   logger: Logger;
   clock?: IClock | null;
@@ -107,6 +109,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   private readonly cache: MapTracker<CacheKey, CacheItem>;
   /** Epoch -> Set<blockRoot> */
   private readonly epochIndex = new MapDef<Epoch, Set<RootHex>>(() => new Set<string>());
+  private readonly config: BeaconConfig;
   private readonly metrics: Metrics | null | undefined;
   private readonly logger: Logger;
   private readonly clock: IClock | null | undefined;
@@ -120,10 +123,20 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   private readonly bufferPool?: BufferPool | null;
 
   constructor(
-    {metrics, logger, clock, signal, datastore, blockStateCache, bufferPool}: PersistentCheckpointStateCacheModules,
+    {
+      config,
+      metrics,
+      logger,
+      clock,
+      signal,
+      datastore,
+      blockStateCache,
+      bufferPool,
+    }: PersistentCheckpointStateCacheModules,
     opts: PersistentCheckpointStateCacheOpts
   ) {
     this.cache = new MapTracker(metrics?.cpStateCache);
+    this.config = config;
     if (metrics) {
       this.metrics = metrics;
       metrics.cpStateCache.size.addCollect(() => {
@@ -484,7 +497,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     }
 
     const blockSlot = state.slot;
-    const processCPStatesTimeMs = state.config.getSlotComponentDurationMs(PROCESS_CHECKPOINT_STATES_BPS);
+    const processCPStatesTimeMs = this.config.getSlotComponentDurationMs(PROCESS_CHECKPOINT_STATES_BPS);
     // we always have clock in production, fallback value is only for test
     const msFromSlot = this.clock?.msFromSlot(blockSlot) ?? processCPStatesTimeMs;
     const msToProcessCPStates = processCPStatesTimeMs - msFromSlot;

package/src/chain/validation/aggregateAndProof.ts

@@ -245,6 +245,18 @@ async function validateAggregateAndProof(
     });
   }
 
+  // Same race-condition check as above for seen aggregators
+  if (
+    !skipValidationKnownAttesters &&
+    chain.seenAggregatedAttestations.isKnown(targetEpoch, attIndex, attDataRootHex, aggregationBits)
+  ) {
+    throw new AttestationError(GossipAction.IGNORE, {
+      code: AttestationErrorCode.ATTESTERS_ALREADY_KNOWN,
+      targetEpoch,
+      aggregateRoot: attDataRootHex,
+    });
+  }
+
   chain.seenAggregators.add(targetEpoch, aggregatorIndex);
   chain.seenAggregatedAttestations.add(
     targetEpoch,

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,12 @@ export async function validateAttesterSlashing(
     });
   }
 
-  const signatureSets = getAttesterSlashingSignatureSets(state, attesterSlashing);
+  const signatureSets = getAttesterSlashingSignatureSets(
+    chain.config,
+    chain.index2pubkey,
+    state.slot,
+    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

@@ -154,7 +154,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.config, chain.index2pubkey, 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/blsToExecutionChange.ts

@@ -41,7 +41,7 @@ async function validateBlsToExecutionChange(
   // NOTE: No need to advance head state since the signature's fork is handled with `broadcastedOnFork`,
   // and chanes relevant to `isValidBlsToExecutionChange()` happen only on processBlock(), not processEpoch()
   const state = chain.getHeadState();
-  const {config} = state;
+  const {config} = chain;
 
   // [REJECT] All of the conditions within process_bls_to_execution_change pass validation.
   // verifySignature = false, verified in batch below

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

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

@@ -14,7 +14,7 @@ export function getAggregateAndProofSigningRoot(
   epoch: Epoch,
   aggregateAndProof: SignedAggregateAndProof
 ): Uint8Array {
-  // previously, we call `const aggregatorDomain = state.config.getDomain(state.slot, DOMAIN_AGGREGATE_AND_PROOF, slot);`
+  // previously, we call `const aggregatorDomain = config.getDomain(state.slot, DOMAIN_AGGREGATE_AND_PROOF, slot);`
   // at fork boundary, it's required to dial to target epoch https://github.com/ChainSafe/lodestar/blob/v1.11.3/packages/beacon-node/src/chain/validation/attestation.ts#L573
   // instead of that, just use the fork of slot in the attestation data
   const slot = computeStartSlotAtEpoch(epoch);

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

@@ -1,18 +1,21 @@
+import {BeaconConfig} from "@lodestar/config";
 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(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedContributionAndProof: altair.SignedContributionAndProof
 ): ISignatureSet {
-  const {epochCtx} = state;
-  const domain = state.config.getDomain(
+  const domain = config.getDomain(
     state.slot,
     DOMAIN_CONTRIBUTION_AND_PROOF,
     signedContributionAndProof.message.contribution.slot
@@ -20,7 +23,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

@@ -1,21 +1,25 @@
+import {BeaconConfig} from "@lodestar/config";
 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(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   syncCommittee: altair.SyncCommitteeMessage
 ): ISignatureSet {
-  const domain = state.config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, syncCommittee.slot);
+  const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, syncCommittee.slot);
 
   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/syncCommitteeContribution.ts

@@ -1,14 +1,16 @@
 import {PublicKey} from "@chainsafe/blst";
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
 import {CachedBeaconStateAltair, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeContributionSignatureSet(
+  config: BeaconConfig,
   state: CachedBeaconStateAltair,
   contribution: altair.SyncCommitteeContribution,
   pubkeys: PublicKey[]
 ): ISignatureSet {
-  const domain = state.config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, contribution.slot);
+  const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, contribution.slot);
   return {
     type: SignatureSetType.aggregate,
     pubkeys,

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

@@ -1,17 +1,20 @@
+import {BeaconConfig} from "@lodestar/config";
 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(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   contributionAndProof: altair.ContributionAndProof
 ): ISignatureSet {
-  const {epochCtx, 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 +23,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.config, 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,20 +74,23 @@ 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(chain.config, index2pubkey, headState, contributionAndProof),
 
     // [REJECT] The aggregator signature, signed_contribution_and_proof.signature, is valid.
-    getContributionAndProofSignatureSet(headState, signedContributionAndProof),
+    getContributionAndProofSignatureSet(chain.config, 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.
-    getSyncCommitteeContributionSignatureSet(headState as CachedBeaconStateAltair, contribution, participantPubkeys),
+    getSyncCommitteeContributionSignatureSet(
+      chain.config,
+      headState as CachedBeaconStateAltair,
+      contribution,
+      participantPubkeys
+    ),
   ];
 
   if (!(await chain.bls.verifySignatureSets(signatureSets, {batchable: true}))) {

package/src/chain/validation/voluntaryExit.ts

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