feat: update weak subjectivity calculation for electra (#7735)

Related spec ~~ethereum/consensus-specs#4243~~
ethereum/consensus-specs#4179


Closes #7645

Author: ensi321

packages/state-transition/src/util/validator.ts

@@ -56,22 +56,34 @@ export function getChurnLimit(config: ChainForkConfig, activeValidatorCount: num
 /**
  * Get combined churn limit of activation-exit and consolidation
  */
-export function getBalanceChurnLimit(epochCtx: EpochCache): number {
+export function getBalanceChurnLimit(
+  totalActiveBalanceIncrements: number,
+  churnLimitQuotient: number,
+  minPerEpochChurnLimit: number
+): number {
   const churnLimitByTotalActiveBalance = Math.floor(
-    (epochCtx.totalActiveBalanceIncrements / epochCtx.config.CHURN_LIMIT_QUOTIENT) * EFFECTIVE_BALANCE_INCREMENT
-  ); // TODO Electra: verify calculation
+    (totalActiveBalanceIncrements / churnLimitQuotient) * EFFECTIVE_BALANCE_INCREMENT
+  );
 
-  const churn = Math.max(churnLimitByTotalActiveBalance, epochCtx.config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA);
+  const churn = Math.max(churnLimitByTotalActiveBalance, minPerEpochChurnLimit);
 
   return churn - (churn % EFFECTIVE_BALANCE_INCREMENT);
 }
 
+export function getBalanceChurnLimitFromCache(epochCtx: EpochCache): number {
+  return getBalanceChurnLimit(
+    epochCtx.totalActiveBalanceIncrements,
+    epochCtx.config.CHURN_LIMIT_QUOTIENT,
+    epochCtx.config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
+  );
+}
+
 export function getActivationExitChurnLimit(epochCtx: EpochCache): number {
-  return Math.min(epochCtx.config.MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT, getBalanceChurnLimit(epochCtx));
+  return Math.min(epochCtx.config.MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT, getBalanceChurnLimitFromCache(epochCtx));
 }
 
 export function getConsolidationChurnLimit(epochCtx: EpochCache): number {
-  return getBalanceChurnLimit(epochCtx) - getActivationExitChurnLimit(epochCtx);
+  return getBalanceChurnLimitFromCache(epochCtx) - getActivationExitChurnLimit(epochCtx);
 }
 
 export function getMaxEffectiveBalance(withdrawalCredentials: Uint8Array): number {

packages/state-transition/src/util/weakSubjectivity.ts

@@ -1,5 +1,11 @@
 import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
-import {EFFECTIVE_BALANCE_INCREMENT, MAX_DEPOSITS, MAX_EFFECTIVE_BALANCE, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {
+  EFFECTIVE_BALANCE_INCREMENT,
+  MAX_DEPOSITS,
+  MAX_EFFECTIVE_BALANCE,
+  SLOTS_PER_EPOCH,
+  isForkPostElectra,
+} from "@lodestar/params";
 import {Epoch, Root} from "@lodestar/types";
 import {ssz} from "@lodestar/types";
 import {Checkpoint} from "@lodestar/types/phase0";
@@ -8,7 +14,12 @@ import {ZERO_HASH} from "../constants/constants.js";
 import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
 import {computeCheckpointEpochAtStateSlot, computeEpochAtSlot, getCurrentEpoch} from "./epoch.js";
 import {getCurrentSlot} from "./slot.js";
-import {getActiveValidatorIndices, getChurnLimit} from "./validator.js";
+import {
+  getActiveValidatorIndices,
+  getBalanceChurnLimit,
+  getBalanceChurnLimitFromCache,
+  getChurnLimit,
+} from "./validator.js";
 
 export const ETH_TO_GWEI = 10 ** 9;
 const SAFETY_DECAY = 10;
@@ -37,12 +48,20 @@ export function computeWeakSubjectivityPeriodCachedState(
   state: CachedBeaconStateAllForks
 ): number {
   const activeValidatorCount = state.epochCtx.currentShuffling.activeIndices.length;
-  return computeWeakSubjectivityPeriodFromConstituents(
-    activeValidatorCount,
-    state.epochCtx.totalActiveBalanceIncrements,
-    getChurnLimit(config, activeValidatorCount),
-    config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
-  );
+  const fork = state.config.getForkName(state.slot);
+
+  return isForkPostElectra(fork)
+    ? computeWeakSubjectivityPeriodFromConstituentsElectra(
+        state.epochCtx.totalActiveBalanceIncrements,
+        getBalanceChurnLimitFromCache(state.epochCtx),
+        config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+      )
+    : computeWeakSubjectivityPeriodFromConstituentsPhase0(
+        activeValidatorCount,
+        state.epochCtx.totalActiveBalanceIncrements,
+        getChurnLimit(config, activeValidatorCount),
+        config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+      );
 }
 
 /**
@@ -52,22 +71,35 @@ export function computeWeakSubjectivityPeriodCachedState(
 export function computeWeakSubjectivityPeriod(config: ChainForkConfig, state: BeaconStateAllForks): number {
   const activeIndices = getActiveValidatorIndices(state, getCurrentEpoch(state));
   const validators = state.validators.getAllReadonlyValues();
+  const fork = config.getForkName(state.slot);
+
   let totalActiveBalanceIncrements = 0;
   for (const index of activeIndices) {
     totalActiveBalanceIncrements += Math.floor(validators[index].effectiveBalance / EFFECTIVE_BALANCE_INCREMENT);
   }
   if (totalActiveBalanceIncrements <= 1) {
     totalActiveBalanceIncrements = 1;
   }
-  return computeWeakSubjectivityPeriodFromConstituents(
-    activeIndices.length,
-    totalActiveBalanceIncrements,
-    getChurnLimit(config, activeIndices.length),
-    config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
-  );
+
+  return isForkPostElectra(fork)
+    ? computeWeakSubjectivityPeriodFromConstituentsElectra(
+        totalActiveBalanceIncrements,
+        getBalanceChurnLimit(
+          totalActiveBalanceIncrements,
+          config.CHURN_LIMIT_QUOTIENT,
+          config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
+        ),
+        config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+      )
+    : computeWeakSubjectivityPeriodFromConstituentsPhase0(
+        activeIndices.length,
+        totalActiveBalanceIncrements,
+        getChurnLimit(config, activeIndices.length),
+        config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+      );
 }
 
-export function computeWeakSubjectivityPeriodFromConstituents(
+export function computeWeakSubjectivityPeriodFromConstituentsPhase0(
   activeValidatorCount: number,
   totalBalanceByIncrement: number,
   churnLimit: number,
@@ -97,6 +129,20 @@ export function computeWeakSubjectivityPeriodFromConstituents(
   return wsPeriod;
 }
 
+export function computeWeakSubjectivityPeriodFromConstituentsElectra(
+  totalBalanceByIncrement: number,
+  // Note this is not the same as churnLimit in `computeWeakSubjectivityPeriodFromConstituentsPhase0`
+  balanceChurnLimit: number,
+  minWithdrawabilityDelay: number
+): number {
+  // Keep t as increment for now. Multiply final result by EFFECTIVE_BALANCE_INCREMENT
+  const t = totalBalanceByIncrement;
+  const delta = balanceChurnLimit;
+  const epochsForValidatorSetChurn = Math.floor(((SAFETY_DECAY * t) / (2 * delta * 100)) * EFFECTIVE_BALANCE_INCREMENT);
+
+  return minWithdrawabilityDelay + epochsForValidatorSetChurn;
+}
+
 export function getLatestBlockRoot(state: BeaconStateAllForks): Root {
   const header = ssz.phase0.BeaconBlockHeader.clone(state.latestBlockHeader);
   if (ssz.Root.equals(header.stateRoot, ZERO_HASH)) {

packages/state-transition/test/unit/util/weakSubjectivity.test.ts

@@ -1,10 +1,13 @@
 import {config} from "@lodestar/config/default";
 import {describe, expect, it} from "vitest";
-import {getChurnLimit} from "../../../src/util/validator.js";
-import {computeWeakSubjectivityPeriodFromConstituents} from "../../../src/util/weakSubjectivity.js";
+import {getBalanceChurnLimit, getChurnLimit} from "../../../src/util/validator.js";
+import {
+  computeWeakSubjectivityPeriodFromConstituentsElectra,
+  computeWeakSubjectivityPeriodFromConstituentsPhase0,
+} from "../../../src/util/weakSubjectivity.js";
 
 describe("weak subjectivity tests", () => {
-  describe("computeWeakSubjectivityPeriodFromConstituents", () => {
+  describe("computeWeakSubjectivityPeriodFromConstituentsPhase0", () => {
     const balance28 = 28;
     const balance32 = 32;
 
@@ -25,14 +28,41 @@ describe("weak subjectivity tests", () => {
 
     it.each(testValues)(
       "should have wsPeriod: $wsPeriod with avgValBalance: $avgValBalance and valCount: $valCount",
-      ({valCount, avgValBalance}) => {
-        const wsPeriod = computeWeakSubjectivityPeriodFromConstituents(
+      ({valCount, avgValBalance, wsPeriod: expectedWsPeriod}) => {
+        const wsPeriod = computeWeakSubjectivityPeriodFromConstituentsPhase0(
           valCount,
           avgValBalance * valCount,
           getChurnLimit(config, valCount),
           config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
         );
-        expect(wsPeriod).toBe(wsPeriod);
+        expect(wsPeriod).toBe(expectedWsPeriod);
+      }
+    );
+  });
+  describe("computeWeakSubjectivityPeriodFromConstituentsElectra", () => {
+    // Values from https://github.com/ethereum/consensus-specs/blob/8ebb5e80862641287d7e8db2bbf69fa31612640b/specs/electra/weak-subjectivity.md#weak-subjectivity-period
+    const testValues = [
+      {totalBalanceIncrement: 1_048_576, wsPeriod: 665},
+      {totalBalanceIncrement: 2_097_152, wsPeriod: 1075},
+      {totalBalanceIncrement: 4_194_304, wsPeriod: 1894},
+      {totalBalanceIncrement: 8_388_608, wsPeriod: 3532},
+      {totalBalanceIncrement: 16_777_216, wsPeriod: 3532},
+      {totalBalanceIncrement: 33_554_432, wsPeriod: 3532},
+    ];
+
+    it.each(testValues)(
+      "should have wsPeriod: $wsPeriod with totalActiveBalance: $totalBalanceIncrement",
+      ({totalBalanceIncrement, wsPeriod: expectedWsPeriod}) => {
+        const wsPeriod = computeWeakSubjectivityPeriodFromConstituentsElectra(
+          totalBalanceIncrement,
+          getBalanceChurnLimit(
+            totalBalanceIncrement,
+            config.CHURN_LIMIT_QUOTIENT,
+            config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
+          ),
+          config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+        );
+        expect(wsPeriod).toBe(expectedWsPeriod);
       }
     );
   });