@lodestar/state-transition 1.35.0-dev.f80d2d52da → 1.35.0-dev.fcf8d024ea

package/src/cache/stateCache.ts

@@ -0,0 +1,268 @@
+import {PublicKey} from "@chainsafe/blst";
+import {BeaconConfig} from "@lodestar/config";
+import {loadState} from "../util/loadState/loadState.js";
+import {EpochCache, EpochCacheImmutableData, EpochCacheOpts} from "./epochCache.js";
+import {RewardCache, createEmptyRewardCache} from "./rewardCache.js";
+import {
+  BeaconStateAllForks,
+  BeaconStateAltair,
+  BeaconStateBellatrix,
+  BeaconStateCapella,
+  BeaconStateDeneb,
+  BeaconStateElectra,
+  BeaconStateExecutions,
+  BeaconStateFulu,
+  BeaconStateGloas,
+  BeaconStatePhase0,
+} from "./types.js";
+
+export type BeaconStateCache = {
+  config: BeaconConfig;
+  epochCtx: EpochCache;
+  /** Count of clones created from this BeaconStateCache instance. readonly to prevent accidental usage downstream */
+  readonly clonedCount: number;
+  readonly clonedCountWithTransferCache: number;
+  readonly createdWithTransferCache: boolean;
+  proposerRewards: RewardCache;
+};
+
+type Mutable<T> = {
+  -readonly [P in keyof T]: T[P];
+};
+
+type BeaconStateCacheMutable = Mutable<BeaconStateCache>;
+
+/**
+ * `BeaconState` with various caches
+ *
+ * Currently contains the following:
+ * - The full list of network params, ssz types, and fork schedule
+ * - The ssz type for the state
+ * - The full merkle tree representation of the state
+ * - A cache of shufflings, committees, proposers, expanded pubkeys
+ * - A flat copy of validators (for fast access/iteration)
+ *
+ * ### BeaconState data representation tradeoffs:
+ *
+ * Requirements of a BeaconState:
+ * - Block processing and epoch processing be performant to not block the node. This functions requires to iterate over
+ *   very large arrays fast, while doing random mutations or big mutations. After them the state must be hashed.
+ *   Processing times: (ideal / current / maximum)
+ *   - block processing: 20ms / 200ms / 500ms
+ *   - epoch processing: 200ms / 2s / 4s
+ *
+ * - BeaconState must be memory efficient. Data should only be represented once in a succint manner. Uint8Arrays are
+ *   expensive, native types are not.
+ * - BeaconState must be hashed efficiently. Data must be merkelized before hashing so the conversion to merkelized
+ *   must be fast or be done already. It must must persist a hashing cache that should be structurally shared between
+ *   states for memory efficiency.
+ * - BeaconState raw data changes sparsingly, so it should be structurally shared between states for memory efficiency
+ *
+ * Summary of goals:
+ * - Structurally share data + hashing cache
+ * - Very fast read and iteration over large arrays
+ * - Fast bulk writes and somewhat fast single writes
+ * - Fast merkelization of data for hashing
+ *
+ * #### state.validators
+ *
+ * 91% of all memory merkelized is state.validators. In normal network conditions state.validators changes rarely.
+ * However for epoch processing the entire array must be iterated and read. So we need fast reads and slow writes.
+ * Tradeoffs to achieve that:
+ * - Represent leaf data with native JS types (deserialized form)
+ * - Use a single Tree for structurally sharing leaf data + hashing cache
+ * - Keep only the root cached on leaf nodes
+ * - Micro-optimizations (TODO):
+ *   - Keep also the root of the node above pubkey and withdrawal creds. Will never change
+ *   - Keep pubkey + withdrawal creds in the same Uint8Array
+ *   - Have a global pubkey + withdrawal creds Uint8Array global cache, like with the index2pubkey cache
+ *
+ * ------------------
+ *
+ * _Previous JSDocs for `BeaconStateContext`_
+ *
+ * Cache useful data associated to a specific state.
+ * Optimize processing speed of block processing + gossip validation while having a low memory cost.
+ *
+ * Previously BeaconStateContext included:
+ * ```ts
+ * validators: CachedValidatorList & T["validators"];
+ * balances: CachedBalanceList & T["balances"];
+ * inactivityScores: CachedInactivityScoreList & Number64[];
+ * ```
+ *
+ * Those caches where removed since they are no strictly necessary to make the epoch transition faster,
+ * but have a high memory cost. Note that all data was duplicated between the Tree and MutableVector.
+ * 1. TreeView, for efficient hashing
+ * 2. MutableVector (persistent-ts) with StructBacked validator objects for fast accessing and iteration
+ *
+ * ### validators
+ * state.validators is the heaviest data structure in the state. As TreeView, the leafs account for 91% with
+ * 200_000 validators. It requires ~ 2_000_000 Uint8Array instances with total memory of ~ 400MB.
+ * However its contents don't change very often. Validators only change when;
+ * - they first deposit
+ * - they dip from 32 effective balance to 31 (pretty much only when inactive for very long, or slashed)
+ * - they activate (once)
+ * - they exit (once)
+ * - they get slashed (max once)
+ *
+ * ### balances
+ * The balances array completely changes at the epoch boundary, where almost all the validator balances
+ * are updated. However it may have tiny changes during block processing if:
+ * - On a valid deposit
+ * - Validator gets slashed
+ * - On altair, the block proposer. Optimized to only happen once per block
+ *
+ * ### epochParticipation
+ * epochParticipation changes continuously through the epoch for each partipation bit of each valid attestation in the state.
+ * The entire structure is dropped after two epochs.
+ *
+ * ### inactivityScores
+ * inactivityScores can be changed only:
+ * - At the epoch transition. It only changes when a validator is offline. So it may change a bit but not
+ *   a lot on normal network conditions.
+ * - During block processing, when a validator joins a new 0 entry is pushed
+ *
+ * RESULT: Don't keep a duplicated structure around always. During block processing just push to the tree. During
+ * epoch processing some temporary flat structures are computed but dropped after processing the epoch.
+ */
+export type CachedBeaconState<T extends BeaconStateAllForks> = T & BeaconStateCache;
+
+export type CachedBeaconStatePhase0 = CachedBeaconState<BeaconStatePhase0>;
+export type CachedBeaconStateAltair = CachedBeaconState<BeaconStateAltair>;
+export type CachedBeaconStateBellatrix = CachedBeaconState<BeaconStateBellatrix>;
+export type CachedBeaconStateCapella = CachedBeaconState<BeaconStateCapella>;
+export type CachedBeaconStateDeneb = CachedBeaconState<BeaconStateDeneb>;
+export type CachedBeaconStateElectra = CachedBeaconState<BeaconStateElectra>;
+export type CachedBeaconStateFulu = CachedBeaconState<BeaconStateFulu>;
+export type CachedBeaconStateGloas = CachedBeaconState<BeaconStateGloas>;
+
+export type CachedBeaconStateAllForks = CachedBeaconState<BeaconStateAllForks>;
+export type CachedBeaconStateExecutions = CachedBeaconState<BeaconStateExecutions>;
+/**
+ * Create CachedBeaconState computing a new EpochCache instance
+ * TODO ELECTRA: rename this to createFinalizedCachedBeaconState() as it's intended for finalized state only
+ */
+export function createCachedBeaconState<T extends BeaconStateAllForks>(
+  state: T,
+  immutableData: EpochCacheImmutableData,
+  opts?: EpochCacheOpts
+): T & BeaconStateCache {
+  const epochCache = EpochCache.createFromState(state, immutableData, opts);
+  const cachedState = getCachedBeaconState(state, {
+    config: immutableData.config,
+    epochCtx: epochCache,
+    clonedCount: 0,
+    clonedCountWithTransferCache: 0,
+    createdWithTransferCache: false,
+    proposerRewards: createEmptyRewardCache(),
+  });
+
+  return cachedState;
+}
+
+/**
+ * Create a CachedBeaconState given a cached seed state and state bytes
+ * This guarantees that the returned state shares the same tree with the seed state
+ * Check loadState() api for more details
+ * // TODO: rename to loadUnfinalizedCachedBeaconState() due to ELECTRA
+ */
+export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStateCache>(
+  cachedSeedState: T,
+  stateBytes: Uint8Array,
+  opts?: EpochCacheOpts,
+  seedValidatorsBytes?: Uint8Array
+): T {
+  const {state: migratedState, modifiedValidators} = loadState(
+    cachedSeedState.config,
+    cachedSeedState,
+    stateBytes,
+    seedValidatorsBytes
+  );
+  const {pubkey2index, index2pubkey, shufflingCache} = cachedSeedState.epochCtx;
+  // Get the validators sub tree once for all the loop
+  const validators = migratedState.validators;
+  for (const validatorIndex of modifiedValidators) {
+    const validator = validators.getReadonly(validatorIndex);
+    const pubkey = validator.pubkey;
+    pubkey2index.set(pubkey, validatorIndex);
+    index2pubkey[validatorIndex] = PublicKey.fromBytes(pubkey);
+  }
+
+  return createCachedBeaconState(
+    migratedState,
+    {
+      config: cachedSeedState.config,
+      pubkey2index,
+      index2pubkey,
+      shufflingCache,
+    },
+    {...(opts ?? {}), ...{skipSyncPubkeys: true}}
+  ) as T;
+}
+
+/**
+ * Attach an already computed BeaconStateCache to a BeaconState object
+ */
+export function getCachedBeaconState<T extends BeaconStateAllForks>(
+  state: T,
+  cache: BeaconStateCache
+): T & BeaconStateCache {
+  const cachedState = state as T & BeaconStateCache;
+  cachedState.config = cache.config;
+  cachedState.epochCtx = cache.epochCtx;
+  (cachedState as BeaconStateCacheMutable).clonedCount = cache.clonedCount;
+  (cachedState as BeaconStateCacheMutable).clonedCountWithTransferCache = cache.clonedCountWithTransferCache;
+  (cachedState as BeaconStateCacheMutable).createdWithTransferCache = cache.createdWithTransferCache;
+  cachedState.proposerRewards = cache.proposerRewards;
+
+  // Overwrite .clone function to preserve cache
+  // TreeViewDU.clone() creates a new object that does not have the attached cache
+  const viewDUClone = cachedState.clone.bind(cachedState);
+
+  function clone(this: T & BeaconStateCache, dontTransferCache?: boolean): T & BeaconStateCache {
+    const viewDUCloned = viewDUClone(dontTransferCache);
+
+    // Override `readonly` attribute in single place where `.clonedCount` is incremented
+    (this as BeaconStateCacheMutable).clonedCount++;
+
+    if (!dontTransferCache) {
+      (this as BeaconStateCacheMutable).clonedCountWithTransferCache++;
+    }
+
+    return getCachedBeaconState(viewDUCloned, {
+      config: this.config,
+      epochCtx: this.epochCtx.clone(),
+      clonedCount: 0,
+      clonedCountWithTransferCache: 0,
+      createdWithTransferCache: !dontTransferCache,
+      proposerRewards: createEmptyRewardCache(), // this sets the rewards to 0 while cloning new state
+    }) as T & BeaconStateCache;
+  }
+
+  cachedState.clone = clone as typeof viewDUClone;
+
+  return cachedState;
+}
+
+/**
+ * Typeguard to check if a state contains a BeaconStateCache
+ */
+export function isCachedBeaconState<T extends BeaconStateAllForks>(
+  state: T | (T & BeaconStateCache)
+): state is T & BeaconStateCache {
+  return (state as T & BeaconStateCache).epochCtx !== undefined;
+}
+
+// Given a CachedBeaconState, check if validators array internal cache is populated.
+// This cache is populated during epoch transition, and should be preserved for performance.
+// If the cache is missing too often, means that our clone strategy is not working well.
+export function isStateValidatorsNodesPopulated(state: CachedBeaconStateAllForks): boolean {
+  // biome-ignore lint/complexity/useLiteralKeys: It is a private attribute
+  return state.validators["nodesPopulated"] === true;
+}
+
+export function isStateBalancesNodesPopulated(state: CachedBeaconStateAllForks): boolean {
+  // biome-ignore lint/complexity/useLiteralKeys: It is a private attribute
+  return state.balances["nodesPopulated"] === true;
+}

