@lodestar/state-transition 1.35.0-dev.e18102ed8c → 1.35.0-dev.f45a2be721

package/src/epoch/processParticipationFlagUpdates.ts

@@ -0,0 +1,27 @@
+import {zeroNode} from "@chainsafe/persistent-merkle-tree";
+import {ssz} from "@lodestar/types";
+import {CachedBeaconStateAltair} from "../types.js";
+
+/**
+ * Updates `state.previousEpochParticipation` with precalculated epoch participation. Creates a new empty tree for
+ * `state.currentEpochParticipation`.
+ *
+ * PERF: Cost = 'proportional' $VALIDATOR_COUNT. Since it updates all of them at once, it will always recreate both
+ * trees completely.
+ */
+export function processParticipationFlagUpdates(state: CachedBeaconStateAltair): void {
+  // Set view and tree from currentEpochParticipation to previousEpochParticipation
+  state.previousEpochParticipation = state.currentEpochParticipation;
+
+  // We need to replace the node of currentEpochParticipation with a node that represents and empty list of some length.
+  // SSZ represents a list as = new BranchNode(chunksNode, lengthNode).
+  // Since the chunks represent all zero'ed data we can re-use the pre-compouted zeroNode at chunkDepth to skip any
+  // data transformation and create the required tree almost for free.
+  const currentEpochParticipationNode = ssz.altair.EpochParticipation.tree_setChunksNode(
+    state.currentEpochParticipation.node,
+    zeroNode(ssz.altair.EpochParticipation.chunkDepth),
+    state.currentEpochParticipation.length
+  );
+
+  state.currentEpochParticipation = ssz.altair.EpochParticipation.getViewDU(currentEpochParticipationNode);
+}

package/src/epoch/processParticipationRecordUpdates.ts

@@ -0,0 +1,14 @@
+import {ssz} from "@lodestar/types";
+import {CachedBeaconStatePhase0} from "../types.js";
+
+/**
+ * PERF: Should have zero cost. It just moves a rootNode from one key to another. Then it creates an empty tree on the
+ * previous key
+ */
+export function processParticipationRecordUpdates(state: CachedBeaconStatePhase0): void {
+  // rotate current/previous epoch attestations
+  state.previousEpochAttestations = state.currentEpochAttestations;
+
+  // Reset list to empty
+  state.currentEpochAttestations = ssz.phase0.EpochAttestations.defaultViewDU();
+}

package/src/epoch/processPendingAttestations.ts

@@ -0,0 +1,75 @@
+import {byteArrayEquals} from "@chainsafe/ssz";
+import {Epoch, phase0} from "@lodestar/types";
+import {CachedBeaconStatePhase0} from "../types.js";
+import {computeStartSlotAtEpoch, getBlockRootAtSlot} from "../util/index.js";
+
+/**
+ * Mutates `proposerIndices`, `inclusionDelays` and `flags` from all pending attestations.
+ *
+ * PERF: Cost 'proportional' to attestation count + how many bits per attestation + how many flags the attestation triggers
+ *
+ * - On normal mainnet conditions:
+ *   - previousEpochAttestations: 3403
+ *   - currentEpochAttestations:  3129
+ *   - previousEpochAttestationsBits: 83
+ *   - currentEpochAttestationsBits:  85
+ */
+export function processPendingAttestations(
+  state: CachedBeaconStatePhase0,
+  proposerIndices: number[],
+  inclusionDelays: number[],
+  flags: number[],
+  attestations: phase0.PendingAttestation[],
+  epoch: Epoch,
+  sourceFlag: number,
+  targetFlag: number,
+  headFlag: number
+): void {
+  const {epochCtx, slot: stateSlot} = state;
+  const prevEpoch = epochCtx.previousShuffling.epoch;
+  if (attestations.length === 0) {
+    return;
+  }
+
+  // Prevent frequent object get of external CommonJS dependencies
+  const byteArrayEqualsFn = byteArrayEquals;
+
+  const actualTargetBlockRoot = getBlockRootAtSlot(state, computeStartSlotAtEpoch(epoch));
+
+  for (const att of attestations) {
+    // Ignore empty BitArray, from spec test minimal/phase0/epoch_processing/participation_record_updates updated_participation_record
+    // See https://github.com/ethereum/consensus-specs/issues/2825
+    if (att.aggregationBits.bitLen === 0) {
+      continue;
+    }
+
+    const attData = att.data;
+    const inclusionDelay = att.inclusionDelay;
+    const proposerIndex = att.proposerIndex;
+    const attSlot = attData.slot;
+    const attVotedTargetRoot = byteArrayEqualsFn(attData.target.root, actualTargetBlockRoot);
+    const attVotedHeadRoot =
+      attSlot < stateSlot && byteArrayEqualsFn(attData.beaconBlockRoot, getBlockRootAtSlot(state, attSlot));
+    const committee = epochCtx.getBeaconCommittee(attSlot, attData.index);
+    const participants = att.aggregationBits.intersectValues(committee);
+
+    if (epoch === prevEpoch) {
+      for (const p of participants) {
+        if (proposerIndices[p] === -1 || inclusionDelays[p] > inclusionDelay) {
+          proposerIndices[p] = proposerIndex;
+          inclusionDelays[p] = inclusionDelay;
+        }
+      }
+    }
+
+    for (const p of participants) {
+      flags[p] |= sourceFlag;
+      if (attVotedTargetRoot) {
+        flags[p] |= targetFlag;
+        if (attVotedHeadRoot) {
+          flags[p] |= headFlag;
+        }
+      }
+    }
+  }
+}

