@lodestar/state-transition 1.38.0 → 1.39.0-dev.d4a47659a5

package/src/block/processAttesterSlashing.ts

@@ -1,5 +1,6 @@
 import {ForkSeq} from "@lodestar/params";
 import {AttesterSlashing} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {getAttesterSlashableIndices, isSlashableAttestationData, isSlashableValidator} from "../util/index.js";
 import {isValidIndexedAttestationBigint} from "./isValidIndexedAttestation.js";
@@ -17,7 +18,8 @@ export function processAttesterSlashing(
   attesterSlashing: AttesterSlashing,
   verifySignatures = true
 ): void {
-  assertValidAttesterSlashing(state, attesterSlashing, verifySignatures);
+  const {epochCtx} = state;
+  assertValidAttesterSlashing(epochCtx.index2pubkey, state, attesterSlashing, verifySignatures);
 
   const intersectingIndices = getAttesterSlashableIndices(attesterSlashing);
 
@@ -25,7 +27,7 @@ export function processAttesterSlashing(
   const validators = state.validators; // Get the validators sub tree once for all indices
   // Spec requires to sort indexes beforehand
   for (const index of intersectingIndices.sort((a, b) => a - b)) {
-    if (isSlashableValidator(validators.getReadonly(index), state.epochCtx.epoch)) {
+    if (isSlashableValidator(validators.getReadonly(index), epochCtx.epoch)) {
       slashValidator(fork, state, index);
       slashedAny = true;
     }
@@ -37,6 +39,7 @@ export function processAttesterSlashing(
 }
 
 export function assertValidAttesterSlashing(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   attesterSlashing: AttesterSlashing,
   verifySignatures = true
@@ -52,7 +55,7 @@ export function assertValidAttesterSlashing(
   // be higher than the clock and the slashing would still be valid. Same applies to attestation data index, which
   // can be any arbitrary value. Must use bigint variants to hash correctly to all possible values
   for (const [i, attestation] of [attestation1, attestation2].entries()) {
-    if (!isValidIndexedAttestationBigint(state, attestation, verifySignatures)) {
+    if (!isValidIndexedAttestationBigint(index2pubkey, state, attestation, verifySignatures)) {
       throw new Error(`AttesterSlashing attestation${i} is invalid`);
     }
   }

package/src/block/processExecutionPayload.ts

@@ -3,11 +3,7 @@ import {ForkName, ForkSeq, isForkPostDeneb} from "@lodestar/params";
 import {BeaconBlockBody, BlindedBeaconBlockBody, deneb, isExecutionPayload} from "@lodestar/types";
 import {toHex, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateBellatrix, CachedBeaconStateCapella} from "../types.js";
-import {
-  executionPayloadToPayloadHeader,
-  getFullOrBlindedPayloadFromBody,
-  isMergeTransitionComplete,
-} from "../util/execution.js";
+import {executionPayloadToPayloadHeader, getFullOrBlindedPayloadFromBody} from "../util/execution.js";
 import {computeEpochAtSlot, computeTimeAtSlot, getRandaoMix} from "../util/index.js";
 import {BlockExternalData, ExecutionPayloadStatus} from "./externalData.js";
 
@@ -21,15 +17,13 @@ export function processExecutionPayload(
   const forkName = ForkName[ForkSeq[fork] as ForkName];
   // Verify consistency of the parent hash, block number, base fee per gas and gas limit
   // with respect to the previous execution payload header
-  if (isMergeTransitionComplete(state)) {
-    const {latestExecutionPayloadHeader} = state;
-    if (!byteArrayEquals(payload.parentHash, latestExecutionPayloadHeader.blockHash)) {
-      throw Error(
-        `Invalid execution payload parentHash ${toRootHex(payload.parentHash)} latest blockHash ${toRootHex(
-          latestExecutionPayloadHeader.blockHash
-        )}`
-      );
-    }
+  const {latestExecutionPayloadHeader} = state;
+  if (!byteArrayEquals(payload.parentHash, latestExecutionPayloadHeader.blockHash)) {
+    throw Error(
+      `Invalid execution payload parentHash ${toRootHex(payload.parentHash)} latest blockHash ${toRootHex(
+        latestExecutionPayloadHeader.blockHash
+      )}`
+    );
   }
 
   // Verify random

package/src/block/processProposerSlashing.ts

@@ -77,7 +77,7 @@ export function assertValidProposerSlashing(
 
   // verify signatures
   if (verifySignatures) {
-    const signatureSets = getProposerSlashingSignatureSets(state, proposerSlashing);
+    const signatureSets = getProposerSlashingSignatureSets(state.epochCtx.index2pubkey, state, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
       if (!verifySignatureSet(signatureSets[i])) {
         throw new Error(`ProposerSlashing header${i + 1} signature invalid`);

package/src/block/processRandao.ts

@@ -17,7 +17,7 @@ export function processRandao(state: CachedBeaconStateAllForks, block: BeaconBlo
   const randaoReveal = block.body.randaoReveal;
 
   // verify RANDAO reveal
-  if (verifySignature && !verifyRandaoSignature(state, block)) {
+  if (verifySignature && !verifyRandaoSignature(epochCtx.index2pubkey, state, block)) {
     throw new Error("RANDAO reveal is an invalid signature");
   }
 

package/src/block/processSyncCommittee.ts

@@ -1,6 +1,7 @@
 import {byteArrayEquals} from "@chainsafe/ssz";
 import {DOMAIN_SYNC_COMMITTEE, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {altair, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {G2_POINT_AT_INFINITY} from "../constants/index.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
@@ -23,7 +24,7 @@ export function processSyncAggregate(
   if (verifySignatures) {
     // This is to conform to the spec - we want the signature to be verified
     const participantIndices = block.body.syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
-    const signatureSet = getSyncCommitteeSignatureSet(state, block, participantIndices);
+    const signatureSet = getSyncCommitteeSignatureSet(state.epochCtx.index2pubkey, state, block, participantIndices);
     // When there's no participation we consider the signature valid and just ignore i
     if (signatureSet !== null && !verifySignatureSet(signatureSet)) {
       throw Error("Sync committee signature invalid");
@@ -63,12 +64,12 @@ export function processSyncAggregate(
 }
 
 export function getSyncCommitteeSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   block: altair.BeaconBlock,
   /** Optional parameter to prevent computing it twice */
   participantIndices?: number[]
 ): ISignatureSet | null {
-  const {epochCtx} = state;
   const {syncAggregate} = block.body;
   const signature = syncAggregate.syncCommitteeSignature;
 
@@ -110,7 +111,7 @@ export function getSyncCommitteeSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: participantIndices.map((i) => epochCtx.index2pubkey[i]),
+    pubkeys: participantIndices.map((i) => index2pubkey[i]),
     signingRoot: computeSigningRoot(ssz.Root, rootSigned, domain),
     signature,
   };

package/src/block/processVoluntaryExit.ts

@@ -74,7 +74,7 @@ export function getVoluntaryExitValidity(
     return VoluntaryExitValidity.pendingWithdrawals;
   }
 
-  if (verifySignature && !verifyVoluntaryExitSignature(state, signedVoluntaryExit)) {
+  if (verifySignature && !verifyVoluntaryExitSignature(epochCtx.index2pubkey, state, signedVoluntaryExit)) {
     return VoluntaryExitValidity.invalidSignature;
   }
 

package/src/signatureSets/attesterSlashings.ts

@@ -1,29 +1,33 @@
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
 import {AttesterSlashing, IndexedAttestationBigint, SignedBeaconBlock, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot, computeStartSlotAtEpoch} from "../util/index.js";
 
 /** Get signature sets from all AttesterSlashing objects in a block */
 export function getAttesterSlashingsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   return signedBlock.message.body.attesterSlashings.flatMap((attesterSlashing) =>
-    getAttesterSlashingSignatureSets(state, attesterSlashing)
+    getAttesterSlashingSignatureSets(index2pubkey, state, attesterSlashing)
   );
 }
 
 /** Get signature sets from a single AttesterSlashing object */
 export function getAttesterSlashingSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   attesterSlashing: AttesterSlashing
 ): ISignatureSet[] {
   return [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
-    getIndexedAttestationBigintSignatureSet(state, attestation)
+    getIndexedAttestationBigintSignatureSet(index2pubkey, state, attestation)
   );
 }
 
 export function getIndexedAttestationBigintSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   indexedAttestation: IndexedAttestationBigint
 ): ISignatureSet {
@@ -32,7 +36,7 @@ export function getIndexedAttestationBigintSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: indexedAttestation.attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
+    pubkeys: indexedAttestation.attestingIndices.map((i) => index2pubkey[i]),
     signingRoot: computeSigningRoot(ssz.phase0.AttestationDataBigint, indexedAttestation.data, domain),
     signature: indexedAttestation.signature,
   };

package/src/signatureSets/index.ts

@@ -1,6 +1,7 @@
 import {ForkSeq} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, altair, capella} from "@lodestar/types";
 import {getSyncCommitteeSignatureSet} from "../block/processSyncCommittee.js";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
 import {ISignatureSet} from "../util/index.js";
 import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
@@ -14,7 +15,7 @@ import {getVoluntaryExitsSignatureSets} from "./voluntaryExits.js";
 export * from "./attesterSlashings.js";
 export * from "./blsToExecutionChange.js";
 export * from "./indexedAttestation.js";
-export * from "./indexedPayloadAttestation.ts";
+export * from "./indexedPayloadAttestation.js";
 export * from "./proposer.js";
 export * from "./proposerSlashings.js";
 export * from "./randao.js";
@@ -25,6 +26,7 @@ export * from "./voluntaryExits.js";
  * Deposits are not included because they can legally have invalid signatures.
  */
 export function getBlockSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[],
@@ -37,20 +39,21 @@ export function getBlockSignatureSets(
   const fork = state.config.getForkSeq(signedBlock.message.slot);
 
   const signatureSets = [
-    getRandaoRevealSignatureSet(state, signedBlock.message),
-    ...getProposerSlashingsSignatureSets(state, signedBlock),
-    ...getAttesterSlashingsSignatureSets(state, signedBlock),
-    ...getAttestationsSignatureSets(state, signedBlock, indexedAttestations),
-    ...getVoluntaryExitsSignatureSets(state, signedBlock),
+    getRandaoRevealSignatureSet(index2pubkey, state, signedBlock.message),
+    ...getProposerSlashingsSignatureSets(index2pubkey, state, signedBlock),
+    ...getAttesterSlashingsSignatureSets(index2pubkey, state, signedBlock),
+    ...getAttestationsSignatureSets(index2pubkey, state, signedBlock, indexedAttestations),
+    ...getVoluntaryExitsSignatureSets(index2pubkey, state, signedBlock),
   ];
 
   if (!opts?.skipProposerSignature) {
-    signatureSets.push(getBlockProposerSignatureSet(state, signedBlock));
+    signatureSets.push(getBlockProposerSignatureSet(index2pubkey, state, signedBlock));
   }
 
   // Only after altair fork, validate tSyncCommitteeSignature
   if (fork >= ForkSeq.altair) {
     const syncCommitteeSignatureSet = getSyncCommitteeSignatureSet(
+      index2pubkey,
       state as CachedBeaconStateAltair,
       (signedBlock as altair.SignedBeaconBlock).message
     );

package/src/signatureSets/indexedAttestation.ts

@@ -1,5 +1,6 @@
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
@@ -19,25 +20,33 @@ export function getAttestationDataSigningRoot(
 }
 
 export function getAttestationWithIndicesSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   attestation: Pick<phase0.Attestation, "data" | "signature">,
   attestingIndices: number[]
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
-    attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
+    attestingIndices.map((i) => index2pubkey[i]),
     getAttestationDataSigningRoot(state, attestation.data),
     attestation.signature
   );
 }
 
 export function getIndexedAttestationSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   indexedAttestation: IndexedAttestation
 ): ISignatureSet {
-  return getAttestationWithIndicesSignatureSet(state, indexedAttestation, indexedAttestation.attestingIndices);
+  return getAttestationWithIndicesSignatureSet(
+    index2pubkey,
+    state,
+    indexedAttestation,
+    indexedAttestation.attestingIndices
+  );
 }
 
 export function getAttestationsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[]
@@ -47,5 +56,7 @@ export function getAttestationsSignatureSets(
       `Indexed attestations length mismatch: got ${indexedAttestations.length}, expected ${signedBlock.message.body.attestations.length}`
     );
   }
-  return indexedAttestations.map((indexedAttestation) => getIndexedAttestationSignatureSet(state, indexedAttestation));
+  return indexedAttestations.map((indexedAttestation) =>
+    getIndexedAttestationSignatureSet(index2pubkey, state, indexedAttestation)
+  );
 }

package/src/signatureSets/proposer.ts

@@ -1,22 +1,25 @@
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, SignedBlindedBeaconBlock, Slot, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {computeSigningRoot} from "../util/index.js";
 import {ISignatureSet, SignatureSetType, verifySignatureSet} from "../util/signatureSets.js";
 
 export function verifyProposerSignature(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
-  const signatureSet = getBlockProposerSignatureSet(state, signedBlock);
+  const signatureSet = getBlockProposerSignatureSet(index2pubkey, state, signedBlock);
   return verifySignatureSet(signatureSet);
 }
 
 export function getBlockProposerSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): ISignatureSet {
-  const {config, epochCtx} = state;
+  const {config} = state;
   const domain = config.getDomain(state.slot, DOMAIN_BEACON_PROPOSER, signedBlock.message.slot);
 
   const blockType = isBlindedBeaconBlock(signedBlock.message)
@@ -25,37 +28,40 @@ export function getBlockProposerSignatureSet(
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedBlock.message.proposerIndex],
+    pubkey: index2pubkey[signedBlock.message.proposerIndex],
     signingRoot: computeSigningRoot(blockType, signedBlock.message, domain),
     signature: signedBlock.signature,
   };
 }
 
 export function getBlockHeaderProposerSignatureSetByParentStateSlot(
+  index2pubkey: Index2PubkeyCache,
   parentState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(parentState, signedBlockHeader, parentState.slot);
+  return getBlockHeaderProposerSignatureSet(index2pubkey, parentState, signedBlockHeader, parentState.slot);
 }
 
 export function getBlockHeaderProposerSignatureSetByHeaderSlot(
+  index2pubkey: Index2PubkeyCache,
   headState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(headState, signedBlockHeader, signedBlockHeader.message.slot);
+  return getBlockHeaderProposerSignatureSet(index2pubkey, headState, signedBlockHeader, signedBlockHeader.message.slot);
 }
 
 function getBlockHeaderProposerSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader,
   domainSlot: Slot
 ): ISignatureSet {
-  const {config, epochCtx} = state;
+  const {config} = state;
   const domain = config.getDomain(domainSlot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedBlockHeader.message.proposerIndex],
+    pubkey: index2pubkey[signedBlockHeader.message.proposerIndex],
     signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeader, signedBlockHeader.message, domain),
     signature: signedBlockHeader.signature,
   };

package/src/signatureSets/proposerSlashings.ts

@@ -1,5 +1,6 @@
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index.js";
 
@@ -7,11 +8,11 @@ import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index
  * Extract signatures to allow validating all block signatures at once
  */
 export function getProposerSlashingSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   proposerSlashing: phase0.ProposerSlashing
 ): ISignatureSet[] {
-  const {epochCtx} = state;
-  const pubkey = epochCtx.index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
+  const pubkey = index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
 
   // In state transition, ProposerSlashing headers are only partially validated. Their slot could be higher than the
   // clock and the slashing would still be valid. Must use bigint variants to hash correctly to all possible values
@@ -32,10 +33,11 @@ export function getProposerSlashingSignatureSets(
 }
 
 export function getProposerSlashingsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   return signedBlock.message.body.proposerSlashings.flatMap((proposerSlashing) =>
-    getProposerSlashingSignatureSets(state, proposerSlashing)
+    getProposerSlashingSignatureSets(index2pubkey, state, proposerSlashing)
   );
 }

package/src/signatureSets/randao.ts

@@ -1,5 +1,6 @@
 import {DOMAIN_RANDAO} from "@lodestar/params";
 import {BeaconBlock, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
@@ -9,22 +10,29 @@ import {
   verifySignatureSet,
 } from "../util/index.js";
 
-export function verifyRandaoSignature(state: CachedBeaconStateAllForks, block: BeaconBlock): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(state, block));
+export function verifyRandaoSignature(
+  index2pubkey: Index2PubkeyCache,
+  state: CachedBeaconStateAllForks,
+  block: BeaconBlock
+): boolean {
+  return verifySignatureSet(getRandaoRevealSignatureSet(index2pubkey, state, block));
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
-export function getRandaoRevealSignatureSet(state: CachedBeaconStateAllForks, block: BeaconBlock): ISignatureSet {
-  const {epochCtx} = state;
+export function getRandaoRevealSignatureSet(
+  index2pubkey: Index2PubkeyCache,
+  state: CachedBeaconStateAllForks,
+  block: BeaconBlock
+): ISignatureSet {
   // should not get epoch from epochCtx
   const epoch = computeEpochAtSlot(block.slot);
   const domain = state.config.getDomain(state.slot, DOMAIN_RANDAO, block.slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[block.proposerIndex],
+    pubkey: index2pubkey[block.proposerIndex],
     signingRoot: computeSigningRoot(ssz.Epoch, epoch, domain),
     signature: block.body.randaoReveal,
   };

package/src/signatureSets/voluntaryExits.ts

@@ -1,4 +1,5 @@
 import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
@@ -9,36 +10,38 @@ import {
 } from "../util/index.js";
 
 export function verifyVoluntaryExitSignature(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(state, signedVoluntaryExit));
+  return verifySignatureSet(getVoluntaryExitSignatureSet(index2pubkey, state, signedVoluntaryExit));
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
 export function getVoluntaryExitSignatureSet(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
-  const {epochCtx} = state;
   const slot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
   const domain = state.config.getDomainForVoluntaryExit(state.slot, slot);
 
   return {
     type: SignatureSetType.single,
-    pubkey: epochCtx.index2pubkey[signedVoluntaryExit.message.validatorIndex],
+    pubkey: index2pubkey[signedVoluntaryExit.message.validatorIndex],
     signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
     signature: signedVoluntaryExit.signature,
   };
 }
 
 export function getVoluntaryExitsSignatureSets(
+  index2pubkey: Index2PubkeyCache,
   state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(state, voluntaryExit)
+    getVoluntaryExitSignatureSet(index2pubkey, state, voluntaryExit)
   );
 }

package/src/stateTransition.ts

@@ -111,7 +111,7 @@ export function stateTransition(
   postState = processSlotsWithTransientCache(postState, blockSlot, options, {metrics, validatorMonitor});
 
   // Verify proposer signature only
-  if (verifyProposer && !verifyProposerSignature(postState, signedBlock)) {
+  if (verifyProposer && !verifyProposerSignature(postState.epochCtx.index2pubkey, postState, signedBlock)) {
     throw new Error("Invalid block signature");
   }
 

package/src/util/execution.ts

@@ -2,7 +2,6 @@ import {ForkName, ForkPostBellatrix, ForkPreGloas, ForkSeq} from "@lodestar/para
 import {
   BeaconBlock,
   BeaconBlockBody,
-  BlindedBeaconBlock,
   BlindedBeaconBlockBody,
   ExecutionPayload,
   ExecutionPayloadHeader,
@@ -10,75 +9,16 @@ import {
   capella,
   deneb,
   isBlindedBeaconBlockBody,
-  isExecutionPayload,
   ssz,
 } from "@lodestar/types";
 import {
   BeaconStateAllForks,
-  BeaconStateBellatrix,
   BeaconStateCapella,
   BeaconStateExecutions,
   CachedBeaconStateAllForks,
   CachedBeaconStateExecutions,
 } from "../types.js";
 
-/**
- * Execution enabled = merge is done.
- * When (A) state has execution data OR (B) block has execution data
- */
-export function isExecutionEnabled(state: BeaconStateExecutions, block: BeaconBlock | BlindedBeaconBlock): boolean {
-  if (isMergeTransitionComplete(state)) {
-    return true;
-  }
-
-  // Throws if not post-bellatrix block. A fork-guard in isExecutionEnabled() prevents this from happening
-  const payload = getFullOrBlindedPayload(block);
-  // Note: spec says to check all payload is zero-ed. However a state-root cannot be zero for any non-empty payload
-  // TODO: Consider comparing with the payload root if this assumption is not correct.
-  // return !byteArrayEquals(payload.stateRoot, ZERO_HASH);
-
-  // UPDATE: stateRoot comparision should have been enough with zero hash, but spec tests were failing
-  // Revisit this later to fix specs and make this efficient
-  return isExecutionPayload(payload)
-    ? !ssz.bellatrix.ExecutionPayload.equals(payload, ssz.bellatrix.ExecutionPayload.defaultValue())
-    : !ssz.bellatrix.ExecutionPayloadHeader.equals(
-        state.latestExecutionPayloadHeader,
-        // TODO: Performance
-        ssz.bellatrix.ExecutionPayloadHeader.defaultValue()
-      );
-}
-
-/**
- * Merge block is the SINGLE block that transitions from POW to POS.
- * state has no execution data AND this block has execution data
- */
-export function isMergeTransitionBlock(state: BeaconStateExecutions, body: bellatrix.BeaconBlockBody): boolean {
-  return (
-    !isMergeTransitionComplete(state) &&
-    !ssz.bellatrix.ExecutionPayload.equals(body.executionPayload, ssz.bellatrix.ExecutionPayload.defaultValue())
-  );
-}
-
-/**
- * Merge is complete when the state includes execution layer data:
- * state.latestExecutionPayloadHeader NOT EMPTY
- */
-export function isMergeTransitionComplete(state: BeaconStateExecutions): boolean {
-  if (!isCapellaStateType(state)) {
-    return !ssz.bellatrix.ExecutionPayloadHeader.equals(
-      (state as BeaconStateBellatrix).latestExecutionPayloadHeader,
-      // TODO: Performance
-      ssz.bellatrix.ExecutionPayloadHeader.defaultValue()
-    );
-  }
-
-  return !ssz.capella.ExecutionPayloadHeader.equals(
-    state.latestExecutionPayloadHeader,
-    // TODO: Performance
-    ssz.capella.ExecutionPayloadHeader.defaultValue()
-  );
-}
-
 /** Type guard for bellatrix.BeaconState */
 export function isExecutionStateType(state: BeaconStateAllForks): state is BeaconStateExecutions {
   return (state as BeaconStateExecutions).latestExecutionPayloadHeader !== undefined;