package/src/cache/syncCommitteeCache.ts

@@ -0,0 +1,96 @@
+import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
+import {CompositeViewDU} from "@chainsafe/ssz";
+import {ValidatorIndex, ssz} from "@lodestar/types";
+import {toPubkeyHex} from "@lodestar/utils";
+
+type ValidatorSyncCommitteeIndexMap = Map<ValidatorIndex, number[]>;
+
+export type SyncCommitteeCache = {
+  /**
+   * Update freq: every ~ 27h.
+   * Memory cost: 512 Number integers.
+   */
+  validatorIndices: Uint32Array;
+  /**
+   * Update freq: every ~ 27h.
+   * Memory cost: Map of Number -> Number with 512 entries.
+   * Note: it stores the position indices in sync committee for each sync committee validator
+   */
+  validatorIndexMap: ValidatorSyncCommitteeIndexMap;
+};
+
+/** Placeholder object for pre-altair fork */
+export class SyncCommitteeCacheEmpty implements SyncCommitteeCache {
+  get validatorIndices(): Uint32Array {
+    throw Error("Empty SyncCommitteeCache");
+  }
+
+  get validatorIndexMap(): ValidatorSyncCommitteeIndexMap {
+    throw Error("Empty SyncCommitteeCache");
+  }
+}
+
+export function getSyncCommitteeCache(validatorIndices: Uint32Array): SyncCommitteeCache {
+  return {
+    validatorIndices,
+    validatorIndexMap: computeValidatorSyncCommitteeIndexMap(validatorIndices),
+  };
+}
+
+export function computeSyncCommitteeCache(
+  syncCommittee: CompositeViewDU<typeof ssz.altair.SyncCommittee>,
+  pubkey2index: PubkeyIndexMap
+): SyncCommitteeCache {
+  const validatorIndices = computeSyncCommitteeValidatorIndices(syncCommittee, pubkey2index);
+  const validatorIndexMap = computeValidatorSyncCommitteeIndexMap(validatorIndices);
+  return {
+    validatorIndices,
+    validatorIndexMap,
+  };
+}
+
+/**
+ * Compute all position index in sync committee for all validatorIndexes in `syncCommitteeIndexes`.
+ * Helps reduce work necessary to verify a validatorIndex belongs in a sync committee and which.
+ * This is similar to compute_subnets_for_sync_committee in https://github.com/ethereum/eth2.0-specs/blob/v1.1.0-alpha.5/specs/altair/validator.md
+ */
+export function computeValidatorSyncCommitteeIndexMap(
+  validatorIndices: ArrayLike<ValidatorIndex>
+): ValidatorSyncCommitteeIndexMap {
+  const map = new Map<ValidatorIndex, number[]>();
+
+  for (let i = 0, len = validatorIndices.length; i < len; i++) {
+    const validatorIndex = validatorIndices[i];
+    let indexes = map.get(validatorIndex);
+    if (!indexes) {
+      indexes = [];
+      map.set(validatorIndex, indexes);
+    }
+    if (!indexes.includes(i)) {
+      indexes.push(i);
+    }
+  }
+
+  return map;
+}
+
+/**
+ * Extract validator indices from current and next sync committee
+ */
+function computeSyncCommitteeValidatorIndices(
+  syncCommittee: CompositeViewDU<typeof ssz.altair.SyncCommittee>,
+  pubkey2index: PubkeyIndexMap
+): Uint32Array {
+  const pubkeys = syncCommittee.pubkeys.getAllReadonly();
+  const validatorIndices = new Uint32Array(pubkeys.length);
+  for (const [i, pubkey] of pubkeys.entries()) {
+    const validatorIndex = pubkey2index.get(pubkey);
+    if (validatorIndex === null) {
+      throw Error(`SyncCommittee pubkey is unknown ${toPubkeyHex(pubkey)}`);
+    }
+
+    validatorIndices[i] = validatorIndex;
+  }
+
+  return validatorIndices;
+}

