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

package/src/cache/epochCache.ts

@@ -32,7 +32,7 @@ import {getTotalSlashingsByIncrement} from "../epoch/processSlashings.js";
 import {AttesterDuty, calculateCommitteeAssignments} from "../util/calculateCommitteeAssignments.js";
 import {
   EpochShuffling,
-  IShufflingCache,
+  calculateDecisionRoot,
   calculateShufflingDecisionRoot,
   computeEpochShuffling,
 } from "../util/epochShuffling.js";
@@ -61,7 +61,7 @@ import {
   computeSyncCommitteeCache,
   getSyncCommitteeCache,
 } from "./syncCommitteeCache.js";
-import {BeaconStateAllForks, BeaconStateAltair, BeaconStateGloas} from "./types.js";
+import {BeaconStateAllForks, BeaconStateAltair, BeaconStateGloas, ShufflingGetter} from "./types.js";
 
 /** `= PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT)` */
 export const PROPOSER_WEIGHT_FACTOR = PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT);
@@ -70,12 +70,12 @@ export type EpochCacheImmutableData = {
   config: BeaconConfig;
   pubkey2index: PubkeyIndexMap;
   index2pubkey: Index2PubkeyCache;
-  shufflingCache?: IShufflingCache;
 };
 
 export type EpochCacheOpts = {
   skipSyncCommitteeCache?: boolean;
   skipSyncPubkeys?: boolean;
+  shufflingGetter?: ShufflingGetter;
 };
 
 /** Defers computing proposers by persisting only the seed, and dropping it once indexes are computed */