package/src/epoch/processPendingConsolidations.ts

@@ -0,0 +1,59 @@
+import {CachedBeaconStateElectra, EpochTransitionCache} from "../types.js";
+import {decreaseBalance, increaseBalance} from "../util/balance.js";
+
+/**
+ * Starting from Electra:
+ * Process every `pendingConsolidation` in `state.pendingConsolidations`.
+ * Churn limit was applied when enqueueing so we don't care about the limit here
+ * However we only process consolidations up to current epoch
+ *
+ * For each valid `pendingConsolidation`, update withdrawal credential of target
+ * validator to compounding, decrease balance of source validator and increase balance
+ * of target validator.
+ *
+ * Dequeue all processed consolidations from `state.pendingConsolidation`
+ *
+ */
+export function processPendingConsolidations(state: CachedBeaconStateElectra, cache: EpochTransitionCache): void {
+  const nextEpoch = state.epochCtx.epoch + 1;
+  let nextPendingConsolidation = 0;
+  const validators = state.validators;
+  const cachedBalances = cache.balances;
+
+  let chunkStartIndex = 0;
+  const chunkSize = 100;
+  const pendingConsolidationsLength = state.pendingConsolidations.length;
+  outer: while (chunkStartIndex < pendingConsolidationsLength) {
+    const consolidationChunk = state.pendingConsolidations.getReadonlyByRange(chunkStartIndex, chunkSize);
+
+    for (const pendingConsolidation of consolidationChunk) {
+      const {sourceIndex, targetIndex} = pendingConsolidation;
+      const sourceValidator = validators.getReadonly(sourceIndex);
+
+      if (sourceValidator.slashed) {
+        nextPendingConsolidation++;
+        continue;
+      }
+
+      if (sourceValidator.withdrawableEpoch > nextEpoch) {
+        break outer;
+      }
+
+      // Calculate the consolidated balance
+      const sourceEffectiveBalance = Math.min(state.balances.get(sourceIndex), sourceValidator.effectiveBalance);
+
+      // Move active balance to target. Excess balance is withdrawable.
+      decreaseBalance(state, sourceIndex, sourceEffectiveBalance);
+      increaseBalance(state, targetIndex, sourceEffectiveBalance);
+      if (cachedBalances) {
+        cachedBalances[sourceIndex] -= sourceEffectiveBalance;
+        cachedBalances[targetIndex] += sourceEffectiveBalance;
+      }
+
+      nextPendingConsolidation++;
+    }
+    chunkStartIndex += chunkSize;
+  }
+
+  state.pendingConsolidations = state.pendingConsolidations.sliceFrom(nextPendingConsolidation);
+}

package/src/epoch/processPendingDeposits.ts

