@lodestar/state-transition 1.39.0-dev.84b481ddb5 → 1.39.0-dev.86298a43e6

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.39.0-dev.84b481ddb5",
+  "version": "1.39.0-dev.86298a43e6",
   "type": "module",
   "exports": {
     ".": {
@@ -62,10 +62,10 @@
     "@chainsafe/pubkey-index-map": "^3.0.0",
     "@chainsafe/ssz": "^1.2.2",
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@lodestar/config": "1.39.0-dev.84b481ddb5",
-    "@lodestar/params": "1.39.0-dev.84b481ddb5",
-    "@lodestar/types": "1.39.0-dev.84b481ddb5",
-    "@lodestar/utils": "1.39.0-dev.84b481ddb5",
+    "@lodestar/config": "1.39.0-dev.86298a43e6",
+    "@lodestar/params": "1.39.0-dev.86298a43e6",
+    "@lodestar/types": "1.39.0-dev.86298a43e6",
+    "@lodestar/utils": "1.39.0-dev.86298a43e6",
     "bigint-buffer": "^1.1.5"
   },
   "keywords": [
@@ -74,5 +74,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "599e196bc2c645e3eaf5696afc9e262f63f5736f"
+  "gitHead": "55dd258fb9d9a8eaad756c34d331ebe0ab71995f"
 }

package/src/block/isValidIndexedAttestation.ts

@@ -21,7 +21,7 @@ export function isValidIndexedAttestation(
   }
 
   if (verifySignature) {
-    return verifySignatureSet(getIndexedAttestationSignatureSet(config, index2pubkey, state, indexedAttestation));
+    return verifySignatureSet(getIndexedAttestationSignatureSet(config, index2pubkey, state.slot, indexedAttestation));
   }
   return true;
 }
@@ -38,7 +38,9 @@ export function isValidIndexedAttestationBigint(
   }
 
   if (verifySignature) {
-    return verifySignatureSet(getIndexedAttestationBigintSignatureSet(config, index2pubkey, state, indexedAttestation));
+    return verifySignatureSet(
+      getIndexedAttestationBigintSignatureSet(config, index2pubkey, state.slot, indexedAttestation)
+    );
   }
   return true;
 }

package/src/block/processAttestationsAltair.ts