package/src/cache/types.ts

@@ -0,0 +1,18 @@
+import {CompositeViewDU} from "@chainsafe/ssz";
+import {ForkAll, ForkName, ForkPostBellatrix, ForkPreGloas} from "@lodestar/params";
+import {Epoch, RootHex, SSZTypesFor} from "@lodestar/types";
+import {EpochShuffling} from "../util/epochShuffling.js";
+
+export type BeaconStatePhase0 = CompositeViewDU<SSZTypesFor<ForkName.phase0, "BeaconState">>;
+export type BeaconStateAltair = CompositeViewDU<SSZTypesFor<ForkName.altair, "BeaconState">>;
+export type BeaconStateBellatrix = CompositeViewDU<SSZTypesFor<ForkName.bellatrix, "BeaconState">>;
+export type BeaconStateCapella = CompositeViewDU<SSZTypesFor<ForkName.capella, "BeaconState">>;
+export type BeaconStateDeneb = CompositeViewDU<SSZTypesFor<ForkName.deneb, "BeaconState">>;
+export type BeaconStateElectra = CompositeViewDU<SSZTypesFor<ForkName.electra, "BeaconState">>;
+export type BeaconStateFulu = CompositeViewDU<SSZTypesFor<ForkName.fulu, "BeaconState">>;
+export type BeaconStateGloas = CompositeViewDU<SSZTypesFor<ForkName.gloas, "BeaconState">>;
+
+export type BeaconStateAllForks = CompositeViewDU<SSZTypesFor<ForkAll, "BeaconState">>;
+export type BeaconStateExecutions = CompositeViewDU<SSZTypesFor<ForkPostBellatrix & ForkPreGloas, "BeaconState">>;
+
+export type ShufflingGetter = (shufflingEpoch: Epoch, dependentRoot: RootHex) => EpochShuffling | null;