@@ -0,0 +1,136 @@
+import {FAR_FUTURE_EPOCH, ForkSeq, GENESIS_SLOT, MAX_PENDING_DEPOSITS_PER_EPOCH} from "@lodestar/params";
+import {electra} from "@lodestar/types";
+import {addValidatorToRegistry, isValidDepositSignature} from "../block/processDeposit.js";
+import {CachedBeaconStateElectra, EpochTransitionCache} from "../types.js";
+import {increaseBalance} from "../util/balance.js";
+import {hasCompoundingWithdrawalCredential, isValidatorKnown} from "../util/electra.js";
+import {computeStartSlotAtEpoch} from "../util/epoch.js";
+import {getActivationExitChurnLimit} from "../util/validator.js";
+
+/**
+ * Starting from Electra:
+ * Process pending balance deposits from state subject to churn limit and depositBalanceToConsume.
+ * For each eligible `deposit`, call `increaseBalance()`.
+ * Remove the processed deposits from `state.pendingDeposits`.
+ * Update `state.depositBalanceToConsume` for the next epoch
+ *
+ * TODO Electra: Update ssz library to support batch push to `pendingDeposits`
+ */
+export function processPendingDeposits(state: CachedBeaconStateElectra, cache: EpochTransitionCache): void {
+  const nextEpoch = state.epochCtx.epoch + 1;
+  const availableForProcessing = state.depositBalanceToConsume + BigInt(getActivationExitChurnLimit(state.epochCtx));
+  let processedAmount = 0;
+  let nextDepositIndex = 0;
+  const depositsToPostpone = [];
+  let isChurnLimitReached = false;
+  const finalizedSlot = computeStartSlotAtEpoch(state.finalizedCheckpoint.epoch);
+
+  let startIndex = 0;
+  // TODO: is this a good number?
+  const chunk = 100;
+  const pendingDepositsLength = state.pendingDeposits.length;
+  outer: while (startIndex < pendingDepositsLength) {
+    const deposits = state.pendingDeposits.getReadonlyByRange(startIndex, chunk);
+
+    for (const deposit of deposits) {
+      // Do not process deposit requests if Eth1 bridge deposits are not yet applied.
+      if (
+        // Is deposit request
+        deposit.slot > GENESIS_SLOT &&
+        // There are pending Eth1 bridge deposits
+        state.eth1DepositIndex < state.depositRequestsStartIndex
+      ) {
+        break outer;
+      }
+
+      // Check if deposit has been finalized, otherwise, stop processing.
+      if (deposit.slot > finalizedSlot) {
+        break outer;
+      }
+
+      // Check if number of processed deposits has not reached the limit, otherwise, stop processing.
+      if (nextDepositIndex >= MAX_PENDING_DEPOSITS_PER_EPOCH) {
+        break outer;
+      }
+
+      // Read validator state
+      let isValidatorExited = false;
+      let isValidatorWithdrawn = false;
+
+      const validatorIndex = state.epochCtx.getValidatorIndex(deposit.pubkey);
+      if (isValidatorKnown(state, validatorIndex)) {
+        const validator = state.validators.getReadonly(validatorIndex);
+        isValidatorExited = validator.exitEpoch < FAR_FUTURE_EPOCH;
+        isValidatorWithdrawn = validator.withdrawableEpoch < nextEpoch;
+      }
+
+      if (isValidatorWithdrawn) {
+        // Deposited balance will never become active. Increase balance but do not consume churn
+        applyPendingDeposit(state, deposit, cache);
+      } else if (isValidatorExited) {
+        // Validator is exiting, postpone the deposit until after withdrawable epoch
+        depositsToPostpone.push(deposit);
+      } else {
+        // Check if deposit fits in the churn, otherwise, do no more deposit processing in this epoch.
+        isChurnLimitReached = processedAmount + deposit.amount > availableForProcessing;
+        if (isChurnLimitReached) {
+          break outer;
+        }
+        // Consume churn and apply deposit.
+        processedAmount += deposit.amount;
+        applyPendingDeposit(state, deposit, cache);
+      }
+
+      // Regardless of how the deposit was handled, we move on in the queue.
+      nextDepositIndex++;
+    }
+
+    startIndex += chunk;
+  }
+
+  const remainingPendingDeposits = state.pendingDeposits.sliceFrom(nextDepositIndex);
+  state.pendingDeposits = remainingPendingDeposits;
+
+  // TODO Electra: add a function in ListCompositeTreeView to support batch push operation
+  for (const deposit of depositsToPostpone) {
+    state.pendingDeposits.push(deposit);
+  }
+
+  // Accumulate churn only if the churn limit has been hit.
+  if (isChurnLimitReached) {
+    state.depositBalanceToConsume = availableForProcessing - BigInt(processedAmount);
+  } else {
+    state.depositBalanceToConsume = 0n;
+  }
+}
+
+function applyPendingDeposit(
+  state: CachedBeaconStateElectra,
+  deposit: electra.PendingDeposit,
+  cache: EpochTransitionCache
+): void {
+  const validatorIndex = state.epochCtx.getValidatorIndex(deposit.pubkey);
+  const {pubkey, withdrawalCredentials, amount, signature} = deposit;
+  const cachedBalances = cache.balances;
+
+  if (!isValidatorKnown(state, validatorIndex)) {
+    // Verify the deposit signature (proof of possession) which is not checked by the deposit contract
+    if (isValidDepositSignature(state.config, pubkey, withdrawalCredentials, amount, signature)) {
+      addValidatorToRegistry(ForkSeq.electra, state, pubkey, withdrawalCredentials, amount);
+      const newValidatorIndex = state.validators.length - 1;
+      cache.isCompoundingValidatorArr[newValidatorIndex] = hasCompoundingWithdrawalCredential(withdrawalCredentials);
+      // set balance, so that the next deposit of same pubkey will increase the balance correctly
+      // this is to fix the double deposit issue found in mekong
+      // see https://github.com/ChainSafe/lodestar/pull/7255
+      if (cachedBalances) {
+        cachedBalances[newValidatorIndex] = amount;
+      }
+    }
+  } else {
+    // Increase balance
+    increaseBalance(state, validatorIndex, amount);
+    if (cachedBalances) {
+      cachedBalances[validatorIndex] += amount;
+    }
+  }
+}

