@lodestar/state-transition 1.39.0-dev.b6bba4cb8c → 1.39.0-dev.b6d377a93c

package/src/block/processWithdrawals.ts

@@ -9,7 +9,7 @@ import {
   MIN_ACTIVATION_BALANCE,
 } from "@lodestar/params";
 import {ValidatorIndex, capella, ssz} from "@lodestar/types";
-import {MapDef, toRootHex} from "@lodestar/utils";
+import {toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateCapella, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {isBuilderPaymentWithdrawable, isParentBlockFull} from "../util/gloas.ts";
 import {
@@ -30,13 +30,11 @@ export function processWithdrawals(
     return;
   }
 
-  // processedPartialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
   // processedBuilderWithdrawalsCount is withdrawals coming from builder payment since gloas (EIP-7732)
-  const {
-    withdrawals: expectedWithdrawals,
-    processedPartialWithdrawalsCount,
-    processedBuilderWithdrawalsCount,
-  } = getExpectedWithdrawals(fork, state);
+  // processedPartialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
+  // processedValidatorSweepCount is withdrawals coming from validator sweep
+  const {expectedWithdrawals, processedBuilderWithdrawalsCount, processedPartialWithdrawalsCount} =
+    getExpectedWithdrawals(fork, state);
   const numWithdrawals = expectedWithdrawals.length;
 
   // After gloas, withdrawals are verified later in processExecutionPayloadEnvelope
@@ -68,12 +66,10 @@ export function processWithdrawals(
     }
   }
 
-  for (let i = 0; i < numWithdrawals; i++) {
-    const withdrawal = expectedWithdrawals[i];
-    decreaseBalance(state, withdrawal.validatorIndex, Number(withdrawal.amount));
-  }
+  applyWithdrawals(state, expectedWithdrawals);
 
   if (fork >= ForkSeq.electra) {
+    // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.0/specs/electra/beacon-chain.md#new-update_pending_partial_withdrawals
     const stateElectra = state as CachedBeaconStateElectra;
     stateElectra.pendingPartialWithdrawals = stateElectra.pendingPartialWithdrawals.sliceFrom(
       processedPartialWithdrawalsCount
@@ -97,13 +93,14 @@ export function processWithdrawals(
       ...remainingWithdrawals,
     ]);
   }
-
   // Update the nextWithdrawalIndex
+  // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.0/specs/capella/beacon-chain.md#new-update_next_withdrawal_index
   const latestWithdrawal = expectedWithdrawals.at(-1);
   if (latestWithdrawal) {
     state.nextWithdrawalIndex = latestWithdrawal.index + 1;
   }
 
+  // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.0/specs/capella/beacon-chain.md#new-update_next_withdrawal_validator_index
   // Update the nextWithdrawalValidatorIndex
   if (latestWithdrawal && expectedWithdrawals.length === MAX_WITHDRAWALS_PER_PAYLOAD) {
     // All slots filled, nextWithdrawalValidatorIndex should be validatorIndex having next turn
@@ -116,142 +113,163 @@ export function processWithdrawals(
   }
 }
 
-export function getExpectedWithdrawals(
-  fork: ForkSeq,
-  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas
-): {
-  withdrawals: capella.Withdrawal[];
-  sampledValidators: number;
-  processedPartialWithdrawalsCount: number;
-  processedBuilderWithdrawalsCount: number;
-} {
-  if (fork < ForkSeq.capella) {
-    throw new Error(`getExpectedWithdrawals not supported at forkSeq=${fork} < ForkSeq.capella`);
-  }
-
+function getBuilderWithdrawals(
+  state: CachedBeaconStateGloas,
+  withdrawalIndex: number,
+  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+): {builderWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
+  const builderWithdrawals: capella.Withdrawal[] = [];
   const epoch = state.epochCtx.epoch;
-  let withdrawalIndex = state.nextWithdrawalIndex;
-  const {validators, balances, nextWithdrawalValidatorIndex} = state;
-
-  const withdrawals: capella.Withdrawal[] = [];
-  const withdrawnBalances = new MapDef<ValidatorIndex, number>(() => 0);
-  const isPostElectra = fork >= ForkSeq.electra;
-  const isPostGloas = fork >= ForkSeq.gloas;
-  // partialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
-  let processedPartialWithdrawalsCount = 0;
-  // builderWithdrawalsCount is withdrawals coming from builder payments since Gloas (EIP-7732)
-  let processedBuilderWithdrawalsCount = 0;
-
-  if (isPostGloas) {
-    const stateGloas = state as CachedBeaconStateGloas;
-
-    const allBuilderPendingWithdrawals =
-      stateGloas.builderPendingWithdrawals.length <= MAX_WITHDRAWALS_PER_PAYLOAD
-        ? stateGloas.builderPendingWithdrawals.getAllReadonly()
-        : null;
+  const allBuilderPendingWithdrawals =
+    state.builderPendingWithdrawals.length <= MAX_WITHDRAWALS_PER_PAYLOAD
+      ? state.builderPendingWithdrawals.getAllReadonly()
+      : null;
+
+  let processedCount = 0;
+  for (let i = 0; i < state.builderPendingWithdrawals.length; i++) {
+    const withdrawal = allBuilderPendingWithdrawals
+      ? allBuilderPendingWithdrawals[i]
+      : state.builderPendingWithdrawals.getReadonly(i);
+
+    if (withdrawal.withdrawableEpoch > epoch || builderWithdrawals.length === MAX_WITHDRAWALS_PER_PAYLOAD) {
+      break;
+    }
 
-    for (let i = 0; i < stateGloas.builderPendingWithdrawals.length; i++) {
-      const withdrawal = allBuilderPendingWithdrawals
-        ? allBuilderPendingWithdrawals[i]
-        : stateGloas.builderPendingWithdrawals.getReadonly(i);
+    if (isBuilderPaymentWithdrawable(state, withdrawal)) {
+      const builderIndex = withdrawal.builderIndex;
+      const builder = state.validators.get(withdrawal.builderIndex);
 
-      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length + 1 === MAX_WITHDRAWALS_PER_PAYLOAD) {
-        break;
+      let balance = balanceAfterWithdrawals.get(builderIndex);
+      if (balance === undefined) {
+        balance = state.balances.get(builderIndex);
+        balanceAfterWithdrawals.set(builderIndex, balance);
       }
 
-      if (isBuilderPaymentWithdrawable(stateGloas, withdrawal)) {
-        const totalWithdrawn = withdrawnBalances.getOrDefault(withdrawal.builderIndex);
-        const balance = state.balances.get(withdrawal.builderIndex) - totalWithdrawn;
-        const builder = state.validators.get(withdrawal.builderIndex);
-
-        let withdrawableBalance = 0;
+      let withdrawableBalance = 0;
 
-        if (builder.slashed) {
-          withdrawableBalance = balance < withdrawal.amount ? balance : withdrawal.amount;
-        } else if (balance > MIN_ACTIVATION_BALANCE) {
-          withdrawableBalance =
-            balance - MIN_ACTIVATION_BALANCE < withdrawal.amount ? balance - MIN_ACTIVATION_BALANCE : withdrawal.amount;
-        }
+      if (builder.slashed) {
+        withdrawableBalance = balance < withdrawal.amount ? balance : withdrawal.amount;
+      } else if (balance > MIN_ACTIVATION_BALANCE) {
+        withdrawableBalance =
+          balance - MIN_ACTIVATION_BALANCE < withdrawal.amount ? balance - MIN_ACTIVATION_BALANCE : withdrawal.amount;
+      }
 
-        if (withdrawableBalance > 0) {
-          withdrawals.push({
-            index: withdrawalIndex,
-            validatorIndex: withdrawal.builderIndex,
-            address: withdrawal.feeRecipient,
-            amount: BigInt(withdrawableBalance),
-          });
-          withdrawalIndex++;
-          withdrawnBalances.set(withdrawal.builderIndex, totalWithdrawn + withdrawableBalance);
-        }
+      if (withdrawableBalance > 0) {
+        builderWithdrawals.push({
+          index: withdrawalIndex,
+          validatorIndex: withdrawal.builderIndex,
+          address: withdrawal.feeRecipient,
+          amount: BigInt(withdrawableBalance),
+        });
+        withdrawalIndex++;
+        balanceAfterWithdrawals.set(builderIndex, balance - withdrawableBalance);
       }
-      processedBuilderWithdrawalsCount++;
     }
+    processedCount++;
   }
 
-  if (isPostElectra) {
-    // In pre-gloas, partialWithdrawalBound == MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP
-    const partialWithdrawalBound = Math.min(
-      withdrawals.length + MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
-      MAX_WITHDRAWALS_PER_PAYLOAD - 1
-    );
-    const stateElectra = state as CachedBeaconStateElectra;
+  return {builderWithdrawals, withdrawalIndex, processedCount};
+}
 
-    // MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP = 8, PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728 so we should only call getAllReadonly() if it makes sense
-    // pendingPartialWithdrawals comes from EIP-7002 smart contract where it takes fee so it's more likely than not validator is in correct condition to withdraw
-    // also we may break early if withdrawableEpoch > epoch
-    const allPendingPartialWithdrawals =
-      stateElectra.pendingPartialWithdrawals.length <= partialWithdrawalBound
-        ? stateElectra.pendingPartialWithdrawals.getAllReadonly()
-        : null;
-
-    // EIP-7002: Execution layer triggerable withdrawals
-    for (let i = 0; i < stateElectra.pendingPartialWithdrawals.length; i++) {
-      const withdrawal = allPendingPartialWithdrawals
-        ? allPendingPartialWithdrawals[i]
-        : stateElectra.pendingPartialWithdrawals.getReadonly(i);
-      if (withdrawal.withdrawableEpoch > epoch || withdrawals.length === partialWithdrawalBound) {
-        break;
-      }
+function getPendingPartialWithdrawals(
+  state: CachedBeaconStateElectra,
+  withdrawalIndex: number,
+  numPriorWithdrawal: number,
+  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+): {pendingPartialWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
+  const epoch = state.epochCtx.epoch;
+  const pendingPartialWithdrawals: capella.Withdrawal[] = [];
+  const validators = state.validators;
+
+  // In pre-gloas, partialWithdrawalBound == MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP
+  const partialWithdrawalBound = Math.min(
+    numPriorWithdrawal + MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
+    MAX_WITHDRAWALS_PER_PAYLOAD - 1
+  );
+
+  // MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP = 8, PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728 so we should only call getAllReadonly() if it makes sense
+  // pendingPartialWithdrawals comes from EIP-7002 smart contract where it takes fee so it's more likely than not validator is in correct condition to withdraw
+  // also we may break early if withdrawableEpoch > epoch
+  const allPendingPartialWithdrawals =
+    state.pendingPartialWithdrawals.length <= partialWithdrawalBound
+      ? state.pendingPartialWithdrawals.getAllReadonly()
+      : null;
+
+  // EIP-7002: Execution layer triggerable withdrawals
+  let processedCount = 0;
+  for (let i = 0; i < state.pendingPartialWithdrawals.length; i++) {
+    const withdrawal = allPendingPartialWithdrawals
+      ? allPendingPartialWithdrawals[i]
+      : state.pendingPartialWithdrawals.getReadonly(i);
+    if (
+      withdrawal.withdrawableEpoch > epoch ||
+      pendingPartialWithdrawals.length + numPriorWithdrawal === partialWithdrawalBound
+    ) {
+      break;
+    }
 
-      const validator = validators.getReadonly(withdrawal.validatorIndex);
-      const totalWithdrawn = withdrawnBalances.getOrDefault(withdrawal.validatorIndex);
-      const balance = state.balances.get(withdrawal.validatorIndex) - totalWithdrawn;
-
-      if (
-        validator.exitEpoch === FAR_FUTURE_EPOCH &&
-        validator.effectiveBalance >= MIN_ACTIVATION_BALANCE &&
-        balance > MIN_ACTIVATION_BALANCE
-      ) {
-        const balanceOverMinActivationBalance = BigInt(balance - MIN_ACTIVATION_BALANCE);
-        const withdrawableBalance =
-          balanceOverMinActivationBalance < withdrawal.amount ? balanceOverMinActivationBalance : withdrawal.amount;
-        withdrawals.push({
-          index: withdrawalIndex,
-          validatorIndex: withdrawal.validatorIndex,
-          address: validator.withdrawalCredentials.subarray(12),
-          amount: withdrawableBalance,
-        });
-        withdrawalIndex++;
-        withdrawnBalances.set(withdrawal.validatorIndex, totalWithdrawn + Number(withdrawableBalance));
-      }
-      processedPartialWithdrawalsCount++;
+    const validatorIndex = withdrawal.validatorIndex;
+    const validator = validators.getReadonly(validatorIndex);
+    let balance = balanceAfterWithdrawals.get(validatorIndex);
+    if (balance === undefined) {
+      balance = state.balances.get(validatorIndex);
+      balanceAfterWithdrawals.set(validatorIndex, balance);
     }
+
+    if (
+      validator.exitEpoch === FAR_FUTURE_EPOCH &&
+      validator.effectiveBalance >= MIN_ACTIVATION_BALANCE &&
+      balance > MIN_ACTIVATION_BALANCE
+    ) {
+      const balanceOverMinActivationBalance = BigInt(balance - MIN_ACTIVATION_BALANCE);
+      const withdrawableBalance =
+        balanceOverMinActivationBalance < withdrawal.amount ? balanceOverMinActivationBalance : withdrawal.amount;
+      pendingPartialWithdrawals.push({
+        index: withdrawalIndex,
+        validatorIndex,
+        address: validator.withdrawalCredentials.subarray(12),
+        amount: withdrawableBalance,
+      });
+      withdrawalIndex++;
+      balanceAfterWithdrawals.set(validatorIndex, balance - Number(withdrawableBalance));
+    }
+    processedCount++;
   }
 
-  const withdrawalBound = Math.min(validators.length, MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP);
-  let n = 0;
+  return {pendingPartialWithdrawals, withdrawalIndex, processedCount};
+}
+
+function getValidatorsSweepWithdrawals(
+  fork: ForkSeq,
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas,
+  withdrawalIndex: number,
+  numPriorWithdrawal: number,
+  balanceAfterWithdrawals: Map<ValidatorIndex, number>
+): {sweepWithdrawals: capella.Withdrawal[]; processedCount: number} {
+  const sweepWithdrawals: capella.Withdrawal[] = [];
+  const epoch = state.epochCtx.epoch;
+  const {validators, balances, nextWithdrawalValidatorIndex} = state;
+  const isPostElectra = fork >= ForkSeq.electra;
+
+  const validatorsLimit = Math.min(state.validators.length, MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP);
+  let processedCount = 0;
   // Just run a bounded loop max iterating over all withdrawals
   // however breaks out once we have MAX_WITHDRAWALS_PER_PAYLOAD
-  for (n = 0; n < withdrawalBound; n++) {
+  for (let n = 0; n < validatorsLimit; n++) {
+    if (sweepWithdrawals.length + numPriorWithdrawal === MAX_WITHDRAWALS_PER_PAYLOAD) {
+      break;
+    }
+
     // Get next validator in turn
     const validatorIndex = (nextWithdrawalValidatorIndex + n) % validators.length;
 
     const validator = validators.getReadonly(validatorIndex);
-    const withdrawnBalance = withdrawnBalances.getOrDefault(validatorIndex);
-    const balance = isPostElectra
-      ? // Deduct partially withdrawn balance already queued above
-        balances.get(validatorIndex) - withdrawnBalance
-      : balances.get(validatorIndex);
+    let balance = balanceAfterWithdrawals.get(validatorIndex);
+    if (balance === undefined) {
+      balance = balances.get(validatorIndex);
+      balanceAfterWithdrawals.set(validatorIndex, balance);
+    }
+
     const {withdrawableEpoch, withdrawalCredentials, effectiveBalance} = validator;
     const hasWithdrawableCredentials = isPostElectra
       ? hasExecutionWithdrawalCredential(withdrawalCredentials)
@@ -259,40 +277,117 @@ export function getExpectedWithdrawals(
     // early skip for balance = 0 as its now more likely that validator has exited/slashed with
     // balance zero than not have withdrawal credentials set
     if (balance === 0 || !hasWithdrawableCredentials) {
+      processedCount++;
       continue;
     }
 
     // capella full withdrawal
     if (withdrawableEpoch <= epoch) {
-      withdrawals.push({
+      sweepWithdrawals.push({
         index: withdrawalIndex,
         validatorIndex,
         address: validator.withdrawalCredentials.subarray(12),
         amount: BigInt(balance),
       });
       withdrawalIndex++;
-      withdrawnBalances.set(validatorIndex, withdrawnBalance + balance);
+      balanceAfterWithdrawals.set(validatorIndex, 0);
     } else if (
       effectiveBalance === (isPostElectra ? getMaxEffectiveBalance(withdrawalCredentials) : MAX_EFFECTIVE_BALANCE) &&
       balance > effectiveBalance
     ) {
       // capella partial withdrawal
       const partialAmount = balance - effectiveBalance;
-      withdrawals.push({
+      sweepWithdrawals.push({
         index: withdrawalIndex,
         validatorIndex,
         address: validator.withdrawalCredentials.subarray(12),
         amount: BigInt(partialAmount),
       });
       withdrawalIndex++;
-      withdrawnBalances.set(validatorIndex, withdrawnBalance + partialAmount);
+      balanceAfterWithdrawals.set(validatorIndex, balance - partialAmount);
     }
+    processedCount++;
+  }
 
-    // Break if we have enough to pack the block
-    if (withdrawals.length >= MAX_WITHDRAWALS_PER_PAYLOAD) {
-      break;
-    }
+  return {sweepWithdrawals, processedCount};
+}
+
+function applyWithdrawals(
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas,
+  withdrawals: capella.Withdrawal[]
+): void {
+  for (const withdrawal of withdrawals) {
+    decreaseBalance(state, withdrawal.validatorIndex, Number(withdrawal.amount));
   }
+}
 
-  return {withdrawals, sampledValidators: n, processedPartialWithdrawalsCount, processedBuilderWithdrawalsCount};
+export function getExpectedWithdrawals(
+  fork: ForkSeq,
+  state: CachedBeaconStateCapella | CachedBeaconStateElectra | CachedBeaconStateGloas
+): {
+  expectedWithdrawals: capella.Withdrawal[];
+  processedBuilderWithdrawalsCount: number;
+  processedPartialWithdrawalsCount: number;
+  processedValidatorSweepCount: number;
+} {
+  if (fork < ForkSeq.capella) {
+    throw new Error(`getExpectedWithdrawals not supported at forkSeq=${fork} < ForkSeq.capella`);
+  }
+
+  let withdrawalIndex = state.nextWithdrawalIndex;
+
+  const expectedWithdrawals: capella.Withdrawal[] = [];
+  // Map to track balances after applying withdrawals
+  // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.0/specs/capella/beacon-chain.md#new-get_balance_after_withdrawals
+  const balanceAfterWithdrawals = new Map<ValidatorIndex, number>();
+  // partialWithdrawalsCount is withdrawals coming from EL since electra (EIP-7002)
+  let processedPartialWithdrawalsCount = 0;
+  // builderWithdrawalsCount is withdrawals coming from builder payments since Gloas (EIP-7732)
+  let processedBuilderWithdrawalsCount = 0;
+
+  if (fork >= ForkSeq.gloas) {
+    const {
+      builderWithdrawals,
+      withdrawalIndex: newWithdrawalIndex,
+      processedCount,
+    } = getBuilderWithdrawals(state as CachedBeaconStateGloas, withdrawalIndex, balanceAfterWithdrawals);
+
+    expectedWithdrawals.push(...builderWithdrawals);
+    withdrawalIndex = newWithdrawalIndex;
+    processedBuilderWithdrawalsCount = processedCount;
+  }
+
+  if (fork >= ForkSeq.electra) {
+    const {
+      pendingPartialWithdrawals,
+      withdrawalIndex: newWithdrawalIndex,
+      processedCount,
+    } = getPendingPartialWithdrawals(
+      state as CachedBeaconStateElectra,
+      withdrawalIndex,
+      expectedWithdrawals.length,
+      balanceAfterWithdrawals
+    );
+
+    expectedWithdrawals.push(...pendingPartialWithdrawals);
+    withdrawalIndex = newWithdrawalIndex;
+    processedPartialWithdrawalsCount = processedCount;
+  }
+
+  const {sweepWithdrawals, processedCount: processedValidatorSweepCount} = getValidatorsSweepWithdrawals(
+    fork,
+    state,
+    withdrawalIndex,
+    expectedWithdrawals.length,
+    balanceAfterWithdrawals
+  );
+
+  expectedWithdrawals.push(...sweepWithdrawals);
+
+  return {
+    expectedWithdrawals,
+    processedBuilderWithdrawalsCount,
+    processedPartialWithdrawalsCount,
+    processedValidatorSweepCount,
+  };
 }

package/src/index.ts

@@ -40,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;
+}