@@ -67,7 +67,7 @@ export function processAttestationsAltair(
       const sigSet = getAttestationWithIndicesSignatureSet(
         state.config,
         epochCtx.index2pubkey,
-        state,
+        state.slot,
         attestation,
         attestingIndices
       );

package/src/block/processProposerSlashing.ts

@@ -80,7 +80,7 @@ export function assertValidProposerSlashing(
     const signatureSets = getProposerSlashingSignatureSets(
       state.config,
       state.epochCtx.index2pubkey,
-      state,
+      state.slot,
       proposerSlashing
     );
     for (let i = 0; i < signatureSets.length; i++) {

package/src/block/processRandao.ts

@@ -12,12 +12,12 @@ import {getRandaoMix} from "../util/index.js";
  * PERF: Fixed work independent of block contents.
  */
 export function processRandao(state: CachedBeaconStateAllForks, block: BeaconBlock, verifySignature = true): void {
-  const {epochCtx} = state;
+  const {epochCtx, config} = state;
   const epoch = epochCtx.epoch;
   const randaoReveal = block.body.randaoReveal;
 
   // verify RANDAO reveal
-  if (verifySignature && !verifyRandaoSignature(state.config, epochCtx.index2pubkey, state, block)) {
+  if (verifySignature && !verifyRandaoSignature(config, epochCtx.index2pubkey, block)) {
     throw new Error("RANDAO reveal is an invalid signature");
   }
 

package/src/block/processSyncCommittee.ts

@@ -3,6 +3,7 @@ import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {altair, ssz} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
 import {G2_POINT_AT_INFINITY} from "../constants/index.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {
@@ -28,7 +29,7 @@ export function processSyncAggregate(
     const signatureSet = getSyncCommitteeSignatureSet(
       state.config,
       state.epochCtx.index2pubkey,
-      state,
+      state.epochCtx.currentSyncCommitteeIndexed,
       block,
       participantIndices
     );
@@ -73,7 +74,7 @@ export function processSyncAggregate(
 export function getSyncCommitteeSignatureSet(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  currentSyncCommitteeIndexed: SyncCommitteeCache,
   block: altair.BeaconBlock,
   /** Optional parameter to prevent computing it twice */
   participantIndices?: number[]
@@ -101,7 +102,7 @@ export function getSyncCommitteeSignatureSet(
   const rootSigned = block.parentRoot;
 
   if (!participantIndices) {
-    const committeeIndices = state.epochCtx.currentSyncCommitteeIndexed.validatorIndices;
+    const committeeIndices = currentSyncCommitteeIndexed.validatorIndices;
     participantIndices = syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
   }
 
@@ -115,7 +116,9 @@ export function getSyncCommitteeSignatureSet(
     throw Error("Empty sync committee signature is not infinity");
   }
 
-  const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, previousSlot);
+  // 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_SYNC_COMMITTEE, previousSlot);
 
   return {
     type: SignatureSetType.aggregate,

package/src/block/processVoluntaryExit.ts

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

package/src/index.ts

@@ -27,8 +27,7 @@ export {
   createEmptyEpochCacheImmutableData,
 } from "./cache/epochCache.js";
 export {type EpochTransitionCache, beforeProcessEpoch} from "./cache/epochTransitionCache.js";
-// Aux data-structures
-export {type Index2PubkeyCache} from "./cache/pubkeyCache.js";
+export {type Index2PubkeyCache, syncPubkeys} from "./cache/pubkeyCache.js";
 // Main state caches
 export {
   type BeaconStateCache,
@@ -41,6 +40,7 @@ export {
 export * from "./constants/index.js";
 export type {EpochTransitionStep} from "./epoch/index.js";
 export {type BeaconStateTransitionMetrics, getMetrics} from "./metrics.js";
+export * from "./rewards/index.js";
 export * from "./signatureSets/index.js";
 export * from "./stateTransition.js";
 export type {

package/src/rewards/attestationsRewards.ts

@@ -0,0 +1,200 @@
+import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
+import {BeaconConfig} from "@lodestar/config";
+import {
+  EFFECTIVE_BALANCE_INCREMENT,
+  ForkName,
+  INACTIVITY_PENALTY_QUOTIENT_ALTAIR,
+  MAX_EFFECTIVE_BALANCE,
+  MAX_EFFECTIVE_BALANCE_ELECTRA,
+  PARTICIPATION_FLAG_WEIGHTS,
+  TIMELY_HEAD_FLAG_INDEX,
+  TIMELY_SOURCE_FLAG_INDEX,
+  TIMELY_TARGET_FLAG_INDEX,
+  WEIGHT_DENOMINATOR,
+  isForkPostElectra,
+} from "@lodestar/params";
+import {ValidatorIndex, rewards} from "@lodestar/types";
+import {fromHex} from "@lodestar/utils";
+import {EpochTransitionCache, beforeProcessEpoch} from "../cache/epochTransitionCache.js";
+import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
+import {
+  FLAG_ELIGIBLE_ATTESTER,
+  FLAG_PREV_HEAD_ATTESTER_UNSLASHED,
+  FLAG_PREV_SOURCE_ATTESTER_UNSLASHED,
+  FLAG_PREV_TARGET_ATTESTER_UNSLASHED,
+  hasMarkers,
+  isInInactivityLeak,
+} from "../util/index.js";
+
+/** Attestations penalty with respect to effective balance in Gwei */
+type AttestationsPenalty = {target: number; source: number; effectiveBalance: number};
+
+const defaultAttestationsReward = {head: 0, target: 0, source: 0, inclusionDelay: 0, inactivity: 0};
+const defaultAttestationsPenalty = {target: 0, source: 0};
+
+export async function computeAttestationsRewards(
+  config: BeaconConfig,
+  pubkey2index: PubkeyIndexMap,
+  state: CachedBeaconStateAllForks,
+  validatorIds?: (ValidatorIndex | string)[]
+): Promise<rewards.AttestationsRewards> {
+  const fork = config.getForkName(state.slot);
+  if (fork === ForkName.phase0) {
+    throw Error("Unsupported fork. Attestations rewards calculation is not available in phase0");
+  }
+
+  const stateAltair = state as CachedBeaconStateAltair;
+  const transitionCache = beforeProcessEpoch(stateAltair);
+
+  const [idealRewards, penalties] = computeIdealAttestationsRewardsAndPenaltiesAltair(
+    config,
+    stateAltair,
+    transitionCache
+  );
+  const totalRewards = computeTotalAttestationsRewardsAltair(
+    config,
+    pubkey2index,
+    stateAltair,
+    transitionCache,
+    idealRewards,
+    penalties,
+    validatorIds
+  );
+
+  return {idealRewards, totalRewards};
+}
+
+function computeIdealAttestationsRewardsAndPenaltiesAltair(
+  config: BeaconConfig,
+  state: CachedBeaconStateAllForks,
+  transitionCache: EpochTransitionCache
+): [rewards.IdealAttestationsReward[], AttestationsPenalty[]] {
+  const baseRewardPerIncrement = transitionCache.baseRewardPerIncrement;
+  const activeBalanceByIncrement = transitionCache.totalActiveStakeByIncrement;
+  const fork = config.getForkName(state.slot);
+  const maxEffectiveBalance = isForkPostElectra(fork) ? MAX_EFFECTIVE_BALANCE_ELECTRA : MAX_EFFECTIVE_BALANCE;
+  const maxEffectiveBalanceByIncrement = Math.floor(maxEffectiveBalance / EFFECTIVE_BALANCE_INCREMENT);
+
+  const idealRewards = Array.from({length: maxEffectiveBalanceByIncrement + 1}, (_, effectiveBalanceByIncrement) => ({
+    ...defaultAttestationsReward,
+    effectiveBalance: effectiveBalanceByIncrement * EFFECTIVE_BALANCE_INCREMENT,
+  }));
+
+  const attestationsPenalties: AttestationsPenalty[] = Array.from(
+    {length: maxEffectiveBalanceByIncrement + 1},
+    (_, effectiveBalanceByIncrement) => ({
+      ...defaultAttestationsPenalty,
+      effectiveBalance: effectiveBalanceByIncrement * EFFECTIVE_BALANCE_INCREMENT,
+    })
+  );
+
+  for (let i = 0; i < PARTICIPATION_FLAG_WEIGHTS.length; i++) {
+    const weight = PARTICIPATION_FLAG_WEIGHTS[i];
+
+    let unslashedStakeByIncrement: number;
+    let flagName: keyof rewards.IdealAttestationsReward;
+
+    switch (i) {
+      case TIMELY_SOURCE_FLAG_INDEX: {
+        unslashedStakeByIncrement = transitionCache.prevEpochUnslashedStake.sourceStakeByIncrement;
+        flagName = "source";
+        break;
+      }
+      case TIMELY_TARGET_FLAG_INDEX: {
+        unslashedStakeByIncrement = transitionCache.prevEpochUnslashedStake.targetStakeByIncrement;
+        flagName = "target";
+        break;
+      }
+      case TIMELY_HEAD_FLAG_INDEX: {
+        unslashedStakeByIncrement = transitionCache.prevEpochUnslashedStake.headStakeByIncrement;
+        flagName = "head";
+        break;
+      }
+      default: {
+        throw Error(`Unable to retrieve unslashed stake. Unknown participation flag index: ${i}`);
+      }
+    }
+
+    for (
+      let effectiveBalanceByIncrement = 0;
+      effectiveBalanceByIncrement <= maxEffectiveBalanceByIncrement;
+      effectiveBalanceByIncrement++
+    ) {
+      const baseReward = effectiveBalanceByIncrement * baseRewardPerIncrement;
+      const rewardNumerator = baseReward * weight * unslashedStakeByIncrement;
+      // Both idealReward and penalty are rounded to nearest integer. Loss of precision is minimal as unit is gwei
+      const idealReward = Math.round(rewardNumerator / activeBalanceByIncrement / WEIGHT_DENOMINATOR);
+      const penalty = Math.round((baseReward * weight) / WEIGHT_DENOMINATOR); // Positive number indicates penalty
+
+      const idealAttestationsReward = idealRewards[effectiveBalanceByIncrement];
+      idealAttestationsReward[flagName] = isInInactivityLeak(state) ? 0 : idealReward; // No attestations rewards during inactivity leak
+
+      if (flagName !== "head") {
+        const attestationPenalty = attestationsPenalties[effectiveBalanceByIncrement];
+        attestationPenalty[flagName] = penalty;
+      }
+    }
+  }
+
+  return [idealRewards, attestationsPenalties];
+}
+
+// Same calculation as `getRewardsAndPenaltiesAltair` but returns the breakdown of rewards instead of aggregated
+function computeTotalAttestationsRewardsAltair(
+  config: BeaconConfig,
+  pubkey2index: PubkeyIndexMap,
+  state: CachedBeaconStateAltair,
+  transitionCache: EpochTransitionCache,
+  idealRewards: rewards.IdealAttestationsReward[],
+  penalties: AttestationsPenalty[],
+  validatorIds: (ValidatorIndex | string)[] = []
+): rewards.TotalAttestationsReward[] {
+  const rewards = [];
+  const {flags} = transitionCache;
+  const {epochCtx} = state;
+  const validatorIndices = validatorIds
+    .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;
+
+  for (let i = 0; i < flags.length; i++) {
+    if (validatorIndices.length && !validatorIndices.includes(i)) {
+      continue;
+    }
+
+    const flag = flags[i];
+    if (!hasMarkers(flag, FLAG_ELIGIBLE_ATTESTER)) {
+      continue;
+    }
+
+    const effectiveBalanceIncrement = epochCtx.effectiveBalanceIncrements[i];
+
+    const currentRewards = {...defaultAttestationsReward, validatorIndex: i};
+
+    if (hasMarkers(flag, FLAG_PREV_SOURCE_ATTESTER_UNSLASHED)) {
+      currentRewards.source = idealRewards[effectiveBalanceIncrement].source;
+    } else {
+      currentRewards.source = penalties[effectiveBalanceIncrement].source * -1; // Negative reward to indicate penalty
+    }
+
+    if (hasMarkers(flag, FLAG_PREV_TARGET_ATTESTER_UNSLASHED)) {
+      currentRewards.target = idealRewards[effectiveBalanceIncrement].target;
+    } else {
+      currentRewards.target = penalties[effectiveBalanceIncrement].target * -1;
+
+      // Also incur inactivity penalty if not voting target correctly
+      const inactivityPenaltyNumerator =
+        effectiveBalanceIncrement * EFFECTIVE_BALANCE_INCREMENT * state.inactivityScores.get(i);
+      currentRewards.inactivity = Math.floor(inactivityPenaltyNumerator / inactivityPenaltyDenominator) * -1;
+    }
+
+    if (hasMarkers(flag, FLAG_PREV_HEAD_ATTESTER_UNSLASHED)) {
+      currentRewards.head = idealRewards[effectiveBalanceIncrement].head;
+    }
+
+    rewards.push(currentRewards);
+  }
+
+  return rewards;
+}

package/src/rewards/blockRewards.ts

@@ -0,0 +1,147 @@
+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 {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,
+  preState: CachedBeaconStateAllForks,
+  postState?: CachedBeaconStateAllForks
+): Promise<rewards.BlockRewards> {
+  const fork = config.getForkName(block.slot);
+  const {attestations: cachedAttestationsReward = 0, syncAggregate: cachedSyncAggregateReward = 0} =
+    postState?.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,59 @@
+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";
+
+type BalanceRecord = {val: number}; // Use val for convenient way to increment/decrement balance
+
+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 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;
+
+  // Use balance of each committee as starting point such that we cap the penalty to avoid balance dropping below 0
+  const balances: Map<ValidatorIndex, BalanceRecord> = new Map();
+  for (const i of syncCommitteeValidatorIndices) {
+    balances.set(i, {val: preStateAltair.balances.get(i)});
+  }
+
+  for (const i of syncCommitteeValidatorIndices) {
+    const balanceRecord = balances.get(i) as BalanceRecord;
+    if (syncCommitteeBits.get(i)) {
+      // Positive rewards for participants
+      balanceRecord.val += syncParticipantReward;
+    } else {
+      // Negative rewards for non participants
+      balanceRecord.val = Math.max(0, balanceRecord.val - syncParticipantReward);
+    }
+  }
+
+  const rewards = Array.from(balances, ([validatorIndex, v]) => ({validatorIndex, reward: v.val}));
+
+  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,19 +1,20 @@
 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(config, index2pubkey, state, attesterSlashing)
+    getAttesterSlashingSignatureSets(config, index2pubkey, blockSlot, attesterSlashing)
   );
 }
 
@@ -21,22 +22,22 @@ export function getAttesterSlashingsSignatureSets(
 export function getAttesterSlashingSignatureSets(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
   attesterSlashing: AttesterSlashing
 ): ISignatureSet[] {
   return [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
-    getIndexedAttestationBigintSignatureSet(config, 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 = 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,