package/src/constants/constants.ts

@@ -0,0 +1,12 @@
+export const ZERO_HASH = new Uint8Array(32).fill(0);
+export const EMPTY_SIGNATURE = new Uint8Array(96).fill(0);
+export const SECONDS_PER_DAY = 86400;
+export const BASE_REWARDS_PER_EPOCH = 4;
+export const G2_POINT_AT_INFINITY = new Uint8Array(
+  Buffer.from(
+    "c000000000000000000000000000000000000000000000000000000000000000" +
+      "0000000000000000000000000000000000000000000000000000000000000000" +
+      "0000000000000000000000000000000000000000000000000000000000000000",
+    "hex"
+  )
+);

package/src/constants/index.ts

@@ -0,0 +1 @@
+export * from "./constants.js";

package/src/epoch/computeUnrealizedCheckpoints.ts

@@ -0,0 +1,55 @@
+import {ForkSeq, GENESIS_EPOCH} from "@lodestar/params";
+import {phase0} from "@lodestar/types";
+import {beforeProcessEpoch} from "../cache/epochTransitionCache.js";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {
+  processJustificationAndFinalization,
+  weighJustificationAndFinalization,
+} from "./processJustificationAndFinalization.js";
+
+/**
+ * Compute on-the-fly justified / finalized checkpoints.
+ *   - For phase0, we need to create the cache through beforeProcessEpoch
+ *   - For other forks, use the progressive balances inside EpochCache
+ */
+export function computeUnrealizedCheckpoints(state: CachedBeaconStateAllForks): {
+  justifiedCheckpoint: phase0.Checkpoint;
+  finalizedCheckpoint: phase0.Checkpoint;
+} {
+  let stateRealizedCheckpoints: CachedBeaconStateAllForks;
+
+  // For phase0, we need to create the cache through beforeProcessEpoch
+  if (state.config.getForkSeq(state.slot) === ForkSeq.phase0) {
+    // Clone state to mutate below         true = do not transfer cache
+    stateRealizedCheckpoints = state.clone(true);
+    const epochTransitionCache = beforeProcessEpoch(stateRealizedCheckpoints);
+    processJustificationAndFinalization(stateRealizedCheckpoints, epochTransitionCache);
+  }
+
+  // For other forks, use the progressive balances inside EpochCache
+  else {
+    // same logic to processJustificationAndFinalization
+    if (state.epochCtx.epoch <= GENESIS_EPOCH + 1) {
+      stateRealizedCheckpoints = state;
+    }
+
+    // Clone state and use progressive balances
+    else {
+      // Clone state to mutate below         true = do not transfer cache
+      stateRealizedCheckpoints = state.clone(true);
+
+      weighJustificationAndFinalization(
+        stateRealizedCheckpoints,
+        state.epochCtx.totalActiveBalanceIncrements,
+        // minimum of total progressive unslashed balance should be 1
+        Math.max(state.epochCtx.previousTargetUnslashedBalanceIncrements, 1),
+        Math.max(state.epochCtx.currentTargetUnslashedBalanceIncrements, 1)
+      );
+    }
+  }
+
+  return {
+    justifiedCheckpoint: stateRealizedCheckpoints.currentJustifiedCheckpoint,
+    finalizedCheckpoint: stateRealizedCheckpoints.finalizedCheckpoint,
+  };
+}