@@ -117,12 +117,6 @@ export class EpochCache {
    * $VALIDATOR_COUNT x BLST deserialized pubkey (Jacobian coordinates)
    */
   index2pubkey: Index2PubkeyCache;
-  /**
-   * ShufflingCache is passed in from `beacon-node` so should be available at runtime but may not be
-   * present during testing.
-   */
-  shufflingCache?: IShufflingCache;
-
   /**
    * Indexes of the block proposers for the current epoch.
    * For pre-fulu, this is computed and cached from the current shuffling.
@@ -161,7 +155,7 @@ export class EpochCache {
   /** Same as previousShuffling */
   currentShuffling: EpochShuffling;
   /** Same as previousShuffling */
-  nextShuffling: EpochShuffling | null;
+  nextShuffling: EpochShuffling;
   /**
    * Cache nextActiveIndices so that in afterProcessEpoch the next shuffling can be build synchronously
    * in case it is not built or the ShufflingCache is not available
@@ -254,7 +248,6 @@ export class EpochCache {
     config: BeaconConfig;
     pubkey2index: PubkeyIndexMap;
     index2pubkey: Index2PubkeyCache;
-    shufflingCache?: IShufflingCache;
     proposers: number[];
     proposersPrevEpoch: number[] | null;
     proposersNextEpoch: ProposersDeferred;
@@ -263,7 +256,7 @@ export class EpochCache {
     nextDecisionRoot: RootHex;
     previousShuffling: EpochShuffling;
     currentShuffling: EpochShuffling;
-    nextShuffling: EpochShuffling | null;
+    nextShuffling: EpochShuffling;
     nextActiveIndices: Uint32Array;
     effectiveBalanceIncrements: EffectiveBalanceIncrements;
     totalSlashingsByIncrement: number;
@@ -286,7 +279,6 @@ export class EpochCache {
     this.config = data.config;
     this.pubkey2index = data.pubkey2index;
     this.index2pubkey = data.index2pubkey;
-    this.shufflingCache = data.shufflingCache;
     this.proposers = data.proposers;
     this.proposersPrevEpoch = data.proposersPrevEpoch;
     this.proposersNextEpoch = data.proposersNextEpoch;
@@ -324,7 +316,7 @@ export class EpochCache {
    */
   static createFromState(
     state: BeaconStateAllForks,
-    {config, pubkey2index, index2pubkey, shufflingCache}: EpochCacheImmutableData,
+    {config, pubkey2index, index2pubkey}: EpochCacheImmutableData,
     opts?: EpochCacheOpts
   ): EpochCache {
     const currentEpoch = computeEpochAtSlot(state.slot);
@@ -351,14 +343,15 @@ export class EpochCache {
     const currentActiveIndicesAsNumberArray: ValidatorIndex[] = [];
     const nextActiveIndicesAsNumberArray: ValidatorIndex[] = [];
 
-    // BeaconChain could provide a shuffling cache to avoid re-computing shuffling every epoch
+    // BeaconChain could provide a shuffling getter to avoid re-computing shuffling every epoch
     // in that case, we don't need to compute shufflings again
+    const shufflingGetter = opts?.shufflingGetter;
     const previousDecisionRoot = calculateShufflingDecisionRoot(config, state, previousEpoch);
-    const cachedPreviousShuffling = shufflingCache?.getSync(previousEpoch, previousDecisionRoot);
+    const cachedPreviousShuffling = shufflingGetter?.(previousEpoch, previousDecisionRoot);
     const currentDecisionRoot = calculateShufflingDecisionRoot(config, state, currentEpoch);
-    const cachedCurrentShuffling = shufflingCache?.getSync(currentEpoch, currentDecisionRoot);
+    const cachedCurrentShuffling = shufflingGetter?.(currentEpoch, currentDecisionRoot);
     const nextDecisionRoot = calculateShufflingDecisionRoot(config, state, nextEpoch);
-    const cachedNextShuffling = shufflingCache?.getSync(nextEpoch, nextDecisionRoot);
+    const cachedNextShuffling = shufflingGetter?.(nextEpoch, nextDecisionRoot);
 
     for (let i = 0; i < validatorCount; i++) {
       const validator = validators[i];
@@ -366,8 +359,7 @@ export class EpochCache {
       // Note: Not usable for fork-choice balances since in-active validators are not zero'ed
       effectiveBalanceIncrements[i] = Math.floor(validator.effectiveBalance / EFFECTIVE_BALANCE_INCREMENT);
 
-      // we only need to track active indices for previous, current and next epoch if we have to compute shufflings
-      // skip doing that if we already have cached shufflings
+      // Collect active indices for each epoch to compute shufflings
       if (cachedPreviousShuffling == null && isActiveValidator(validator, previousEpoch)) {
         previousActiveIndicesAsNumberArray.push(i);
       }
@@ -402,47 +394,19 @@ export class EpochCache {
     }
 
     const nextActiveIndices = new Uint32Array(nextActiveIndicesAsNumberArray);
-    let previousShuffling: EpochShuffling;
-    let currentShuffling: EpochShuffling;
-    let nextShuffling: EpochShuffling;
-
-    if (!shufflingCache) {
-      // Only for testing. shufflingCache should always be available in prod
-      previousShuffling = computeEpochShuffling(
-        state,
-        new Uint32Array(previousActiveIndicesAsNumberArray),
-        previousEpoch
-      );
 
-      currentShuffling = isGenesis
-        ? previousShuffling
-        : computeEpochShuffling(state, new Uint32Array(currentActiveIndicesAsNumberArray), currentEpoch);
+    // Use cached shufflings if available, otherwise compute
+    const currentShuffling =
+      cachedCurrentShuffling ??
+      computeEpochShuffling(state, new Uint32Array(currentActiveIndicesAsNumberArray), currentEpoch);
 
-      nextShuffling = computeEpochShuffling(state, nextActiveIndices, nextEpoch);
-    } else {
-      currentShuffling = cachedCurrentShuffling
-        ? cachedCurrentShuffling
-        : shufflingCache.getSync(currentEpoch, currentDecisionRoot, {
-            state,
-            activeIndices: new Uint32Array(currentActiveIndicesAsNumberArray),
-          });
-
-      previousShuffling = cachedPreviousShuffling
-        ? cachedPreviousShuffling
-        : isGenesis
-          ? currentShuffling
-          : shufflingCache.getSync(previousEpoch, previousDecisionRoot, {
-              state,
-              activeIndices: new Uint32Array(previousActiveIndicesAsNumberArray),
-            });
-
-      nextShuffling = cachedNextShuffling
-        ? cachedNextShuffling
-        : shufflingCache.getSync(nextEpoch, nextDecisionRoot, {
-            state,
-            activeIndices: nextActiveIndices,
-          });
-    }
+    const previousShuffling =
+      cachedPreviousShuffling ??
+      (isGenesis
+        ? currentShuffling
+        : computeEpochShuffling(state, new Uint32Array(previousActiveIndicesAsNumberArray), previousEpoch));
+
+    const nextShuffling = cachedNextShuffling ?? computeEpochShuffling(state, nextActiveIndices, nextEpoch);
 
     const currentProposerSeed = getSeed(state, currentEpoch, DOMAIN_BEACON_PROPOSER);
 
@@ -549,7 +513,6 @@ export class EpochCache {
       config,
       pubkey2index,
       index2pubkey,
-      shufflingCache,
       proposers,
       // On first epoch, set to null to prevent unnecessary work since this is only used for metrics
       proposersPrevEpoch: null,
@@ -593,7 +556,6 @@ export class EpochCache {
       // Common append-only structures shared with all states, no need to clone
       pubkey2index: this.pubkey2index,
       index2pubkey: this.index2pubkey,
-      shufflingCache: this.shufflingCache,
       // Immutable data
       proposers: this.proposers,
       proposersPrevEpoch: this.proposersPrevEpoch,
@@ -652,62 +614,26 @@ export class EpochCache {
     this.previousShuffling = this.currentShuffling;
     this.previousDecisionRoot = this.currentDecisionRoot;
 
-    // move next to current or calculate upcoming
+    // move next to current
     this.currentDecisionRoot = this.nextDecisionRoot;
-    if (this.nextShuffling) {
-      // was already pulled from the ShufflingCache to the EpochCache (should be in most cases)
-      this.currentShuffling = this.nextShuffling;
-    } else {
-      this.shufflingCache?.metrics?.shufflingCache.nextShufflingNotOnEpochCache.inc();
-      this.currentShuffling =
-        this.shufflingCache?.getSync(upcomingEpoch, this.currentDecisionRoot, {
-          state,
-          // have to use the "nextActiveIndices" that were saved in the last transition here to calculate
-          // the upcoming shuffling if it is not already built (similar condition to the below computation)
-          activeIndices: this.nextActiveIndices,
-        }) ??
-        // allow for this case during testing where the ShufflingCache is not present, may affect perf testing
-        // so should be taken into account when structuring tests.  Should not affect unit or other tests though
-        computeEpochShuffling(state, this.nextActiveIndices, upcomingEpoch);
-    }
+    this.currentShuffling = this.nextShuffling;
 
-    // handle next values
-    this.nextDecisionRoot = epochTransitionCache.nextShufflingDecisionRoot;
+    // Compute shuffling for epoch n+2
+    //
+    // Post-Fulu (EIP-7917), the beacon state includes a `proposer_lookahead` field that stores
+    // proposer indices for MIN_SEED_LOOKAHEAD + 1 epochs ahead (2 epochs with MIN_SEED_LOOKAHEAD=1).
+    // At each epoch boundary, processProposerLookahead() shifts out the current epoch's proposers
+    // and appends new proposers for epoch n + MIN_SEED_LOOKAHEAD + 1 (i.e., epoch n+2).
+    //
+    // processProposerLookahead() already computes the n+2 shuffling and stores it in
+    // epochTransitionCache.nextShuffling. Reuse it here to avoid duplicate computation.
+    // Pre-Fulu, we need to compute it here since processProposerLookahead doesn't run.
+    //
+    // See: https://eips.ethereum.org/EIPS/eip-7917
+    this.nextDecisionRoot = calculateDecisionRoot(state, epochAfterUpcoming);
     this.nextActiveIndices = epochTransitionCache.nextShufflingActiveIndices;
-    if (this.shufflingCache) {
-      if (!epochTransitionCache.asyncShufflingCalculation) {
-        this.nextShuffling = this.shufflingCache.getSync(epochAfterUpcoming, this.nextDecisionRoot, {
-          state,
-          activeIndices: this.nextActiveIndices,
-        });
-      } else {
-        this.nextShuffling = null;
-        // This promise will resolve immediately after the synchronous code of the state-transition runs. Until
-        // the build is done on a worker thread it will be calculated immediately after the epoch transition
-        // completes.  Once the work is done concurrently it should be ready by time this get runs so the promise
-        // will resolve directly on the next spin of the event loop because the epoch transition and shuffling take
-        // about the same time to calculate so theoretically its ready now.  Do not await here though in case it
-        // is not ready yet as the transition must not be asynchronous.
-        this.shufflingCache
-          .get(epochAfterUpcoming, this.nextDecisionRoot)
-          .then((shuffling) => {
-            if (!shuffling) {
-              throw new Error("EpochShuffling not returned from get in afterProcessEpoch");
-            }
-            this.nextShuffling = shuffling;
-          })
-          .catch((err) => {
-            this.shufflingCache?.logger?.error(
-              "EPOCH_CONTEXT_SHUFFLING_BUILD_ERROR",
-              {epoch: epochAfterUpcoming, decisionRoot: epochTransitionCache.nextShufflingDecisionRoot},
-              err
-            );
-          });
-      }
-    } else {
-      // Only for testing. shufflingCache should always be available in prod
-      this.nextShuffling = computeEpochShuffling(state, this.nextActiveIndices, epochAfterUpcoming);
-    }
+    this.nextShuffling =
+      epochTransitionCache.nextShuffling ?? computeEpochShuffling(state, this.nextActiveIndices, epochAfterUpcoming);
 
     // TODO: DEDUPLICATE from createEpochCache
     //
@@ -1100,10 +1026,6 @@ export class EpochCache {
       case this.epoch:
         return this.currentShuffling;
       case this.nextEpoch:
-        if (!this.nextShuffling) {
-          this.nextShuffling =
-            this.shufflingCache?.getSync(this.nextEpoch, this.getShufflingDecisionRoot(this.nextEpoch)) ?? null;
-        }
         return this.nextShuffling;
       default:
         return null;

package/src/cache/epochTransitionCache.ts

@@ -1,12 +1,6 @@
-import {
-  EPOCHS_PER_SLASHINGS_VECTOR,
-  FAR_FUTURE_EPOCH,
-  ForkSeq,
-  MIN_ACTIVATION_BALANCE,
-  SLOTS_PER_HISTORICAL_ROOT,
-} from "@lodestar/params";
-import {Epoch, RootHex, ValidatorIndex} from "@lodestar/types";
-import {intDiv, toRootHex} from "@lodestar/utils";
+import {EPOCHS_PER_SLASHINGS_VECTOR, FAR_FUTURE_EPOCH, ForkSeq, MIN_ACTIVATION_BALANCE} from "@lodestar/params";
+import {Epoch, ValidatorIndex} from "@lodestar/types";
+import {intDiv} from "@lodestar/utils";
 import {processPendingAttestations} from "../epoch/processPendingAttestations.js";
 import {
   CachedBeaconStateAllForks,
@@ -26,16 +20,13 @@ import {
   FLAG_UNSLASHED,
   hasMarkers,
 } from "../util/attesterStatus.js";
+import {EpochShuffling} from "../util/epochShuffling.js";
 
 export type EpochTransitionCacheOpts = {
   /**
    * Assert progressive balances the same to EpochTransitionCache
    */
   assertCorrectProgressiveBalances?: boolean;
-  /**
-   * Do not queue shuffling calculation async. Forces sync JIT calculation in afterProcessEpoch
-   */
-  asyncShufflingCalculation?: boolean;
 };
 
 /**
@@ -162,9 +153,10 @@ export interface EpochTransitionCache {
   nextShufflingActiveIndices: Uint32Array;
 
   /**
-   * Shuffling decision root that gets set on the EpochCache in afterProcessEpoch
+   * Pre-computed shuffling for epoch N+2, populated by processProposerLookahead (Fulu+).
+   * Used by afterProcessEpoch to avoid recomputing the same shuffling.
    */
-  nextShufflingDecisionRoot: RootHex;
+  nextShuffling: EpochShuffling | null;
 
   /**
    * Altair specific, this is total active balances for the next epoch.
@@ -179,12 +171,6 @@ export interface EpochTransitionCache {
    */
   nextEpochTotalActiveBalanceByIncrement: number;
 
-  /**
-   * Compute the shuffling sync or async.  Defaults to synchronous.  Need to pass `true` with the
-   * `EpochTransitionCacheOpts`
-   */
-  asyncShufflingCalculation: boolean;
-
   /**
    * Track by validator index if it's active in the prev epoch.
    * Used in metrics
@@ -379,12 +365,7 @@ export function beforeProcessEpoch(
     }
   });
 
-  // Trigger async build of shuffling for epoch after next (nextShuffling post epoch transition)
-  const epochAfterNext = state.epochCtx.nextEpoch + 1;
-  // cannot call calculateShufflingDecisionRoot here because spec prevent getting current slot
-  // as a decision block.  we are part way through the transition though and this was added in
-  // process slot beforeProcessEpoch happens so it available and valid
-  const nextShufflingDecisionRoot = toRootHex(state.blockRoots.get(state.slot % SLOTS_PER_HISTORICAL_ROOT));
+  // Prepare shuffling data for epoch after next (nextShuffling post epoch transition)
   const nextShufflingActiveIndices = new Uint32Array(nextEpochShufflingActiveIndicesLength);
   if (nextEpochShufflingActiveIndicesLength > nextEpochShufflingActiveValidatorIndices.length) {
     throw new Error(
@@ -396,11 +377,6 @@ export function beforeProcessEpoch(
     nextShufflingActiveIndices[i] = nextEpochShufflingActiveValidatorIndices[i];
   }
 
-  const asyncShufflingCalculation = opts?.asyncShufflingCalculation ?? false;
-  if (asyncShufflingCalculation) {
-    state.epochCtx.shufflingCache?.build(epochAfterNext, nextShufflingDecisionRoot, state, nextShufflingActiveIndices);
-  }
-
   if (totalActiveStakeByIncrement < 1) {
     totalActiveStakeByIncrement = 1;
   } else if (totalActiveStakeByIncrement >= Number.MAX_SAFE_INTEGER) {
@@ -524,9 +500,8 @@ export function beforeProcessEpoch(
     indicesEligibleForActivationQueue,
     indicesEligibleForActivation: indicesEligibleForActivation.map(({validatorIndex}) => validatorIndex),
     indicesToEject,
-    nextShufflingDecisionRoot,
     nextShufflingActiveIndices,
-    asyncShufflingCalculation,
+    nextShuffling: null,
     // to be updated in processEffectiveBalanceUpdates
     nextEpochTotalActiveBalanceByIncrement: 0,
     isActivePrevEpoch,

package/src/cache/stateCache.ts

@@ -17,6 +17,7 @@ import {
 } from "./types.js";
 
 export type BeaconStateCache = {
+  /** @deprecated should not access config outside of state-transition package */
   config: BeaconConfig;
   epochCtx: EpochCache;
   /** Count of clones created from this BeaconStateCache instance. readonly to prevent accidental usage downstream */
@@ -179,7 +180,7 @@ export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStat
     stateBytes,
     seedValidatorsBytes
   );
-  const {pubkey2index, index2pubkey, shufflingCache} = cachedSeedState.epochCtx;
+  const {pubkey2index, index2pubkey} = cachedSeedState.epochCtx;
   // Get the validators sub tree once for all the loop
   const validators = migratedState.validators;
   for (const validatorIndex of modifiedValidators) {
@@ -195,7 +196,6 @@ export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStat
       config: cachedSeedState.config,
       pubkey2index,
       index2pubkey,
-      shufflingCache,
     },
     {...(opts ?? {}), ...{skipSyncPubkeys: true}}
   ) as T;

package/src/epoch/processProposerLookahead.ts

@@ -22,13 +22,9 @@ export function processProposerLookahead(
   // Fill in the last epoch with new proposer indices
   const epoch = state.epochCtx.epoch + MIN_SEED_LOOKAHEAD + 1;
 
-  const shuffling =
-    state.epochCtx.shufflingCache?.getSync(epoch, cache.nextShufflingDecisionRoot, {
-      state,
-      activeIndices: cache.nextShufflingActiveIndices,
-    }) ??
-    // Only for testing. shufflingCache should always be available in prod
-    computeEpochShuffling(state, cache.nextShufflingActiveIndices, epoch);
+  const shuffling = computeEpochShuffling(state, cache.nextShufflingActiveIndices, epoch);
+  // Save shuffling to cache so afterProcessEpoch can reuse it instead of recomputing
+  cache.nextShuffling = shuffling;
 
   const lastEpochProposerLookahead = computeProposerIndices(fork, state, shuffling, epoch);
 

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;
+}