@lodestar/state-transition 1.50.1 → 1.51.0-dev.09763aa8d2

package/src/util/genesis.ts

@@ -11,11 +11,18 @@ import {
   UNSET_DEPOSIT_REQUESTS_START_INDEX,
 } from "@lodestar/params";
 import {Bytes32, Root, TimeSeconds, phase0, ssz} from "@lodestar/types";
-import {processDeposit} from "../block/processDeposit.js";
+import {applyDeposit, processDeposit} from "../block/processDeposit.js";
 import {EpochCacheImmutableData} from "../cache/epochCache.js";
 import {createCachedBeaconState} from "../cache/stateCache.js";
 import {increaseBalance} from "../index.js";
-import {BeaconStateAllForks, CachedBeaconStateAllForks, CachedBeaconStateElectra} from "../types.js";
+import {
+  BeaconStateAllForks,
+  BeaconStatePreHeze,
+  CachedBeaconStateAllForks,
+  CachedBeaconStateElectra,
+  CachedBeaconStateGloas,
+  CachedBeaconStatePreHeze,
+} from "../types.js";
 import {newFilledArray} from "./array.js";
 import {getTemporaryBlockHeader} from "./blockRoot.js";
 import {computeEpochAtSlot} from "./epoch.js";
@@ -87,7 +94,9 @@ export function getGenesisBeaconState(
   state.latestBlockHeader = ssz.phase0.BeaconBlockHeader.toViewDU(latestBlockHeader);
 
   // Ethereum 1.0 chain data
-  state.eth1Data = ssz.phase0.Eth1Data.toViewDU(genesisEth1Data);
+  if (config.getForkSeq(GENESIS_SLOT) < ForkSeq.heze) {
+    (state as BeaconStatePreHeze).eth1Data = ssz.phase0.Eth1Data.toViewDU(genesisEth1Data);
+  }
   state.randaoMixes = ssz.phase0.RandaoMixes.toViewDU(randaoMixes);
 
   return state;
@@ -100,7 +109,9 @@ export function getGenesisBeaconState(
  * @param eth1BlockHash eth1 block hash
  */
 export function applyEth1BlockHash(state: CachedBeaconStateAllForks, eth1BlockHash: Bytes32): void {
-  state.eth1Data.blockHash = eth1BlockHash;
+  if (state.config.getForkSeq(state.slot) < ForkSeq.heze) {
+    (state as CachedBeaconStatePreHeze).eth1Data.blockHash = eth1BlockHash;
+  }
   state.randaoMixes = ssz.phase0.RandaoMixes.toViewDU(newFilledArray(EPOCHS_PER_HISTORICAL_VECTOR, eth1BlockHash));
 }
 
@@ -134,36 +145,41 @@ export function applyDeposits(
   fullDepositDataRootList?: DepositDataRootViewDU
 ): {activatedValidatorCount: number} {
   const fork = config.getForkSeq(state.slot);
-  const depositDataRootList: Root[] = [];
-
-  const fullDepositDataRootArr = fullDepositDataRootList ? fullDepositDataRootList.getAllReadonlyValues() : null;
-
-  if (fullDepositDataRootArr) {
-    const depositCount = Number(state.eth1Data.depositCount);
-    for (let index = 0; index < depositCount; index++) {
-      depositDataRootList.push(fullDepositDataRootArr[index]);
+  if (fork >= ForkSeq.heze) {
+    // Genesis deposits do not use the removed legacy deposit tree.
+    for (const deposit of newDeposits) {
+      applyDeposit(fork, state, deposit.data);
     }
-  }
+  } else {
+    const statePreHeze = state as CachedBeaconStatePreHeze;
+    const depositDataRootList: Root[] = [];
+    const fullDepositDataRootArr = fullDepositDataRootList ? fullDepositDataRootList.getAllReadonlyValues() : null;
 
-  const initDepositCount = depositDataRootList.length;
-  const depositDatas = fullDepositDataRootList ? null : newDeposits.map((deposit) => deposit.data);
-  const {DepositData, DepositDataRootList} = ssz.phase0;
-
-  for (const [index, deposit] of newDeposits.entries()) {
     if (fullDepositDataRootArr) {
-      depositDataRootList.push(fullDepositDataRootArr[index + initDepositCount]);
-      state.eth1Data.depositRoot = DepositDataRootList.hashTreeRoot(depositDataRootList);
-    } else if (depositDatas) {
-      const depositDataList = depositDatas.slice(0, index + 1);
-      state.eth1Data.depositRoot = DepositDataRootList.hashTreeRoot(
-        depositDataList.map((d) => DepositData.hashTreeRoot(d))
-      );
+      const depositCount = Number(statePreHeze.eth1Data.depositCount);
+      for (let index = 0; index < depositCount; index++) {
+        depositDataRootList.push(fullDepositDataRootArr[index]);
+      }
     }
 
-    state.eth1Data.depositCount += 1n;
+    const initDepositCount = depositDataRootList.length;
+    const depositDatas = fullDepositDataRootList ? null : newDeposits.map((deposit) => deposit.data);
+    const {DepositData, DepositDataRootList} = ssz.phase0;
+
+    for (const [index, deposit] of newDeposits.entries()) {
+      if (fullDepositDataRootArr) {
+        depositDataRootList.push(fullDepositDataRootArr[index + initDepositCount]);
+        statePreHeze.eth1Data.depositRoot = DepositDataRootList.hashTreeRoot(depositDataRootList);
+      } else if (depositDatas) {
+        const depositDataList = depositDatas.slice(0, index + 1);
+        statePreHeze.eth1Data.depositRoot = DepositDataRootList.hashTreeRoot(
+          depositDataList.map((d) => DepositData.hashTreeRoot(d))
+        );
+      }
 
-    const fork = config.getForkSeq(GENESIS_SLOT);
-    processDeposit(fork, state, deposit);
+      statePreHeze.eth1Data.depositCount += 1n;
+      processDeposit(fork, statePreHeze, deposit);
+    }
   }
 
   // Process deposit balance updates
@@ -178,7 +194,11 @@ export function applyDeposits(
       }
       increaseBalance(state, validatorIndex, amount);
     }
-    stateElectra.pendingDeposits = ssz.electra.PendingDeposits.defaultViewDU();
+    if (fork >= ForkSeq.gloas) {
+      (state as CachedBeaconStateGloas).pendingDeposits = ssz.gloas.PendingDeposits.defaultViewDU();
+    } else {
+      stateElectra.pendingDeposits = ssz.electra.PendingDeposits.defaultViewDU();
+    }
   }
 
   // Process activations
@@ -316,7 +336,9 @@ export function initializeBeaconStateFromEth1(
     stateElectra.latestExecutionPayloadHeader =
       (executionPayloadHeader as CompositeViewDU<typeof ssz.electra.ExecutionPayloadHeader>) ??
       ssz.electra.ExecutionPayloadHeader.defaultViewDU();
-    stateElectra.depositRequestsStartIndex = UNSET_DEPOSIT_REQUESTS_START_INDEX;
+    if (fork < ForkSeq.heze) {
+      stateElectra.depositRequestsStartIndex = UNSET_DEPOSIT_REQUESTS_START_INDEX;
+    }
   }
 
   if (fork >= ForkSeq.fulu) {
@@ -326,6 +348,10 @@ export function initializeBeaconStateFromEth1(
     stateFulu.latestExecutionPayloadHeader =
       (executionPayloadHeader as CompositeViewDU<typeof ssz.fulu.ExecutionPayloadHeader>) ??
       ssz.fulu.ExecutionPayloadHeader.defaultViewDU();
+    if (fork < ForkSeq.heze) {
+      // Fulu retires the legacy bridge after the genesis deposits.
+      stateFulu.depositRequestsStartIndex = BigInt(stateFulu.eth1DepositIndex);
+    }
   }
 
   if (fork >= ForkSeq.gloas) {

package/src/util/inclusionListCommittee.ts

@@ -0,0 +1,17 @@
+import {ValidatorIndex} from "@lodestar/types";
+
+/** Spec `InclusionListCommittee` of one slot */
+export class InclusionListCommittee {
+  constructor(readonly validatorIndices: Uint32Array) {}
+
+  /** Positions of `validatorIndex`, several when the committee cycles over a slot with fewer validators than its size */
+  getCommitteeIndices(validatorIndex: ValidatorIndex): number[] {
+    const committeeIndices: number[] = [];
+    for (let i = 0; i < this.validatorIndices.length; i++) {
+      if (this.validatorIndices[i] === validatorIndex) {
+        committeeIndices.push(i);
+      }
+    }
+    return committeeIndices;
+  }
+}

package/src/util/index.ts

@@ -17,6 +17,7 @@ export * from "./execution.js";
 export * from "./finality.js";
 export * from "./genesis.js";
 export * from "./gloas.js";
+export * from "./inclusionListCommittee.js";
 export * from "./interop.js";
 export * from "./loadState/index.js";
 export * from "./pendingDepositsLookup.js";

package/src/util/interop.ts

@@ -1,6 +1,6 @@
 import {toBufferBE} from "@vekexasia/bigint-buffer2";
 import {digest} from "@chainsafe/as-sha256";
-import {SecretKey} from "@chainsafe/lodestar-z/blst";
+import {SecretKey} from "@lodestar/native/blst";
 import {bytesToBigInt, intToBytes} from "@lodestar/utils";
 
 let curveOrder: bigint;

package/src/util/seed.ts

@@ -3,7 +3,7 @@ import {
   computePtcIndicesForEpoch,
   computeProposerIndex as nativeComputeProposerIndex,
   computeSyncCommitteeIndices as nativeComputeSyncCommitteeIndices,
-} from "@chainsafe/lodestar-z/shuffle";
+} from "@lodestar/native/shuffle";
 import {
   DOMAIN_BEACON_PROPOSER,
   DOMAIN_PTC_ATTESTER,

package/src/util/shuffling.ts

@@ -1,4 +1,4 @@
-import {ForkName, ForkSeq, SLOTS_PER_EPOCH, isForkPostFulu} from "@lodestar/params";
+import {ForkName, ForkSeq, INCLUSION_LIST_COMMITTEE_SIZE, SLOTS_PER_EPOCH, isForkPostFulu} from "@lodestar/params";
 import {
   Attestation,
   CommitteeIndex,
@@ -15,6 +15,7 @@ import {IBeaconStateView} from "../stateView/interface.js";
 import {getBlockRootAtSlot} from "./blockRoot.js";
 import {computeStartSlotAtEpoch} from "./epoch.js";
 import {EpochShuffling} from "./epochShuffling.js";
+import {InclusionListCommittee} from "./inclusionListCommittee.js";
 
 /**
  * Block root that decided the proposer shuffling for `proposalEpoch` (keys that shuffling).
@@ -196,6 +197,50 @@ export function getBeaconCommittee(epochShuffling: EpochShuffling, slot: Slot, i
   return getBeaconCommittees(epochShuffling, slot, [index])[0];
 }
 
+/** Inclusion list committees of a shuffling by slot index, computed on first use and freed with the shuffling */
+// TODO HEZE: replace this module-level map with an extended EpochShuffling tracked by the beacon-node ShufflingCache
+const inclusionListCommitteesByShuffling = new WeakMap<EpochShuffling, InclusionListCommittee[]>();
+
+/** Spec get_inclusion_list_committee: cycle over the slot's concatenated beacon committees */
+export function getInclusionListCommittee(epochShuffling: EpochShuffling, slot: Slot): InclusionListCommittee {
+  let committees = inclusionListCommitteesByShuffling.get(epochShuffling);
+  if (committees === undefined) {
+    committees = [];
+    inclusionListCommitteesByShuffling.set(epochShuffling, committees);
+  }
+  const slotIndex = slot % SLOTS_PER_EPOCH;
+  let committee = committees[slotIndex];
+  if (committee === undefined) {
+    committee = new InclusionListCommittee(computeInclusionListCommittee(epochShuffling.committees[slotIndex]));
+    committees[slotIndex] = committee;
+  }
+  return committee;
+}
+
+function computeInclusionListCommittee(slotCommittees: Uint32Array[]): Uint32Array {
+  let totalLen = 0;
+  for (const committee of slotCommittees) {
+    totalLen += committee.length;
+  }
+
+  const result = new Uint32Array(INCLUSION_LIST_COMMITTEE_SIZE);
+  if (totalLen === 0) {
+    return result;
+  }
+
+  for (let i = 0; i < INCLUSION_LIST_COMMITTEE_SIZE; i++) {
+    let offset = i % totalLen;
+    for (const committee of slotCommittees) {
+      if (offset < committee.length) {
+        result[i] = committee[offset];
+        break;
+      }
+      offset -= committee.length;
+    }
+  }
+  return result;
+}
+
 /**
  * Return a Uint32Array[] representing committees validator indices
  */

package/src/util/signatureSets.ts

@@ -1,4 +1,4 @@
-import {BLS_VERIFIER_SET_TYPE, type BlsSignatureSet, verifySignatureSets} from "@chainsafe/lodestar-z/bls-verifier";
+import {BLS_VERIFIER_SET_TYPE, type BlsSignatureSet, verifySignatureSets} from "@lodestar/native/bls-verifier";
 import {Root} from "@lodestar/types";
 
 export enum SignatureSetType {

package/src/util/slot.ts

@@ -1,22 +1,92 @@
-import {ChainConfig} from "@lodestar/config";
-import {GENESIS_SLOT} from "@lodestar/params";
+import {ChainConfig, ChainForkConfig} from "@lodestar/config";
+import {GENESIS_EPOCH, GENESIS_SLOT} from "@lodestar/params";
 import {Epoch, Slot, TimeSeconds} from "@lodestar/types";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
 
+/**
+ * Slot durations with their activation epochs, derived from the configuration.
+ * A fork that changes the slot duration must add an entry here and in `ForkConfig.getSlotDurationMs`.
+ */
+export function getSlotDurations(config: ChainConfig): [Epoch, number][] {
+  const durations: [Epoch, number][] = [[GENESIS_EPOCH, config.SLOT_DURATION_MS]];
+  if (config.HEZE_FORK_EPOCH !== Infinity) {
+    durations.push([config.HEZE_FORK_EPOCH, config.SLOT_DURATION_MS_HEZE]);
+  }
+  return durations;
+}
+
+/** Slot duration in ms in effect at a given epoch */
+export function getSlotDurationMsAtEpoch(config: ChainConfig, epoch: Epoch): number {
+  let slotDurationMs = config.SLOT_DURATION_MS;
+  for (const [forkEpoch, forkSlotDurationMs] of getSlotDurations(config)) {
+    if (epoch >= forkEpoch) {
+      slotDurationMs = forkSlotDurationMs;
+    }
+  }
+  return slotDurationMs;
+}
+
+/** Slot duration in ms for a given slot */
+export function getSlotDurationMs(config: ChainForkConfig, slot: Slot): number {
+  return config.getSlotDurationMs(config.getForkName(slot));
+}
+
+export function computeTimeAtSlotMs(config: ChainConfig, slot: Slot, genesisTimeMs: number): number {
+  let endSlot = slot;
+  let timeMs = genesisTimeMs;
+  for (const [forkEpoch, slotDurationMs] of getSlotDurations(config).reverse()) {
+    const forkSlot = computeStartSlotAtEpoch(forkEpoch);
+    if (forkSlot < endSlot) {
+      timeMs += (endSlot - forkSlot) * slotDurationMs;
+      endSlot = forkSlot;
+    }
+  }
+  // Pre-genesis slots extrapolate linearly so the clock keeps ticking before genesis
+  return timeMs + (endSlot - GENESIS_SLOT) * getSlotDurationMsAtEpoch(config, GENESIS_EPOCH);
+}
+
+export function computeTimeAtSlot(config: ChainConfig, slot: Slot, genesisTime: TimeSeconds): TimeSeconds {
+  return computeTimeAtSlotMs(config, slot, genesisTime * 1000) / 1000;
+}
+
+export function computeSlotAtTimeMs(config: ChainConfig, timeMs: number, genesisTimeMs: number): Slot {
+  let startSlot = GENESIS_SLOT;
+  let startTimeMs = genesisTimeMs;
+  let slotDurationMs = getSlotDurationMsAtEpoch(config, GENESIS_EPOCH);
+  for (const [forkEpoch, forkSlotDurationMs] of getSlotDurations(config)) {
+    const forkSlot = computeStartSlotAtEpoch(forkEpoch);
+    const forkTimeMs = computeTimeAtSlotMs(config, forkSlot, genesisTimeMs);
+    if (timeMs >= forkTimeMs) {
+      startSlot = forkSlot;
+      startTimeMs = forkTimeMs;
+      slotDurationMs = forkSlotDurationMs;
+    }
+  }
+  return startSlot + Math.floor((timeMs - startTimeMs) / slotDurationMs);
+}
+
 export function getSlotsSinceGenesis(config: ChainConfig, genesisTime: TimeSeconds): Slot {
-  const diffInSeconds = Date.now() / 1000 - genesisTime;
-  return Math.floor(diffInSeconds / (config.SLOT_DURATION_MS / 1000));
+  return computeSlotAtTimeMs(config, Date.now(), genesisTime * 1000) - GENESIS_SLOT;
 }
 
 export function getCurrentSlot(config: ChainConfig, genesisTime: TimeSeconds): Slot {
   return GENESIS_SLOT + getSlotsSinceGenesis(config, genesisTime);
 }
 
+/**
+ * Start epoch of the blob data retention window, preserving its wall-clock length
+ * across slot duration changes
+ */
+export function getBlobDataRetentionStartEpoch(config: ChainConfig, epoch: Epoch): Epoch {
+  const windowMs = config.MIN_BLOB_DATA_RETENTION_MS;
+  const currentStartMs = computeTimeAtSlotMs(config, computeStartSlotAtEpoch(epoch), 0);
+  if (currentStartMs < windowMs) {
+    return GENESIS_EPOCH;
+  }
+  return computeEpochAtSlot(computeSlotAtTimeMs(config, currentStartMs - windowMs, 0));
+}
+
 export function computeSlotsSinceEpochStart(slot: Slot, epoch?: Epoch): Slot {
   const computeEpoch = epoch ?? computeEpochAtSlot(slot);
   return slot - computeStartSlotAtEpoch(computeEpoch);
 }
-
-export function computeTimeAtSlot(config: ChainConfig, slot: Slot, genesisTime: TimeSeconds): TimeSeconds {
-  return genesisTime + slot * (config.SLOT_DURATION_MS / 1000);
-}

package/src/util/syncCommittee.ts

@@ -1,18 +1,21 @@
-import {aggregateSerializedPublicKeys} from "@chainsafe/lodestar-z/blst";
+import {ChainConfig} from "@lodestar/config";
+import {aggregateSerializedPublicKeys} from "@lodestar/native/blst";
 import {
   BASE_REWARD_FACTOR,
   EFFECTIVE_BALANCE_INCREMENT,
   ForkSeq,
+  GENESIS_EPOCH,
   SLOTS_PER_EPOCH,
   SYNC_COMMITTEE_SIZE,
   SYNC_REWARD_WEIGHT,
   WEIGHT_DENOMINATOR,
 } from "@lodestar/params";
-import {altair} from "@lodestar/types";
+import {Epoch, altair} from "@lodestar/types";
 import {bigIntSqrt} from "@lodestar/utils";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
 import {BeaconStateAllForks} from "../types.js";
 import {getNextSyncCommitteeIndices} from "./seed.js";
+import {getSlotDurationMsAtEpoch} from "./slot.js";
 
 /**
  * Return the sync committee for a given state and epoch.
@@ -45,11 +48,12 @@ export function getNextSyncCommittee(
 /**
  * Same logic in https://github.com/ethereum/eth2.0-specs/blob/v1.1.0-alpha.5/specs/altair/beacon-chain.md#sync-committee-processing
  */
-export function computeSyncParticipantReward(totalActiveBalanceIncrements: number): number {
-  const totalActiveBalance = BigInt(totalActiveBalanceIncrements) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
-  const baseRewardPerIncrement = Math.floor(
-    (EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR) / Number(bigIntSqrt(totalActiveBalance))
-  );
+export function computeSyncParticipantReward(
+  config: ChainConfig,
+  epoch: Epoch,
+  totalActiveBalanceIncrements: number
+): number {
+  const baseRewardPerIncrement = computeBaseRewardPerIncrement(config, epoch, totalActiveBalanceIncrements);
   const totalBaseRewards = baseRewardPerIncrement * totalActiveBalanceIncrements;
   const maxParticipantRewards = Math.floor(
     Math.floor((totalBaseRewards * SYNC_REWARD_WEIGHT) / WEIGHT_DENOMINATOR) / SLOTS_PER_EPOCH
@@ -61,9 +65,17 @@ export function computeSyncParticipantReward(totalActiveBalanceIncrements: numbe
  * Before we manage bigIntSqrt(totalActiveStake) as BigInt and return BigInt.
  * bigIntSqrt(totalActiveStake) should fit a number (2 ** 53 -1 max)
  **/
-export function computeBaseRewardPerIncrement(totalActiveStakeByIncrement: number): number {
+export function computeBaseRewardPerIncrement(
+  config: ChainConfig,
+  epoch: Epoch,
+  totalActiveStakeByIncrement: number
+): number {
+  // Divide last so the exact slot duration ratio applies
+  const numerator = Math.floor(
+    (EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR * getSlotDurationMsAtEpoch(config, epoch)) /
+      getSlotDurationMsAtEpoch(config, GENESIS_EPOCH)
+  );
   return Math.floor(
-    (EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR) /
-      Number(bigIntSqrt(BigInt(totalActiveStakeByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT)))
+    numerator / Number(bigIntSqrt(BigInt(totalActiveStakeByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT)))
   );
 }

package/src/util/validator.ts

@@ -2,6 +2,7 @@ import {ChainForkConfig} from "@lodestar/config";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
   ForkSeq,
+  GENESIS_EPOCH,
   MAX_EFFECTIVE_BALANCE,
   MAX_EFFECTIVE_BALANCE_ELECTRA,
   MIN_ACTIVATION_BALANCE,
@@ -11,6 +12,7 @@ import {intDiv} from "@lodestar/utils";
 import {BeaconStateAllForks, CachedBeaconStateElectra, CachedBeaconStateGloas, EpochCache} from "../types.js";
 import {hasEth1WithdrawalCredential} from "./capella.js";
 import {hasCompoundingWithdrawalCredential, hasExecutionWithdrawalCredential} from "./electra.js";
+import {getSlotDurationMsAtEpoch} from "./slot.js";
 
 /**
  * Check if [[validator]] is active
@@ -93,23 +95,35 @@ export function getActivationExitChurnLimit(epochCtx: EpochCache): number {
  * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/beacon-chain.md#new-get_activation_churn_limit
  */
 export function getActivationChurnLimit(epochCtx: EpochCache): number {
-  const churn = getBalanceChurnLimit(
-    epochCtx.totalActiveBalanceIncrements,
-    epochCtx.config.CHURN_LIMIT_QUOTIENT_GLOAS,
-    epochCtx.config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
+  const {config, epoch, totalActiveBalanceIncrements} = epochCtx;
+  const churnByBalance = Math.floor(
+    (totalActiveBalanceIncrements / config.CHURN_LIMIT_QUOTIENT_GLOAS) * EFFECTIVE_BALANCE_INCREMENT
+  );
+  const churn = Math.min(
+    config.MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS,
+    Math.max(churnByBalance, config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA)
   );
-  return Math.min(epochCtx.config.MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS, churn);
+  // Scale by the slot duration ratio, rounding to the increment once after scaling
+  const scaled = Math.floor(
+    (churn * getSlotDurationMsAtEpoch(config, epoch)) / getSlotDurationMsAtEpoch(config, GENESIS_EPOCH)
+  );
+  return scaled - (scaled % EFFECTIVE_BALANCE_INCREMENT);
 }
 
 /**
  * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/beacon-chain.md#new-get_exit_churn_limit
  */
 export function getExitChurnLimit(epochCtx: EpochCache): number {
-  return getBalanceChurnLimit(
-    epochCtx.totalActiveBalanceIncrements,
-    epochCtx.config.CHURN_LIMIT_QUOTIENT_GLOAS,
-    epochCtx.config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
+  const {config, epoch, totalActiveBalanceIncrements} = epochCtx;
+  const churnByBalance = Math.floor(
+    (totalActiveBalanceIncrements / config.CHURN_LIMIT_QUOTIENT_GLOAS) * EFFECTIVE_BALANCE_INCREMENT
+  );
+  const churn = Math.max(churnByBalance, config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA);
+  // Scale by the slot duration ratio, rounding to the increment once after scaling
+  const scaled = Math.floor(
+    (churn * getSlotDurationMsAtEpoch(config, epoch)) / getSlotDurationMsAtEpoch(config, GENESIS_EPOCH)
   );
+  return scaled - (scaled % EFFECTIVE_BALANCE_INCREMENT);
 }
 
 /**
@@ -118,12 +132,16 @@ export function getExitChurnLimit(epochCtx: EpochCache): number {
  */
 export function getConsolidationChurnLimit(fork: ForkSeq, epochCtx: EpochCache): number {
   if (fork >= ForkSeq.gloas) {
-    // No MIN floor — pass 0 so getBalanceChurnLimit's max(churn, min) is a no-op.
-    return getBalanceChurnLimit(
-      epochCtx.totalActiveBalanceIncrements,
-      epochCtx.config.CONSOLIDATION_CHURN_LIMIT_QUOTIENT,
-      0
+    const {config, epoch, totalActiveBalanceIncrements} = epochCtx;
+    // No MIN floor in gloas
+    const churn = Math.floor(
+      (totalActiveBalanceIncrements / config.CONSOLIDATION_CHURN_LIMIT_QUOTIENT) * EFFECTIVE_BALANCE_INCREMENT
     );
+    // Scale by the slot duration ratio, rounding to the increment once after scaling
+    const scaled = Math.floor(
+      (churn * getSlotDurationMsAtEpoch(config, epoch)) / getSlotDurationMsAtEpoch(config, GENESIS_EPOCH)
+    );
+    return scaled - (scaled % EFFECTIVE_BALANCE_INCREMENT);
   }
   return getBalanceChurnLimitFromCache(epochCtx) - getActivationExitChurnLimit(epochCtx);
 }
@@ -131,17 +149,26 @@ export function getConsolidationChurnLimit(fork: ForkSeq, epochCtx: EpochCache):
 // NOTE: duplicates the quotient/min choices in get{Exit,Activation,Consolidation}ChurnLimit.
 export function getGloasChurnLimits(
   config: ChainForkConfig,
+  epoch: Epoch,
   totalActiveBalanceIncrements: number
 ): {exit: number; activation: number; consolidation: number} {
-  const exit = getBalanceChurnLimit(
-    totalActiveBalanceIncrements,
-    config.CHURN_LIMIT_QUOTIENT_GLOAS,
+  const ratioNumerator = getSlotDurationMsAtEpoch(config, epoch);
+  const ratioDenominator = getSlotDurationMsAtEpoch(config, GENESIS_EPOCH);
+  const exitUnscaled = Math.max(
+    Math.floor((totalActiveBalanceIncrements / config.CHURN_LIMIT_QUOTIENT_GLOAS) * EFFECTIVE_BALANCE_INCREMENT),
     config.MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA
   );
+  const activationUnscaled = Math.min(config.MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS, exitUnscaled);
+  const consolidationUnscaled = Math.floor(
+    (totalActiveBalanceIncrements / config.CONSOLIDATION_CHURN_LIMIT_QUOTIENT) * EFFECTIVE_BALANCE_INCREMENT
+  );
+  const exit = Math.floor((exitUnscaled * ratioNumerator) / ratioDenominator);
+  const activation = Math.floor((activationUnscaled * ratioNumerator) / ratioDenominator);
+  const consolidation = Math.floor((consolidationUnscaled * ratioNumerator) / ratioDenominator);
   return {
-    exit,
-    activation: Math.min(config.MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS, exit),
-    consolidation: getBalanceChurnLimit(totalActiveBalanceIncrements, config.CONSOLIDATION_CHURN_LIMIT_QUOTIENT, 0),
+    exit: exit - (exit % EFFECTIVE_BALANCE_INCREMENT),
+    activation: activation - (activation % EFFECTIVE_BALANCE_INCREMENT),
+    consolidation: consolidation - (consolidation % EFFECTIVE_BALANCE_INCREMENT),
   };
 }
 

package/src/util/weakSubjectivity.ts

@@ -2,7 +2,6 @@ import {ChainForkConfig} from "@lodestar/config";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
   ForkSeq,
-  GENESIS_SLOT,
   MAX_DEPOSITS,
   MAX_EFFECTIVE_BALANCE,
   SLOTS_PER_EPOCH,
@@ -13,6 +12,7 @@ import {Epoch, Root, Slot, TimeSeconds, ssz} from "@lodestar/types";
 import {ZERO_HASH} from "../constants/constants.js";
 import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
 import {computeCheckpointEpochAtStateSlot, computeEpochAtSlot, getCurrentEpoch} from "./epoch.js";
+import {computeSlotAtTimeMs} from "./slot.js";
 import {StateBytesMetadata, getStateTypeFromBytes, scanActiveValidatorsFromStateBytes} from "./sszBytes.js";
 import {
   getActivationChurnLimit,
@@ -107,7 +107,7 @@ function computeWeakSubjectivityPeriodFromActiveValidators(
 ): number {
   const fork = config.getForkName(slot);
 
-  const churnLimitsGloas = getGloasChurnLimits(config, totalActiveBalanceIncrements);
+  const churnLimitsGloas = getGloasChurnLimits(config, computeEpochAtSlot(slot), totalActiveBalanceIncrements);
 
   return isForkPostGloas(fork)
     ? computeWeakSubjectivityPeriodFromConstituentsGloas(
@@ -223,6 +223,6 @@ export function isWithinWeakSubjectivityPeriodFromSummary(
   summary: WeakSubjectivitySummary,
   now: TimeSeconds = Date.now() / 1000
 ): boolean {
-  const clockSlot = GENESIS_SLOT + Math.floor((now - summary.genesisTime) / (config.SLOT_DURATION_MS / 1000));
+  const clockSlot = computeSlotAtTimeMs(config, now * 1000, summary.genesisTime * 1000);
   return computeEpochAtSlot(clockSlot) <= summary.checkpointEpoch + summary.period;
 }