package/src/epoch/getAttestationDeltas.ts

@@ -0,0 +1,169 @@
+import {
+  BASE_REWARD_FACTOR,
+  EFFECTIVE_BALANCE_INCREMENT,
+  INACTIVITY_PENALTY_QUOTIENT,
+  MIN_EPOCHS_TO_INACTIVITY_PENALTY,
+  PROPOSER_REWARD_QUOTIENT,
+} from "@lodestar/params";
+import {bigIntSqrt, bnToNum} from "@lodestar/utils";
+import {BASE_REWARDS_PER_EPOCH as BASE_REWARDS_PER_EPOCH_CONST} from "../constants/index.js";
+import {CachedBeaconStatePhase0, EpochTransitionCache} from "../types.js";
+import {hasMarkers} from "../util/attesterStatus.js";
+import {newZeroedArray} from "../util/index.js";
+
+/**
+ * Redefine constants in attesterStatus to improve performance
+ */
+const FLAG_PREV_SOURCE_ATTESTER = 1 << 0;
+const FLAG_PREV_TARGET_ATTESTER = 1 << 1;
+const FLAG_PREV_HEAD_ATTESTER = 1 << 2;
+const FLAG_UNSLASHED = 1 << 6;
+const FLAG_ELIGIBLE_ATTESTER = 1 << 7;
+
+const FLAG_PREV_SOURCE_ATTESTER_OR_UNSLASHED = FLAG_PREV_SOURCE_ATTESTER | FLAG_UNSLASHED;
+const FLAG_PREV_TARGET_ATTESTER_OR_UNSLASHED = FLAG_PREV_TARGET_ATTESTER | FLAG_UNSLASHED;
+const FLAG_PREV_HEAD_ATTESTER_OR_UNSLASHED = FLAG_PREV_HEAD_ATTESTER | FLAG_UNSLASHED;
+
+type RewardPenaltyItem = {
+  baseReward: number;
+  proposerReward: number;
+  maxAttesterReward: number;
+  sourceCheckpointReward: number;
+  targetCheckpointReward: number;
+  headReward: number;
+  basePenalty: number;
+  finalityDelayPenalty: number;
+};
+
+/**
+ * Return attestation reward/penalty deltas for each validator.
+ *
+ * - On normal mainnet conditions
+ *   - prevSourceAttester: 98%
+ *   - prevTargetAttester: 96%
+ *   - prevHeadAttester:   93%
+ *   - currSourceAttester: 95%
+ *   - currTargetAttester: 93%
+ *   - currHeadAttester:   91%
+ *   - unslashed:          100%
+ *   - eligibleAttester:   98%
+ */
+export function getAttestationDeltas(
+  state: CachedBeaconStatePhase0,
+  cache: EpochTransitionCache
+): [number[], number[]] {
+  const {flags, proposerIndices, inclusionDelays} = cache;
+  const validatorCount = flags.length;
+  const rewards = newZeroedArray(validatorCount);
+  const penalties = newZeroedArray(validatorCount);
+
+  // no need this as we make sure it in EpochTransitionCache
+  // let totalBalance = bigIntMax(epochTransitionCache.totalActiveStake, increment);
+  const totalBalance = cache.totalActiveStakeByIncrement;
+  const totalBalanceInGwei = BigInt(totalBalance) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
+
+  // increment is factored out from balance totals to avoid overflow
+  const prevEpochSourceStakeByIncrement = cache.prevEpochUnslashedStake.sourceStakeByIncrement;
+  const prevEpochTargetStakeByIncrement = cache.prevEpochUnslashedStake.targetStakeByIncrement;
+  const prevEpochHeadStakeByIncrement = cache.prevEpochUnslashedStake.headStakeByIncrement;
+
+  // sqrt first, before factoring out the increment for later usage
+  const balanceSqRoot = bnToNum(bigIntSqrt(totalBalanceInGwei));
+  const finalityDelay = cache.prevEpoch - state.finalizedCheckpoint.epoch;
+
+  const BASE_REWARDS_PER_EPOCH = BASE_REWARDS_PER_EPOCH_CONST;
+  const proposerRewardQuotient = PROPOSER_REWARD_QUOTIENT;
+  const isInInactivityLeak = finalityDelay > MIN_EPOCHS_TO_INACTIVITY_PENALTY;
+
+  // effectiveBalance is multiple of EFFECTIVE_BALANCE_INCREMENT and less than MAX_EFFECTIVE_BALANCE
+  // so there are limited values of them like 32, 31, 30
+  const rewardPnaltyItemCache = new Map<number, RewardPenaltyItem>();
+  const {effectiveBalanceIncrements} = state.epochCtx;
+  for (let i = 0; i < flags.length; i++) {
+    const flag = flags[i];
+    const effectiveBalanceIncrement = effectiveBalanceIncrements[i];
+    const effectiveBalance = effectiveBalanceIncrement * EFFECTIVE_BALANCE_INCREMENT;
+
+    let rewardItem = rewardPnaltyItemCache.get(effectiveBalanceIncrement);
+    if (!rewardItem) {
+      const baseReward = Math.floor(
+        Math.floor((effectiveBalance * BASE_REWARD_FACTOR) / balanceSqRoot) / BASE_REWARDS_PER_EPOCH
+      );
+      const proposerReward = Math.floor(baseReward / proposerRewardQuotient);
+      rewardItem = {
+        baseReward,
+        proposerReward,
+        maxAttesterReward: baseReward - proposerReward,
+        sourceCheckpointReward: isInInactivityLeak
+          ? baseReward
+          : Math.floor((baseReward * prevEpochSourceStakeByIncrement) / totalBalance),
+        targetCheckpointReward: isInInactivityLeak
+          ? baseReward
+          : Math.floor((baseReward * prevEpochTargetStakeByIncrement) / totalBalance),
+        headReward: isInInactivityLeak
+          ? baseReward
+          : Math.floor((baseReward * prevEpochHeadStakeByIncrement) / totalBalance),
+        basePenalty: baseReward * BASE_REWARDS_PER_EPOCH_CONST - proposerReward,
+        finalityDelayPenalty: Math.floor((effectiveBalance * finalityDelay) / INACTIVITY_PENALTY_QUOTIENT),
+      };
+      rewardPnaltyItemCache.set(effectiveBalanceIncrement, rewardItem);
+    }
+
+    const {
+      baseReward,
+      proposerReward,
+      maxAttesterReward,
+      sourceCheckpointReward,
+      targetCheckpointReward,
+      headReward,
+      basePenalty,
+      finalityDelayPenalty,
+    } = rewardItem;
+
+    // inclusion speed bonus
+    if (hasMarkers(flag, FLAG_PREV_SOURCE_ATTESTER_OR_UNSLASHED)) {
+      rewards[proposerIndices[i]] += proposerReward;
+      rewards[i] += Math.floor(maxAttesterReward / inclusionDelays[i]);
+    }
+
+    if (hasMarkers(flag, FLAG_ELIGIBLE_ATTESTER)) {
+      // expected FFG source
+      if (hasMarkers(flag, FLAG_PREV_SOURCE_ATTESTER_OR_UNSLASHED)) {
+        // justification-participation reward
+        rewards[i] += sourceCheckpointReward;
+      } else {
+        // justification-non-participation R-penalty
+        penalties[i] += baseReward;
+      }
+
+      // expected FFG target
+      if (hasMarkers(flag, FLAG_PREV_TARGET_ATTESTER_OR_UNSLASHED)) {
+        // boundary-attestation reward
+        rewards[i] += targetCheckpointReward;
+      } else {
+        // boundary-attestation-non-participation R-penalty
+        penalties[i] += baseReward;
+      }
+
+      // expected head
+      if (hasMarkers(flag, FLAG_PREV_HEAD_ATTESTER_OR_UNSLASHED)) {
+        // canonical-participation reward
+        rewards[i] += headReward;
+      } else {
+        // non-canonical-participation R-penalty
+        penalties[i] += baseReward;
+      }
+
+      // take away max rewards if we're not finalizing
+      if (isInInactivityLeak) {
+        penalties[i] += basePenalty;
+
+        if (!hasMarkers(flag, FLAG_PREV_TARGET_ATTESTER_OR_UNSLASHED)) {
+          penalties[i] += finalityDelayPenalty;
+        }
+      }
+    }
+  }
+
+  return [rewards, penalties];
+}