package/src/epoch/processProposerLookahead.ts

@@ -0,0 +1,39 @@
+import {ForkSeq, MIN_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+import {CachedBeaconStateFulu, EpochTransitionCache} from "../types.js";
+import {computeEpochShuffling} from "../util/epochShuffling.js";
+import {computeProposerIndices} from "../util/seed.js";
+
+/**
+ * This function updates the `proposer_lookahead` field in the beacon state
+ * by shifting out proposer indices from the earliest epoch and appending new
+ * proposer indices for the latest epoch. With `MIN_SEED_LOOKAHEAD` set to `1`,
+ * this means that at the start of epoch `N`, the proposer lookahead for epoch
+ * `N+1` will be computed and included in the beacon state's lookahead.
+ */
+export function processProposerLookahead(
+  fork: ForkSeq,
+  state: CachedBeaconStateFulu,
+  cache: EpochTransitionCache
+): void {
+  // Shift out proposers in the first epoch
+  const remainingProposerLookahead = state.proposerLookahead.getAll().slice(SLOTS_PER_EPOCH);
+
+  // 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 lastEpochProposerLookahead = computeProposerIndices(fork, state, shuffling, epoch);
+
+  state.proposerLookahead = ssz.fulu.ProposerLookahead.toViewDU([
+    ...remainingProposerLookahead,
+    ...lastEpochProposerLookahead,
+  ]);
+}

package/src/epoch/processRandaoMixesReset.ts

@@ -0,0 +1,18 @@
+import {EPOCHS_PER_HISTORICAL_VECTOR} from "@lodestar/params";
+import {CachedBeaconStateAllForks, EpochTransitionCache} from "../types.js";
+
+/**
+ * Write next randaoMix
+ *
+ * PERF: Almost no (constant) cost
+ */
+export function processRandaoMixesReset(state: CachedBeaconStateAllForks, cache: EpochTransitionCache): void {
+  const currentEpoch = cache.currentEpoch;
+  const nextEpoch = currentEpoch + 1;
+
+  // set randao mix
+  state.randaoMixes.set(
+    nextEpoch % EPOCHS_PER_HISTORICAL_VECTOR,
+    state.randaoMixes.get(currentEpoch % EPOCHS_PER_HISTORICAL_VECTOR)
+  );
+}

package/src/epoch/processRegistryUpdates.ts

@@ -0,0 +1,65 @@
+import {ForkSeq} from "@lodestar/params";
+import {initiateValidatorExit} from "../block/index.js";
+import {CachedBeaconStateAllForks, EpochTransitionCache} from "../types.js";
+import {computeActivationExitEpoch} from "../util/index.js";
+
+/**
+ * Update validator registry for validators that activate + exit
+ *
+ * PERF: Cost 'proportional' to only validators that active + exit. For mainnet conditions:
+ * - indicesEligibleForActivationQueue: Maxing deposits triggers 512 validator mutations
+ * - indicesEligibleForActivation: 4 per epoch
+ * - indicesToEject: Potentially the entire validator set. On a massive offline event this could trigger many mutations
+ *   per epoch. Note that once mutated that validator can't be added to indicesToEject.
+ *
+ * - On normal mainnet conditions only 4 validators will be updated
+ *   - indicesEligibleForActivation: ~4000
+ *   - indicesEligibleForActivationQueue: 0
+ *   - indicesToEject: 0
+ */
+export function processRegistryUpdates(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  cache: EpochTransitionCache
+): void {
+  const {epochCtx} = state;
+
+  // Get the validators sub tree once for all the loop
+  const validators = state.validators;
+
+  // TODO: Batch set this properties in the tree at once with setMany() or setNodes()
+
+  // process ejections
+  for (const index of cache.indicesToEject) {
+    // set validator exit epoch and withdrawable epoch
+    // TODO: Figure out a way to quickly set properties on the validators tree
+    initiateValidatorExit(fork, state, validators.get(index));
+  }
+
+  // set new activation eligibilities
+  for (const index of cache.indicesEligibleForActivationQueue) {
+    validators.get(index).activationEligibilityEpoch = epochCtx.epoch + 1;
+  }
+
+  const finalityEpoch = state.finalizedCheckpoint.epoch;
+  // this avoids an array allocation compared to `slice(0, epochCtx.activationChurnLimit)`
+  const len =
+    fork < ForkSeq.electra
+      ? Math.min(cache.indicesEligibleForActivation.length, epochCtx.activationChurnLimit)
+      : cache.indicesEligibleForActivation.length;
+  const activationEpoch = computeActivationExitEpoch(cache.currentEpoch);
+  // dequeue validators for activation up to churn limit
+  for (let i = 0; i < len; i++) {
+    const validatorIndex = cache.indicesEligibleForActivation[i];
+    const validator = validators.get(validatorIndex);
+    // placement in queue is finalized
+    if (validator.activationEligibilityEpoch > finalityEpoch) {
+      // remaining validators all have an activationEligibilityEpoch that is higher anyway, break early
+      // activationEligibilityEpoch has been sorted in epoch process in ascending order.
+      // At that point the finalityEpoch was not known because processJustificationAndFinalization() wasn't called yet.
+      // So we need to filter by finalityEpoch here to comply with the spec.
+      break;
+    }
+    validator.activationEpoch = activationEpoch;
+  }
+}

package/src/epoch/processRewardsAndPenalties.ts

@@ -0,0 +1,58 @@
+import {ForkSeq, GENESIS_EPOCH} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+import {
+  CachedBeaconStateAllForks,
+  CachedBeaconStateAltair,
+  CachedBeaconStatePhase0,
+  EpochTransitionCache,
+} from "../types.js";
+import {getAttestationDeltas} from "./getAttestationDeltas.js";
+import {getRewardsAndPenaltiesAltair} from "./getRewardsAndPenalties.js";
+
+/**
+ * This data is reused and never gc.
+ */
+const balances = new Array<number>();
+/**
+ * Iterate over all validator and compute rewards and penalties to apply to balances.
+ *
+ * PERF: Cost = 'proportional' to $VALIDATOR_COUNT. Extra work is done per validator the more status flags are set
+ */
+export function processRewardsAndPenalties(
+  state: CachedBeaconStateAllForks,
+  cache: EpochTransitionCache,
+  slashingPenalties: number[] = []
+): void {
+  // No rewards are applied at the end of `GENESIS_EPOCH` because rewards are for work done in the previous epoch
+  if (cache.currentEpoch === GENESIS_EPOCH) {
+    return;
+  }
+
+  const [rewards, penalties] = getRewardsAndPenalties(state, cache);
+  balances.length = state.balances.length;
+  state.balances.getAll(balances);
+
+  for (let i = 0, len = rewards.length; i < len; i++) {
+    const result = balances[i] + rewards[i] - penalties[i] - (slashingPenalties[i] ?? 0);
+    balances[i] = Math.max(result, 0);
+  }
+
+  // important: do not change state one balance at a time. Set them all at once, constructing the tree in one go
+  // cache the balances array, too
+  state.balances = ssz.phase0.Balances.toViewDU(balances);
+
+  // For processEffectiveBalanceUpdates() to prevent having to re-compute the balances array.
+  // For validator metrics
+  cache.balances = balances;
+}
+
+// Note: abstracted in separate function for easier spec tests
+export function getRewardsAndPenalties(
+  state: CachedBeaconStateAllForks,
+  epochTransitionCache: EpochTransitionCache
+): [number[], number[]] {
+  const fork = state.config.getForkSeq(state.slot);
+  return fork === ForkSeq.phase0
+    ? getAttestationDeltas(state as CachedBeaconStatePhase0, epochTransitionCache)
+    : getRewardsAndPenaltiesAltair(state as CachedBeaconStateAltair, epochTransitionCache);
+}

package/src/epoch/processSlashings.ts

@@ -0,0 +1,97 @@
+import {
+  EFFECTIVE_BALANCE_INCREMENT,
+  ForkSeq,
+  PROPORTIONAL_SLASHING_MULTIPLIER,
+  PROPORTIONAL_SLASHING_MULTIPLIER_ALTAIR,
+  PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX,
+} from "@lodestar/params";
+import {BeaconStateAllForks, CachedBeaconStateAllForks, EpochTransitionCache} from "../types.js";
+import {decreaseBalance} from "../util/index.js";
+
+/**
+ * Update validator registry for validators that activate + exit
+ * updateBalance is an optimization:
+ * - For spec test, it's true
+ * - For processEpoch flow, it's false, i.e to only update balances once in processRewardsAndPenalties()
+ *
+ * PERF: almost no (constant) cost.
+ * - Total slashings by increment is computed once and stored in state.epochCtx.totalSlashingsByIncrement so no need to compute here
+ * - Penalties for validators with the same effective balance are the same and computed once
+ * - No need to apply penalties to validators here, do it once in processRewardsAndPenalties()
+ * - indicesToSlash: max len is 8704. But it's very unlikely since it would require all validators on the same
+ *   committees to sign slashable attestations.
+ * - On normal mainnet conditions indicesToSlash = 0
+ *
+ * @returns slashing penalties to be applied in processRewardsAndPenalties()
+ */
+export function processSlashings(
+  state: CachedBeaconStateAllForks,
+  cache: EpochTransitionCache,
+  updateBalance = true
+): number[] {
+  // Return early if there no index to slash
+  if (cache.indicesToSlash.length === 0) {
+    return [];
+  }
+
+  const totalBalanceByIncrement = cache.totalActiveStakeByIncrement;
+  const fork = state.config.getForkSeq(state.slot);
+  const proportionalSlashingMultiplier =
+    fork === ForkSeq.phase0
+      ? PROPORTIONAL_SLASHING_MULTIPLIER
+      : fork === ForkSeq.altair
+        ? PROPORTIONAL_SLASHING_MULTIPLIER_ALTAIR
+        : PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX;
+
+  const {effectiveBalanceIncrements} = state.epochCtx;
+  const adjustedTotalSlashingBalanceByIncrement = Math.min(
+    state.epochCtx.totalSlashingsByIncrement * proportionalSlashingMultiplier,
+    totalBalanceByIncrement
+  );
+  const increment = EFFECTIVE_BALANCE_INCREMENT;
+
+  const penaltyPerEffectiveBalanceIncrement = Math.floor(
+    (adjustedTotalSlashingBalanceByIncrement * increment) / totalBalanceByIncrement
+  );
+  const penalties: number[] = [];
+
+  const penaltiesByEffectiveBalanceIncrement = new Map<number, number>();
+  for (const index of cache.indicesToSlash) {
+    const effectiveBalanceIncrement = effectiveBalanceIncrements[index];
+    let penalty = penaltiesByEffectiveBalanceIncrement.get(effectiveBalanceIncrement);
+    if (penalty === undefined) {
+      if (fork < ForkSeq.electra) {
+        const penaltyNumeratorByIncrement = effectiveBalanceIncrement * adjustedTotalSlashingBalanceByIncrement;
+        penalty = Math.floor(penaltyNumeratorByIncrement / totalBalanceByIncrement) * increment;
+      } else {
+        penalty = penaltyPerEffectiveBalanceIncrement * effectiveBalanceIncrement;
+      }
+      penaltiesByEffectiveBalanceIncrement.set(effectiveBalanceIncrement, penalty);
+    }
+
+    if (updateBalance) {
+      // for spec test only
+      decreaseBalance(state, index, penalty);
+    } else {
+      // do it later in processRewardsAndPenalties()
+      penalties[index] = penalty;
+    }
+  }
+
+  return penalties;
+}
+
+/**
+ * Get total slashings by increment.
+ * By default, total slashings are computed every time we run processSlashings() function above.
+ * We improve it by computing it once and store it in state.epochCtx.totalSlashingsByIncrement
+ * Every change to state.slashings should update totalSlashingsByIncrement.
+ */
+export function getTotalSlashingsByIncrement(state: BeaconStateAllForks): number {
+  let totalSlashingsByIncrement = 0;
+  const slashings = state.slashings.getAll();
+  for (let i = 0; i < slashings.length; i++) {
+    totalSlashingsByIncrement += Math.floor(slashings[i] / EFFECTIVE_BALANCE_INCREMENT);
+  }
+  return totalSlashingsByIncrement;
+}

package/src/epoch/processSlashingsReset.ts

@@ -0,0 +1,20 @@
+import {EFFECTIVE_BALANCE_INCREMENT, EPOCHS_PER_SLASHINGS_VECTOR} from "@lodestar/params";
+import {CachedBeaconStateAllForks, EpochTransitionCache} from "../types.js";
+
+/**
+ * Reset the next slashings balance accumulator
+ *
+ * PERF: Almost no (constant) cost
+ */
+export function processSlashingsReset(state: CachedBeaconStateAllForks, cache: EpochTransitionCache): void {
+  const nextEpoch = cache.currentEpoch + 1;
+
+  // reset slashings
+  const slashIndex = nextEpoch % EPOCHS_PER_SLASHINGS_VECTOR;
+  const oldSlashingValueByIncrement = Math.floor(state.slashings.get(slashIndex) / EFFECTIVE_BALANCE_INCREMENT);
+  state.slashings.set(slashIndex, 0);
+  state.epochCtx.totalSlashingsByIncrement = Math.max(
+    0,
+    state.epochCtx.totalSlashingsByIncrement - oldSlashingValueByIncrement
+  );
+}

package/src/epoch/processSyncCommitteeUpdates.ts

@@ -0,0 +1,44 @@
+import {aggregateSerializedPublicKeys} from "@chainsafe/blst";
+import {EPOCHS_PER_SYNC_COMMITTEE_PERIOD, ForkSeq} from "@lodestar/params";
+import {ssz} from "@lodestar/types";
+import {CachedBeaconStateAltair} from "../types.js";
+import {getNextSyncCommitteeIndices} from "../util/seed.js";
+
+/**
+ * Rotate nextSyncCommittee to currentSyncCommittee if sync committee period is over.
+ *
+ * PERF: Once every `EPOCHS_PER_SYNC_COMMITTEE_PERIOD`, do an expensive operation to compute the next committee.
+ * Calculating the next sync committee has a proportional cost to $VALIDATOR_COUNT
+ */
+export function processSyncCommitteeUpdates(fork: ForkSeq, state: CachedBeaconStateAltair): void {
+  const nextEpoch = state.epochCtx.epoch + 1;
+
+  if (nextEpoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD === 0) {
+    const activeValidatorIndices = state.epochCtx.nextActiveIndices;
+    const {effectiveBalanceIncrements} = state.epochCtx;
+
+    const nextSyncCommitteeIndices = getNextSyncCommitteeIndices(
+      fork,
+      state,
+      activeValidatorIndices,
+      effectiveBalanceIncrements
+    );
+    const validators = state.validators;
+
+    // Using the index2pubkey cache is slower because it needs the serialized pubkey.
+    const nextSyncCommitteePubkeys = [];
+    for (const index of nextSyncCommitteeIndices) {
+      nextSyncCommitteePubkeys.push(validators.getReadonly(index).pubkey);
+    }
+
+    // Rotate syncCommittee in state
+    state.currentSyncCommittee = state.nextSyncCommittee;
+    state.nextSyncCommittee = ssz.altair.SyncCommittee.toViewDU({
+      pubkeys: nextSyncCommitteePubkeys,
+      aggregatePubkey: aggregateSerializedPublicKeys(nextSyncCommitteePubkeys).toBytes(),
+    });
+
+    // Rotate syncCommittee cache
+    state.epochCtx.rotateSyncCommitteeIndexed(nextSyncCommitteeIndices);
+  }
+}