@lodestar/state-transition 1.46.0-dev.b22e48117e → 1.46.0-dev.b9d4e89e49

package/src/cache/stateCache.ts

@@ -13,6 +13,7 @@ import {
   BeaconStateExecutions,
   BeaconStateFulu,
   BeaconStateGloas,
+  BeaconStateHeze,
   BeaconStatePhase0,
 } from "./types.js";
 
@@ -137,6 +138,7 @@ export type CachedBeaconStateDeneb = CachedBeaconState<BeaconStateDeneb>;
 export type CachedBeaconStateElectra = CachedBeaconState<BeaconStateElectra>;
 export type CachedBeaconStateFulu = CachedBeaconState<BeaconStateFulu>;
 export type CachedBeaconStateGloas = CachedBeaconState<BeaconStateGloas>;
+export type CachedBeaconStateHeze = CachedBeaconState<BeaconStateHeze>;
 
 export type CachedBeaconStateAllForks = CachedBeaconState<BeaconStateAllForks>;
 export type CachedBeaconStateExecutions = CachedBeaconState<BeaconStateExecutions>;

package/src/cache/types.ts

@@ -11,6 +11,7 @@ export type BeaconStateDeneb = CompositeViewDU<SSZTypesFor<ForkName.deneb, "Beac
 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 BeaconStateHeze = CompositeViewDU<SSZTypesFor<ForkName.heze, "BeaconState">>;
 
 export type BeaconStateAllForks = CompositeViewDU<SSZTypesFor<ForkAll, "BeaconState">>;
 export type BeaconStateExecutions = CompositeViewDU<SSZTypesFor<ForkPostBellatrix & ForkPreGloas, "BeaconState">>;

package/src/index.ts

