@lodestar/state-transition 1.39.0-dev.aceb5b7416 → 1.39.0-dev.ad129ced66

package/src/rewards/blockRewards.ts

@@ -0,0 +1,150 @@
+import {BeaconConfig} from "@lodestar/config";
+import {
+  ForkName,
+  WHISTLEBLOWER_REWARD_QUOTIENT,
+  WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA,
+  isForkPostElectra,
+} from "@lodestar/params";
+import {BeaconBlock, altair, phase0, rewards} from "@lodestar/types";
+import {processAttestationsAltair} from "../block/processAttestationsAltair.js";
+import {RewardCache} from "../cache/rewardCache.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair, CachedBeaconStatePhase0} from "../cache/stateCache.js";
+import {getAttesterSlashableIndices} from "../util/attestation.js";
+
+type SubRewardValue = number; // All reward values should be integer
+
+/**
+ * Calculate total proposer block rewards given block and the beacon state of the same slot before the block is applied (preState)
+ * postState can be passed in to read reward cache if available
+ * Standard (Non MEV) rewards for proposing a block consists of:
+ *  1) Including attestations from (beacon) committee
+ *  2) Including attestations from sync committee
+ *  3) Reporting slashable behaviours from proposer and attester
+ */
+export async function computeBlockRewards(
+  config: BeaconConfig,
+  block: BeaconBlock,
+  preStateIn: CachedBeaconStateAllForks,
+  proposerRewards?: RewardCache
+): Promise<rewards.BlockRewards> {
+  const preState = preStateIn.clone();
+
+  const fork = config.getForkName(block.slot);
+  const {attestations: cachedAttestationsReward = 0, syncAggregate: cachedSyncAggregateReward = 0} =
+    proposerRewards ?? {};
+  let blockAttestationReward = cachedAttestationsReward;
+  let syncAggregateReward = cachedSyncAggregateReward;
+
+  if (blockAttestationReward === 0) {
+    blockAttestationReward =
+      fork === ForkName.phase0
+        ? computeBlockAttestationRewardPhase0(block as phase0.BeaconBlock, preState as CachedBeaconStatePhase0)
+        : computeBlockAttestationRewardAltair(config, block as altair.BeaconBlock, preState as CachedBeaconStateAltair);
+  }
+
+  if (syncAggregateReward === 0) {
+    syncAggregateReward = computeSyncAggregateReward(block as altair.BeaconBlock, preState as CachedBeaconStateAltair);
+  }
+
+  const blockProposerSlashingReward = computeBlockProposerSlashingReward(fork, block, preState);
+  const blockAttesterSlashingReward = computeBlockAttesterSlashingReward(fork, block, preState);
+
+  const total =
+    blockAttestationReward + syncAggregateReward + blockProposerSlashingReward + blockAttesterSlashingReward;
+
+  return {
+    proposerIndex: block.proposerIndex,
+    total,
+    attestations: blockAttestationReward,
+    syncAggregate: syncAggregateReward,
+    proposerSlashings: blockProposerSlashingReward,
+    attesterSlashings: blockAttesterSlashingReward,
+  };
+}
+
+/**
+ * TODO: Calculate rewards received by block proposer for including attestations.
+ */
+function computeBlockAttestationRewardPhase0(
+  _block: phase0.BeaconBlock,
+  _preState: CachedBeaconStatePhase0
+): SubRewardValue {
+  throw new Error("Unsupported fork! Block attestation reward calculation is not available in phase0");
+}
+
+/**
+ * Calculate rewards received by block proposer for including attestations since Altair.
+ * Reuses `processAttestationsAltair()`. Has dependency on RewardCache
+ */
+function computeBlockAttestationRewardAltair(
+  config: BeaconConfig,
+  block: altair.BeaconBlock,
+  preState: CachedBeaconStateAltair
+): SubRewardValue {
+  const fork = config.getForkSeq(block.slot);
+  const {attestations} = block.body;
+
+  processAttestationsAltair(fork, preState, attestations, false);
+
+  return preState.proposerRewards.attestations;
+}
+
+function computeSyncAggregateReward(block: altair.BeaconBlock, preState: CachedBeaconStateAltair): SubRewardValue {
+  if (block.body.syncAggregate !== undefined) {
+    const {syncCommitteeBits} = block.body.syncAggregate;
+    const {syncProposerReward} = preState.epochCtx;
+
+    return syncCommitteeBits.getTrueBitIndexes().length * Math.floor(syncProposerReward); // syncProposerReward should already be integer
+  }
+
+  return 0; // phase0 block does not have syncAggregate
+}
+
+/**
+ * Calculate rewards received by block proposer for including proposer slashings.
+ * All proposer slashing rewards go to block proposer and none to whistleblower as of Deneb
+ */
+function computeBlockProposerSlashingReward(
+  fork: ForkName,
+  block: BeaconBlock,
+  state: CachedBeaconStateAllForks
+): SubRewardValue {
+  let proposerSlashingReward = 0;
+
+  for (const proposerSlashing of block.body.proposerSlashings) {
+    const offendingProposerIndex = proposerSlashing.signedHeader1.message.proposerIndex;
+    const offendingProposerBalance = state.validators.getReadonly(offendingProposerIndex).effectiveBalance;
+    const whistleblowerRewardQuotient = isForkPostElectra(fork)
+      ? WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA
+      : WHISTLEBLOWER_REWARD_QUOTIENT;
+
+    proposerSlashingReward += Math.floor(offendingProposerBalance / whistleblowerRewardQuotient);
+  }
+
+  return proposerSlashingReward;
+}
+
+/**
+ * Calculate rewards received by block proposer for including attester slashings.
+ * All attester slashing rewards go to block proposer and none to whistleblower as of Deneb
+ */
+function computeBlockAttesterSlashingReward(
+  fork: ForkName,
+  block: BeaconBlock,
+  preState: CachedBeaconStateAllForks
+): SubRewardValue {
+  let attesterSlashingReward = 0;
+
+  for (const attesterSlashing of block.body.attesterSlashings) {
+    for (const offendingAttesterIndex of getAttesterSlashableIndices(attesterSlashing)) {
+      const offendingAttesterBalance = preState.validators.getReadonly(offendingAttesterIndex).effectiveBalance;
+      const whistleblowerRewardQuotient = isForkPostElectra(fork)
+        ? WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA
+        : WHISTLEBLOWER_REWARD_QUOTIENT;
+
+      attesterSlashingReward += Math.floor(offendingAttesterBalance / whistleblowerRewardQuotient);
+    }
+  }
+
+  return attesterSlashingReward;
+}

package/src/rewards/index.ts

@@ -0,0 +1,3 @@
+export * from "./attestationsRewards.js";
+export * from "./blockRewards.js";
+export * from "./syncCommitteeRewards.js";

package/src/rewards/syncCommitteeRewards.ts

@@ -0,0 +1,56 @@
+import {BeaconConfig} from "@lodestar/config";
+import {ForkName, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
+import {BeaconBlock, ValidatorIndex, altair, rewards} from "@lodestar/types";
+import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../cache/stateCache.js";
+
+export async function computeSyncCommitteeRewards(
+  config: BeaconConfig,
+  index2pubkey: Index2PubkeyCache,
+  block: BeaconBlock,
+  preState: CachedBeaconStateAllForks,
+  validatorIds: (ValidatorIndex | string)[] = []
+): Promise<rewards.SyncCommitteeRewards> {
+  const fork = config.getForkName(block.slot);
+  if (fork === ForkName.phase0) {
+    throw Error("Cannot get sync rewards as phase0 block does not have sync committee");
+  }
+
+  const altairBlock = block as altair.BeaconBlock;
+  const preStateAltair = preState.clone() as CachedBeaconStateAltair;
+
+  // Bound syncCommitteeValidatorIndices in case it goes beyond SYNC_COMMITTEE_SIZE just to be safe
+  const syncCommitteeValidatorIndices = preStateAltair.epochCtx.currentSyncCommitteeIndexed.validatorIndices.slice(
+    0,
+    SYNC_COMMITTEE_SIZE
+  );
+  const {syncParticipantReward} = preStateAltair.epochCtx;
+  const {syncCommitteeBits} = altairBlock.body.syncAggregate;
+
+  // Track reward deltas per validator (can appear multiple times in sync committee)
+  const rewardDeltas: Map<ValidatorIndex, number> = new Map();
+
+  // Iterate by position index to correctly access syncCommitteeBits
+  for (let i = 0; i < syncCommitteeValidatorIndices.length; i++) {
+    const validatorIndex = syncCommitteeValidatorIndices[i];
+    const currentDelta = rewardDeltas.get(validatorIndex) ?? 0;
+    if (syncCommitteeBits.get(i)) {
+      // Positive rewards for participants
+      rewardDeltas.set(validatorIndex, currentDelta + syncParticipantReward);
+    } else {
+      // Negative rewards for non participants
+      rewardDeltas.set(validatorIndex, currentDelta - syncParticipantReward);
+    }
+  }
+
+  const rewards = Array.from(rewardDeltas, ([validatorIndex, reward]) => ({validatorIndex, reward}));
+
+  if (validatorIds.length) {
+    const filtersSet = new Set(validatorIds);
+    return rewards.filter(
+      (reward) => filtersSet.has(reward.validatorIndex) || filtersSet.has(index2pubkey[reward.validatorIndex].toHex())
+    );
+  }
+
+  return rewards;
+}

package/src/signatureSets/attesterSlashings.ts

@@ -1,38 +1,43 @@
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
-import {AttesterSlashing, IndexedAttestationBigint, SignedBeaconBlock, ssz} from "@lodestar/types";
+import {AttesterSlashing, IndexedAttestationBigint, SignedBeaconBlock, Slot, 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(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
+  // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
+  // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
+  const blockSlot = signedBlock.message.slot;
   return signedBlock.message.body.attesterSlashings.flatMap((attesterSlashing) =>
-    getAttesterSlashingSignatureSets(index2pubkey, state, attesterSlashing)
+    getAttesterSlashingSignatureSets(config, index2pubkey, blockSlot, attesterSlashing)
   );
 }
 
 /** Get signature sets from a single AttesterSlashing object */
 export function getAttesterSlashingSignatureSets(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   attesterSlashing: AttesterSlashing
 ): ISignatureSet[] {
   return [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
-    getIndexedAttestationBigintSignatureSet(index2pubkey, state, attestation)
+    getIndexedAttestationBigintSignatureSet(config, index2pubkey, stateSlot, attestation)
   );
 }
 
 export function getIndexedAttestationBigintSignatureSet(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   indexedAttestation: IndexedAttestationBigint
 ): ISignatureSet {
-  const slot = computeStartSlotAtEpoch(Number(indexedAttestation.data.target.epoch as bigint));
-  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_ATTESTER, slot);
+  const messageSlot = computeStartSlotAtEpoch(Number(indexedAttestation.data.target.epoch as bigint));
+  const domain = config.getDomain(stateSlot, DOMAIN_BEACON_ATTESTER, messageSlot);
 
   return {
     type: SignatureSetType.aggregate,

package/src/signatureSets/blsToExecutionChange.ts

@@ -2,14 +2,13 @@ import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BLS_TO_EXECUTION_CHANGE, ForkName} from "@lodestar/params";
 import {capella, ssz} from "@lodestar/types";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot, verifySignatureSet} from "../util/index.js";
 
 export function verifyBlsToExecutionChangeSignature(
-  state: CachedBeaconStateAllForks,
+  config: BeaconConfig,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange
 ): boolean {
-  return verifySignatureSet(getBlsToExecutionChangeSignatureSet(state.config, signedBLSToExecutionChange));
+  return verifySignatureSet(getBlsToExecutionChangeSignatureSet(config, signedBLSToExecutionChange));
 }
 
 /**

package/src/signatureSets/index.ts

@@ -1,8 +1,9 @@
+import {BeaconConfig} from "@lodestar/config";
 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 {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
 import {ISignatureSet} from "../util/index.js";
 import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
 import {getBlsToExecutionChangeSignatureSets} from "./blsToExecutionChange.js";
@@ -26,8 +27,9 @@ export * from "./voluntaryExits.js";
  * Deposits are not included because they can legally have invalid signatures.
  */
 export function getBlockSignatureSets(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  currentSyncCommitteeIndexed: SyncCommitteeCache,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[],
   opts?: {
@@ -36,25 +38,26 @@ export function getBlockSignatureSets(
   }
 ): ISignatureSet[] {
   // fork based validations
-  const fork = state.config.getForkSeq(signedBlock.message.slot);
+  const fork = config.getForkSeq(signedBlock.message.slot);
 
   const signatureSets = [
-    getRandaoRevealSignatureSet(index2pubkey, state, signedBlock.message),
-    ...getProposerSlashingsSignatureSets(index2pubkey, state, signedBlock),
-    ...getAttesterSlashingsSignatureSets(index2pubkey, state, signedBlock),
-    ...getAttestationsSignatureSets(index2pubkey, state, signedBlock, indexedAttestations),
-    ...getVoluntaryExitsSignatureSets(index2pubkey, state, signedBlock),
+    getRandaoRevealSignatureSet(config, index2pubkey, signedBlock.message),
+    ...getProposerSlashingsSignatureSets(config, index2pubkey, signedBlock),
+    ...getAttesterSlashingsSignatureSets(config, index2pubkey, signedBlock),
+    ...getAttestationsSignatureSets(config, index2pubkey, signedBlock, indexedAttestations),
+    ...getVoluntaryExitsSignatureSets(config, index2pubkey, signedBlock),
   ];
 
   if (!opts?.skipProposerSignature) {
-    signatureSets.push(getBlockProposerSignatureSet(index2pubkey, state, signedBlock));
+    signatureSets.push(getBlockProposerSignatureSet(config, index2pubkey, signedBlock));
   }
 
   // Only after altair fork, validate tSyncCommitteeSignature
   if (fork >= ForkSeq.altair) {
     const syncCommitteeSignatureSet = getSyncCommitteeSignatureSet(
+      config,
       index2pubkey,
-      state as CachedBeaconStateAltair,
+      currentSyncCommitteeIndexed,
       (signedBlock as altair.SignedBeaconBlock).message
     );
     // There may be no participants in this syncCommitteeSignature, so it must not be validated
@@ -66,7 +69,7 @@ export function getBlockSignatureSets(
   // only after capella fork
   if (fork >= ForkSeq.capella) {
     const blsToExecutionChangeSignatureSets = getBlsToExecutionChangeSignatureSets(
-      state.config,
+      config,
       signedBlock as capella.SignedBeaconBlock
     );
     if (blsToExecutionChangeSignatureSets.length > 0) {

package/src/signatureSets/indexedAttestation.ts

@@ -1,7 +1,7 @@
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
-import {IndexedAttestation, SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {IndexedAttestation, SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
   computeSigningRoot,
@@ -10,44 +10,48 @@ import {
 } from "../util/index.js";
 
 export function getAttestationDataSigningRoot(
-  state: CachedBeaconStateAllForks,
+  config: BeaconConfig,
+  stateSlot: Slot,
   data: phase0.AttestationData
 ): Uint8Array {
-  const slot = computeStartSlotAtEpoch(data.target.epoch);
-  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_ATTESTER, slot);
+  const messageSlot = computeStartSlotAtEpoch(data.target.epoch);
+  const domain = config.getDomain(stateSlot, DOMAIN_BEACON_ATTESTER, messageSlot);
 
   return computeSigningRoot(ssz.phase0.AttestationData, data, domain);
 }
 
 export function getAttestationWithIndicesSignatureSet(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   attestation: Pick<phase0.Attestation, "data" | "signature">,
   attestingIndices: number[]
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
     attestingIndices.map((i) => index2pubkey[i]),
-    getAttestationDataSigningRoot(state, attestation.data),
+    getAttestationDataSigningRoot(config, stateSlot, attestation.data),
     attestation.signature
   );
 }
 
 export function getIndexedAttestationSignatureSet(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   indexedAttestation: IndexedAttestation
 ): ISignatureSet {
   return getAttestationWithIndicesSignatureSet(
+    config,
     index2pubkey,
-    state,
+    stateSlot,
     indexedAttestation,
     indexedAttestation.attestingIndices
   );
 }
 
 export function getAttestationsSignatureSets(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[]
 ): ISignatureSet[] {
@@ -56,7 +60,10 @@ export function getAttestationsSignatureSets(
       `Indexed attestations length mismatch: got ${indexedAttestations.length}, expected ${signedBlock.message.body.attestations.length}`
     );
   }
+  // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
+  // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
+  const blockSlot = signedBlock.message.slot;
   return indexedAttestations.map((indexedAttestation) =>
-    getIndexedAttestationSignatureSet(index2pubkey, state, indexedAttestation)
+    getIndexedAttestationSignatureSet(config, index2pubkey, blockSlot, indexedAttestation)
   );
 }

package/src/signatureSets/proposer.ts

@@ -1,26 +1,28 @@
+import {BeaconConfig} from "@lodestar/config";
 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(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
-  const signatureSet = getBlockProposerSignatureSet(index2pubkey, state, signedBlock);
+  const signatureSet = getBlockProposerSignatureSet(config, index2pubkey, signedBlock);
   return verifySignatureSet(signatureSet);
 }
 
 export function getBlockProposerSignatureSet(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): ISignatureSet {
-  const {config} = state;
-  const domain = config.getDomain(state.slot, DOMAIN_BEACON_PROPOSER, signedBlock.message.slot);
+  // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
+  // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
+  const blockSlot = signedBlock.message.slot;
+  const domain = config.getDomain(blockSlot, DOMAIN_BEACON_PROPOSER, blockSlot);
 
   const blockType = isBlindedBeaconBlock(signedBlock.message)
     ? config.getPostBellatrixForkTypes(signedBlock.message.slot).BlindedBeaconBlock
@@ -35,28 +37,28 @@ export function getBlockProposerSignatureSet(
 }
 
 export function getBlockHeaderProposerSignatureSetByParentStateSlot(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  parentState: CachedBeaconStateAllForks,
+  parentStateSlot: Slot,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(index2pubkey, parentState, signedBlockHeader, parentState.slot);
+  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, parentStateSlot);
 }
 
 export function getBlockHeaderProposerSignatureSetByHeaderSlot(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  headState: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(index2pubkey, headState, signedBlockHeader, signedBlockHeader.message.slot);
+  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, signedBlockHeader.message.slot);
 }
 
 function getBlockHeaderProposerSignatureSet(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlockHeader: phase0.SignedBeaconBlockHeader,
   domainSlot: Slot
 ): ISignatureSet {
-  const {config} = state;
   const domain = config.getDomain(domainSlot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
 
   return {

package/src/signatureSets/proposerSlashings.ts

@@ -1,15 +1,16 @@
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
-import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index.js";
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
 export function getProposerSlashingSignatureSets(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing
 ): ISignatureSet[] {
   const pubkey = index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
@@ -17,11 +18,7 @@ export function getProposerSlashingSignatureSets(
   // 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
   return [proposerSlashing.signedHeader1, proposerSlashing.signedHeader2].map((signedHeader): ISignatureSet => {
-    const domain = state.config.getDomain(
-      state.slot,
-      DOMAIN_BEACON_PROPOSER,
-      Number(signedHeader.message.slot as bigint)
-    );
+    const domain = config.getDomain(stateSlot, DOMAIN_BEACON_PROPOSER, Number(signedHeader.message.slot as bigint));
 
     return {
       type: SignatureSetType.single,
@@ -33,11 +30,14 @@ export function getProposerSlashingSignatureSets(
 }
 
 export function getProposerSlashingsSignatureSets(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
+  // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
+  // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
+  const blockSlot = signedBlock.message.slot;
   return signedBlock.message.body.proposerSlashings.flatMap((proposerSlashing) =>
-    getProposerSlashingSignatureSets(index2pubkey, state, proposerSlashing)
+    getProposerSlashingSignatureSets(config, index2pubkey, blockSlot, proposerSlashing)
   );
 }

package/src/signatureSets/randao.ts

@@ -1,7 +1,7 @@
+import {BeaconConfig} from "@lodestar/config";
 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,
   SignatureSetType,
@@ -11,24 +11,26 @@ import {
 } from "../util/index.js";
 
 export function verifyRandaoSignature(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   block: BeaconBlock
 ): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(index2pubkey, state, block));
+  return verifySignatureSet(getRandaoRevealSignatureSet(config, index2pubkey, block));
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
 export function getRandaoRevealSignatureSet(
+  config: BeaconConfig,
   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);
+  // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
+  // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
+  const domain = config.getDomain(block.slot, DOMAIN_RANDAO, block.slot);
 
   return {
     type: SignatureSetType.single,

package/src/signatureSets/voluntaryExits.ts

@@ -1,6 +1,6 @@
-import {SignedBeaconBlock, phase0, ssz} from "@lodestar/types";
+import {BeaconConfig} from "@lodestar/config";
+import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {
   ISignatureSet,
   SignatureSetType,
@@ -10,23 +10,25 @@ import {
 } from "../util/index.js";
 
 export function verifyVoluntaryExitSignature(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(index2pubkey, state, signedVoluntaryExit));
+  return verifySignatureSet(getVoluntaryExitSignatureSet(config, index2pubkey, stateSlot, signedVoluntaryExit));
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
 export function getVoluntaryExitSignatureSet(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
-  const slot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
-  const domain = state.config.getDomainForVoluntaryExit(state.slot, slot);
+  const messageSlot = computeStartSlotAtEpoch(signedVoluntaryExit.message.epoch);
+  const domain = config.getDomainForVoluntaryExit(stateSlot, messageSlot);
 
   return {
     type: SignatureSetType.single,
@@ -37,11 +39,14 @@ export function getVoluntaryExitSignatureSet(
 }
 
 export function getVoluntaryExitsSignatureSets(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
+  // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
+  // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
+  const blockSlot = signedBlock.message.slot;
   return signedBlock.message.body.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(index2pubkey, state, voluntaryExit)
+    getVoluntaryExitSignatureSet(config, index2pubkey, blockSlot, 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.epochCtx.index2pubkey, postState, signedBlock)) {
+  if (verifyProposer && !verifyProposerSignature(postState.config, postState.epochCtx.index2pubkey, signedBlock)) {
     throw new Error("Invalid block signature");
   }
 

package/src/types.ts

@@ -23,4 +23,5 @@ export type {
   BeaconStateFulu,
   BeaconStateGloas,
   BeaconStatePhase0,
+  ShufflingGetter,
 } from "./cache/types.js";