@@ -52,6 +52,7 @@ export {
   type IBeaconStateViewElectra,
   type IBeaconStateViewFulu,
   type IBeaconStateViewGloas,
+  type IBeaconStateViewHeze,
   isStatePostAltair,
   isStatePostBellatrix,
   isStatePostCapella,
@@ -59,6 +60,7 @@ export {
   isStatePostElectra,
   isStatePostFulu,
   isStatePostGloas,
+  isStatePostHeze,
 } from "./stateView/interface.js";
 export {createBeaconStateView, createBeaconStateViewForHistoricalRegen} from "./stateView/stateViewFactory.js";
 export type {
@@ -71,6 +73,7 @@ export type {
   BeaconStateExecutions,
   BeaconStateFulu,
   BeaconStateGloas,
+  BeaconStateHeze,
   // Non-cached states
   BeaconStatePhase0,
   CachedBeaconStateAllForks,
@@ -82,6 +85,7 @@ export type {
   CachedBeaconStateExecutions,
   CachedBeaconStateFulu,
   CachedBeaconStateGloas,
+  CachedBeaconStateHeze,
   CachedBeaconStatePhase0,
 } from "./types.js";
 export * from "./util/index.js";

package/src/lightClient/spec/utils.ts

@@ -263,6 +263,7 @@ export function upgradeLightClientHeader(
       // Break if no further upgrades is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.fulu) break;
 
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
     case ForkName.gloas:
       if (isGloasLightClientHeader(upgradedHeader)) {
         break;
@@ -272,6 +273,12 @@ export function upgradeLightClientHeader(
 
       // Break if no further upgrades is required else fall through
       if (ForkSeq[targetFork] <= ForkSeq.gloas) break;
+
+    case ForkName.heze:
+      // No changes to LightClientHeader in Heze
+
+      // Break if no further upgrades is required else fall through
+      if (ForkSeq[targetFork] <= ForkSeq.heze) break;
   }
   return upgradedHeader;
 }

package/src/signatureSets/executionPayloadBid.ts

@@ -1,14 +1,12 @@
 import {BeaconConfig} from "@lodestar/config";
-import {DOMAIN_BEACON_BUILDER} from "@lodestar/params";
-import {Slot, gloas, ssz} from "@lodestar/types";
+import {DOMAIN_BEACON_BUILDER, isForkPostGloas} from "@lodestar/params";
+import {ExecutionPayloadBid, ssz, sszTypesFor} from "@lodestar/types";
 import {computeSigningRoot} from "../util/index.js";
 
-export function getExecutionPayloadBidSigningRoot(
-  config: BeaconConfig,
-  stateSlot: Slot,
-  bid: gloas.ExecutionPayloadBid
-): Uint8Array {
-  const domain = config.getDomain(stateSlot, DOMAIN_BEACON_BUILDER);
+export function getExecutionPayloadBidSigningRoot(config: BeaconConfig, bid: ExecutionPayloadBid): Uint8Array {
+  const fork = config.getForkName(bid.slot);
+  const domain = config.getDomain(bid.slot, DOMAIN_BEACON_BUILDER);
+  const sszType = isForkPostGloas(fork) ? sszTypesFor(fork).ExecutionPayloadBid : ssz.gloas.ExecutionPayloadBid;
 
-  return computeSigningRoot(ssz.gloas.ExecutionPayloadBid, bid, domain);
+  return computeSigningRoot(sszType, bid, domain);
 }

package/src/slot/index.ts

@@ -10,6 +10,7 @@ export {upgradeStateToDeneb} from "./upgradeStateToDeneb.js";
 export {upgradeStateToElectra} from "./upgradeStateToElectra.js";
 export {upgradeStateToFulu} from "./upgradeStateToFulu.js";
 export {upgradeStateToGloas} from "./upgradeStateToGloas.js";
+export {upgradeStateToHeze} from "./upgradeStateToHeze.js";
 
 /**
  * Dial state to next slot. Common for all forks

package/src/slot/upgradeStateToHeze.ts

@@ -0,0 +1,91 @@
+import {ssz} from "@lodestar/types";
+import {getCachedBeaconState} from "../cache/stateCache.js";
+import {CachedBeaconStateGloas, CachedBeaconStateHeze} from "../types.js";
+
+/**
+ * Upgrade a state from Gloas to Heze.
+ * Spec: heze/fork.md `upgrade_to_heze`.
+ */
+export function upgradeStateToHeze(stateGloas: CachedBeaconStateGloas): CachedBeaconStateHeze {
+  const {config} = stateGloas;
+
+  ssz.gloas.BeaconState.commitViewDU(stateGloas);
+  const stateHezeCloned = stateGloas;
+
+  const stateHezeView = ssz.heze.BeaconState.defaultViewDU();
+
+  stateHezeView.genesisTime = stateHezeCloned.genesisTime;
+  stateHezeView.genesisValidatorsRoot = stateHezeCloned.genesisValidatorsRoot;
+  stateHezeView.slot = stateHezeCloned.slot;
+  stateHezeView.fork = ssz.phase0.Fork.toViewDU({
+    previousVersion: stateGloas.fork.currentVersion,
+    currentVersion: config.HEZE_FORK_VERSION,
+    epoch: stateGloas.epochCtx.epoch,
+  });
+  stateHezeView.latestBlockHeader = stateHezeCloned.latestBlockHeader;
+  stateHezeView.blockRoots = stateHezeCloned.blockRoots;
+  stateHezeView.stateRoots = stateHezeCloned.stateRoots;
+  stateHezeView.historicalRoots = stateHezeCloned.historicalRoots;
+  stateHezeView.eth1Data = stateHezeCloned.eth1Data;
+  stateHezeView.eth1DataVotes = stateHezeCloned.eth1DataVotes;
+  stateHezeView.eth1DepositIndex = stateHezeCloned.eth1DepositIndex;
+  stateHezeView.validators = stateHezeCloned.validators;
+  stateHezeView.balances = stateHezeCloned.balances;
+  stateHezeView.randaoMixes = stateHezeCloned.randaoMixes;
+  stateHezeView.slashings = stateHezeCloned.slashings;
+  stateHezeView.previousEpochParticipation = stateHezeCloned.previousEpochParticipation;
+  stateHezeView.currentEpochParticipation = stateHezeCloned.currentEpochParticipation;
+  stateHezeView.justificationBits = stateHezeCloned.justificationBits;
+  stateHezeView.previousJustifiedCheckpoint = stateHezeCloned.previousJustifiedCheckpoint;
+  stateHezeView.currentJustifiedCheckpoint = stateHezeCloned.currentJustifiedCheckpoint;
+  stateHezeView.finalizedCheckpoint = stateHezeCloned.finalizedCheckpoint;
+  stateHezeView.inactivityScores = stateHezeCloned.inactivityScores;
+  stateHezeView.currentSyncCommittee = stateHezeCloned.currentSyncCommittee;
+  stateHezeView.nextSyncCommittee = stateHezeCloned.nextSyncCommittee;
+  stateHezeView.latestBlockHash = stateHezeCloned.latestBlockHash;
+  stateHezeView.nextWithdrawalIndex = stateHezeCloned.nextWithdrawalIndex;
+  stateHezeView.nextWithdrawalValidatorIndex = stateHezeCloned.nextWithdrawalValidatorIndex;
+  stateHezeView.historicalSummaries = stateHezeCloned.historicalSummaries;
+  stateHezeView.depositRequestsStartIndex = stateHezeCloned.depositRequestsStartIndex;
+  stateHezeView.depositBalanceToConsume = stateHezeCloned.depositBalanceToConsume;
+  stateHezeView.exitBalanceToConsume = stateHezeCloned.exitBalanceToConsume;
+  stateHezeView.earliestExitEpoch = stateHezeCloned.earliestExitEpoch;
+  stateHezeView.consolidationBalanceToConsume = stateHezeCloned.consolidationBalanceToConsume;
+  stateHezeView.earliestConsolidationEpoch = stateHezeCloned.earliestConsolidationEpoch;
+  stateHezeView.pendingDeposits = stateHezeCloned.pendingDeposits;
+  stateHezeView.pendingPartialWithdrawals = stateHezeCloned.pendingPartialWithdrawals;
+  stateHezeView.pendingConsolidations = stateHezeCloned.pendingConsolidations;
+  stateHezeView.proposerLookahead = stateHezeCloned.proposerLookahead;
+  stateHezeView.builders = stateHezeCloned.builders;
+  stateHezeView.nextWithdrawalBuilderIndex = stateHezeCloned.nextWithdrawalBuilderIndex;
+  stateHezeView.executionPayloadAvailability = stateHezeCloned.executionPayloadAvailability;
+  stateHezeView.builderPendingPayments = stateHezeCloned.builderPendingPayments;
+  stateHezeView.builderPendingWithdrawals = stateHezeCloned.builderPendingWithdrawals;
+
+  // [Modified in Heze:EIP7805] inclusion_list_bits = Bitvector[INCLUSION_LIST_COMMITTEE_SIZE]() (default zero)
+  const oldBid = stateHezeCloned.latestExecutionPayloadBid;
+  const newBid = ssz.heze.ExecutionPayloadBid.defaultViewDU();
+  newBid.parentBlockHash = oldBid.parentBlockHash;
+  newBid.parentBlockRoot = oldBid.parentBlockRoot;
+  newBid.blockHash = oldBid.blockHash;
+  newBid.prevRandao = oldBid.prevRandao;
+  newBid.feeRecipient = oldBid.feeRecipient;
+  newBid.gasLimit = oldBid.gasLimit;
+  newBid.builderIndex = oldBid.builderIndex;
+  newBid.slot = oldBid.slot;
+  newBid.value = oldBid.value;
+  newBid.executionPayment = oldBid.executionPayment;
+  newBid.blobKzgCommitments = oldBid.blobKzgCommitments;
+  newBid.executionRequestsRoot = oldBid.executionRequestsRoot;
+  stateHezeView.latestExecutionPayloadBid = newBid;
+
+  stateHezeView.payloadExpectedWithdrawals = stateHezeCloned.payloadExpectedWithdrawals;
+  stateHezeView.ptcWindow = stateHezeCloned.ptcWindow;
+
+  const stateHeze = getCachedBeaconState(stateHezeView, stateGloas);
+  stateHeze.commit();
+  // biome-ignore lint/complexity/useLiteralKeys: It is a protected attribute
+  stateHeze["clearCache"]();
+
+  return stateHeze;
+}

package/src/stateTransition.ts

@@ -16,6 +16,7 @@ import {
   upgradeStateToDeneb,
   upgradeStateToElectra,
   upgradeStateToGloas,
+  upgradeStateToHeze,
 } from "./slot/index.js";
 import {upgradeStateToFulu} from "./slot/upgradeStateToFulu.js";
 import {
@@ -26,6 +27,7 @@ import {
   CachedBeaconStateDeneb,
   CachedBeaconStateElectra,
   CachedBeaconStateFulu,
+  CachedBeaconStateGloas,
   CachedBeaconStatePhase0,
 } from "./types.js";
 import {computeEpochAtSlot} from "./util/index.js";
@@ -278,6 +280,9 @@ function processSlotsWithTransientCache(
       if (stateEpoch === config.GLOAS_FORK_EPOCH) {
         postState = upgradeStateToGloas(postState as CachedBeaconStateFulu) as CachedBeaconStateAllForks;
       }
+      if (stateEpoch === config.HEZE_FORK_EPOCH) {
+        postState = upgradeStateToHeze(postState as CachedBeaconStateGloas) as CachedBeaconStateAllForks;
+      }
 
       {
         const timer = metrics?.epochTransitionStepTime.startTimer({step: EpochTransitionStep.finalProcessEpoch});

package/src/stateView/interface.ts

@@ -9,6 +9,7 @@ import {
   ForkPostElectra,
   ForkPostFulu,
   ForkPostGloas,
+  ForkPostHeze,
   isForkPostAltair,
   isForkPostBellatrix,
   isForkPostCapella,
@@ -16,6 +17,7 @@ import {
   isForkPostElectra,
   isForkPostFulu,
   isForkPostGloas,
+  isForkPostHeze,
 } from "@lodestar/params";
 import {
   BeaconBlock,
@@ -267,14 +269,19 @@ export interface IBeaconStateViewGloas extends IBeaconStateViewFulu {
   withParentPayloadApplied(executionRequests: gloas.ExecutionRequests): IBeaconStateViewGloas;
 }
 
+/** Heze+ state fields — use isStatePostHeze() guard */
+export interface IBeaconStateViewHeze extends IBeaconStateViewGloas {
+  forkName: ForkPostHeze;
+}
+
 /**
  * Type constraint for the concrete BeaconStateView class.
- * Requires all fields from the latest fork interface (IBeaconStateViewGloas) but keeps
+ * Requires all fields from the latest fork interface (IBeaconStateViewHeze) but keeps
  * forkName as ForkName since the class wraps any fork's state.
  * Sub-interfaces retain their narrowed forkName discriminants for caller-side type guards.
  */
 export type IBeaconStateViewLatestFork = Omit<
-  IBeaconStateViewGloas,
+  IBeaconStateViewHeze,
   "forkName" | "latestExecutionPayloadHeader" | "payloadBlockNumber"
 > & {
   forkName: ForkName;
@@ -337,3 +344,7 @@ export function isStatePostFulu(state: IBeaconStateView): state is IBeaconStateV
 export function isStatePostGloas(state: IBeaconStateView): state is IBeaconStateViewGloas {
   return isForkPostGloas(state.forkName);
 }
+
+export function isStatePostHeze(state: IBeaconStateView): state is IBeaconStateViewHeze {
+  return isForkPostHeze(state.forkName);
+}

package/src/testUtils/state.ts

@@ -54,7 +54,7 @@ export function generateState(opts?: TestBeaconState): BeaconStatePhase0 {
     eth1Data: {
       depositRoot: Buffer.alloc(32),
       blockHash: Buffer.alloc(32),
-      depositCount: 0,
+      depositCount: 0n,
     },
     eth1DataVotes: [],
     eth1DepositIndex: 0,

package/src/testUtils/util.ts

@@ -437,13 +437,13 @@ function buildPerformanceStatePhase0(pubkeysArg?: Uint8Array[]): phase0.BeaconSt
     historicalRoots: [],
     // Eth1
     eth1Data: {
-      depositCount: pubkeys.length,
+      depositCount: BigInt(pubkeys.length),
       depositRoot: fromHexString("0xcb1f89a924cfd31224823db5a41b1643f10faa7aedf231f1e28887f6ee98c047"),
       blockHash: fromHexString("0x701fb2869ce16d0f1d14f6705725adb0dec6799da29006dfc6fff83960298f21"),
     },
     // minus one so that inserting 1 from block works
     eth1DataVotes: newFilledArray(EPOCHS_PER_ETH1_VOTING_PERIOD * SLOTS_PER_EPOCH - 1, {
-      depositCount: 1,
+      depositCount: 1n,
       depositRoot: Buffer.alloc(32, 1),
       blockHash: Buffer.alloc(32, 1),
     }),

package/src/types.ts

@@ -10,6 +10,7 @@ export type {
   CachedBeaconStateExecutions,
   CachedBeaconStateFulu,
   CachedBeaconStateGloas,
+  CachedBeaconStateHeze,
   CachedBeaconStatePhase0,
 } from "./cache/stateCache.js";
 export type {
@@ -22,6 +23,7 @@ export type {
   BeaconStateExecutions,
   BeaconStateFulu,
   BeaconStateGloas,
+  BeaconStateHeze,
   BeaconStatePhase0,
   ShufflingGetter,
 } from "./cache/types.js";

package/src/util/deposit.ts

@@ -4,19 +4,21 @@ import {CachedBeaconStateAllForks, CachedBeaconStateElectra} from "../types.js";
 
 export function getEth1DepositCount(state: CachedBeaconStateAllForks, eth1Data?: phase0.Eth1Data): UintNum64 {
   const eth1DataToUse = eth1Data ?? state.eth1Data;
+  // Proposer can set any value, use in bigint until the result is bounded by MAX_DEPOSITS
+  const depositCount = eth1DataToUse.depositCount;
+  const eth1DepositIndex = BigInt(state.eth1DepositIndex);
+  const maxDeposits = BigInt(MAX_DEPOSITS);
   if (state.config.getForkSeq(state.slot) >= ForkSeq.electra) {
     const electraState = state as CachedBeaconStateElectra;
-    // eth1DataIndexLimit = min(UintNum64, UintBn64) can be safely casted as UintNum64
-    // since the result lies within upper and lower bound of UintNum64
-    const eth1DataIndexLimit: UintNum64 =
-      eth1DataToUse.depositCount < electraState.depositRequestsStartIndex
-        ? eth1DataToUse.depositCount
-        : Number(electraState.depositRequestsStartIndex);
+    const eth1DataIndexLimit =
+      depositCount < electraState.depositRequestsStartIndex ? depositCount : electraState.depositRequestsStartIndex;
 
-    if (state.eth1DepositIndex < eth1DataIndexLimit) {
-      return Math.min(MAX_DEPOSITS, eth1DataIndexLimit - state.eth1DepositIndex);
+    if (eth1DepositIndex < eth1DataIndexLimit) {
+      const available = eth1DataIndexLimit - eth1DepositIndex;
+      return Number(available < maxDeposits ? available : maxDeposits);
     }
     return 0;
   }
-  return Math.min(MAX_DEPOSITS, eth1DataToUse.depositCount - state.eth1DepositIndex);
+  const available = depositCount - eth1DepositIndex;
+  return Number(available < maxDeposits ? available : maxDeposits);
 }

package/src/util/genesis.ts

@@ -139,7 +139,7 @@ export function applyDeposits(
   const fullDepositDataRootArr = fullDepositDataRootList ? fullDepositDataRootList.getAllReadonlyValues() : null;
 
   if (fullDepositDataRootArr) {
-    const depositCount = state.eth1Data.depositCount;
+    const depositCount = Number(state.eth1Data.depositCount);
     for (let index = 0; index < depositCount; index++) {
       depositDataRootList.push(fullDepositDataRootArr[index]);
     }
@@ -160,7 +160,7 @@ export function applyDeposits(
       );
     }
 
-    state.eth1Data.depositCount += 1;
+    state.eth1Data.depositCount += 1n;
 
     const fork = config.getForkSeq(GENESIS_SLOT);
     processDeposit(fork, state, deposit);
@@ -334,6 +334,12 @@ export function initializeBeaconStateFromEth1(
     stateGloas.fork.currentVersion = config.GLOAS_FORK_VERSION;
   }
 
+  if (fork >= ForkSeq.heze) {
+    const stateHeze = state as CompositeViewDU<typeof ssz.heze.BeaconState>;
+    stateHeze.fork.previousVersion = config.HEZE_FORK_VERSION;
+    stateHeze.fork.currentVersion = config.HEZE_FORK_VERSION;
+  }
+
   state.commit();
 
   return state;

package/src/util/validator.ts

@@ -128,6 +128,23 @@ export function getConsolidationChurnLimit(fork: ForkSeq, epochCtx: EpochCache):
   return getBalanceChurnLimitFromCache(epochCtx) - getActivationExitChurnLimit(epochCtx);
 }
 
+// NOTE: duplicates the quotient/min choices in get{Exit,Activation,Consolidation}ChurnLimit.
+export function getGloasChurnLimits(
+  config: ChainForkConfig,
+  totalActiveBalanceIncrements: number
+): {exit: number; activation: number; consolidation: number} {
+  const exit = getBalanceChurnLimit(
+    totalActiveBalanceIncrements,
+    config.CHURN_LIMIT_QUOTIENT_GLOAS,
+    config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
+  );
+  return {
+    exit,
+    activation: Math.min(config.MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS, exit),
+    consolidation: getBalanceChurnLimit(totalActiveBalanceIncrements, config.CONSOLIDATION_CHURN_LIMIT_QUOTIENT, 0),
+  };
+}
+
 export function getMaxEffectiveBalance(withdrawalCredentials: Uint8Array): number {
   // Compounding withdrawal credential only available since Electra
   if (hasCompoundingWithdrawalCredential(withdrawalCredentials)) {

package/src/util/weakSubjectivity.ts

@@ -1,10 +1,12 @@
 import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
+  ForkSeq,
   MAX_DEPOSITS,
   MAX_EFFECTIVE_BALANCE,
   SLOTS_PER_EPOCH,
   isForkPostElectra,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {Epoch, Root, ssz} from "@lodestar/types";
 import {Checkpoint} from "@lodestar/types/phase0";
@@ -14,10 +16,14 @@ import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
 import {computeCheckpointEpochAtStateSlot, computeEpochAtSlot, getCurrentEpoch} from "./epoch.js";
 import {getCurrentSlot} from "./slot.js";
 import {
+  getActivationChurnLimit,
   getActiveValidatorIndices,
   getBalanceChurnLimit,
   getBalanceChurnLimitFromCache,
   getChurnLimit,
+  getConsolidationChurnLimit,
+  getExitChurnLimit,
+  getGloasChurnLimits,
 } from "./validator.js";
 
 export const ETH_TO_GWEI = 10 ** 9;
@@ -49,18 +55,26 @@ export function computeWeakSubjectivityPeriodCachedState(
   const activeValidatorCount = state.epochCtx.currentShuffling.activeIndices.length;
   const fork = config.getForkName(state.slot);
 
-  return isForkPostElectra(fork)
-    ? computeWeakSubjectivityPeriodFromConstituentsElectra(
+  return isForkPostGloas(fork)
+    ? computeWeakSubjectivityPeriodFromConstituentsGloas(
         state.epochCtx.totalActiveBalanceIncrements,
-        getBalanceChurnLimitFromCache(state.epochCtx),
+        getExitChurnLimit(state.epochCtx),
+        getActivationChurnLimit(state.epochCtx),
+        getConsolidationChurnLimit(ForkSeq.gloas, state.epochCtx),
         config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
       )
-    : computeWeakSubjectivityPeriodFromConstituentsPhase0(
-        activeValidatorCount,
-        state.epochCtx.totalActiveBalanceIncrements,
-        getChurnLimit(config, activeValidatorCount),
-        config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
-      );
+    : 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
+        );
 }
 
 /**
@@ -80,22 +94,32 @@ export function computeWeakSubjectivityPeriod(config: ChainForkConfig, state: Be
     totalActiveBalanceIncrements = 1;
   }
 
-  return isForkPostElectra(fork)
-    ? computeWeakSubjectivityPeriodFromConstituentsElectra(
+  const churnLimitsGloas = getGloasChurnLimits(config, totalActiveBalanceIncrements);
+
+  return isForkPostGloas(fork)
+    ? computeWeakSubjectivityPeriodFromConstituentsGloas(
         totalActiveBalanceIncrements,
-        getBalanceChurnLimit(
-          totalActiveBalanceIncrements,
-          config.CHURN_LIMIT_QUOTIENT,
-          config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
-        ),
+        churnLimitsGloas.exit,
+        churnLimitsGloas.activation,
+        churnLimitsGloas.consolidation,
         config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
       )
-    : computeWeakSubjectivityPeriodFromConstituentsPhase0(
-        activeIndices.length,
-        totalActiveBalanceIncrements,
-        getChurnLimit(config, activeIndices.length),
-        config.MIN_VALIDATOR_WITHDRAWABILITY_DELAY
-      );
+    : 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 computeWeakSubjectivityPeriodFromConstituentsPhase0(
@@ -142,6 +166,21 @@ export function computeWeakSubjectivityPeriodFromConstituentsElectra(
   return minWithdrawabilityDelay + epochsForValidatorSetChurn;
 }
 
+export function computeWeakSubjectivityPeriodFromConstituentsGloas(
+  totalBalanceByIncrement: number,
+  exitChurnLimit: number,
+  activationChurnLimit: number,
+  consolidationChurnLimit: number,
+  minWithdrawabilityDelay: number
+): number {
+  // Keep t as increment for now. Multiply final result by EFFECTIVE_BALANCE_INCREMENT
+  const t = totalBalanceByIncrement;
+  const delta = Math.floor((2 * exitChurnLimit) / 3) + Math.floor(activationChurnLimit / 3) + consolidationChurnLimit;
+  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)) {