fix: fixed churn limit post electra, fixed maxExitEpoch in past was negative

Author: Tarens2

src/jobs/validators/utils/getChurnLimit.ts

@@ -0,0 +1,25 @@
+import { BigNumber } from '@ethersproject/bignumber';
+
+const MIN_PER_EPOCH_CHURN_LIMIT = BigNumber.from(4); // 4 validators
+const MIN_ACTIVATION_BALANCE = BigNumber.from('32000000000'); // 32 ETH in Gwei
+const MAX_PER_EPOCH_CHURN_LIMIT = BigNumber.from('256000000000'); // 256 ETH in Gwei
+const CHURN_LIMIT_QUOTIENT = BigNumber.from('65536');
+
+/**
+ * Calculates the churn limit (in Gwei) based on total active balance.
+ * Pectra-style stake-based churn limit with min/max bounds.
+ */
+export function getChurnLimitGwei(totalActiveBalanceGwei: BigNumber): BigNumber {
+  const minLimit = MIN_PER_EPOCH_CHURN_LIMIT.mul(MIN_ACTIVATION_BALANCE);
+  const dynamicLimit = totalActiveBalanceGwei.div(CHURN_LIMIT_QUOTIENT);
+  const maxedLimit = dynamicLimit.gt(minLimit) ? dynamicLimit : minLimit;
+
+  return maxedLimit.gt(MAX_PER_EPOCH_CHURN_LIMIT) ? MAX_PER_EPOCH_CHURN_LIMIT : maxedLimit;
+}
+
+/**
+ * Returns average number of validators for churn limit.
+ */
+export function getChurnLimit(totalActiveBalanceGwei: BigNumber) {
+  return getChurnLimitGwei(totalActiveBalanceGwei).div(MIN_ACTIVATION_BALANCE);
+}

src/jobs/validators/validators.service.ts

@@ -22,6 +22,7 @@ import { getValidatorWithdrawalTimestamp } from './utils/get-validator-withdrawa
 import { IndexedValidator, ResponseValidatorsData } from '../../common/consensus-provider/consensus-provider.types';
 import { SweepService } from '../../common/sweep';
 import { toEth } from '../../common/utils/to-eth';
+import { getChurnLimit } from './utils/getChurnLimit';
 
 export class ValidatorsService {
   static SERVICE_LOG_NAME = 'validators';
@@ -91,20 +92,22 @@ export class ValidatorsService {
         const indexedValidators: ResponseValidatorsData = await processValidatorsStream(stream);
         const currentEpoch = this.genesisTimeService.getCurrentEpoch();
 
-        let activeValidatorCount = 0;
-        let latestEpoch = `${currentEpoch + MAX_SEED_LOOKAHEAD + 1}`;
-
         const sweepMeanEpochs = await this.sweepService.getSweepDelayInEpochs(indexedValidators, currentEpoch);
         this.validatorsStorageService.setSweepMeanEpochs(sweepMeanEpochs);
 
+        let activeValidatorCount = 0;
+        let maxExitEpoch = `${currentEpoch + MAX_SEED_LOOKAHEAD + 1}`;
+        let totalActiveBalance = BigNumber.from(0);
+
         for (const item of indexedValidators) {
           if (['active_ongoing', 'active_exiting', 'active_slashed'].includes(item.status)) {
             activeValidatorCount++;
+            totalActiveBalance = totalActiveBalance.add(item.balance);
           }
 
           if (item.validator.exit_epoch !== FAR_FUTURE_EPOCH.toString()) {
-            if (BigNumber.from(item.validator.exit_epoch).gt(BigNumber.from(latestEpoch))) {
-              latestEpoch = item.validator.exit_epoch;
+            if (BigNumber.from(item.validator.exit_epoch).gt(BigNumber.from(maxExitEpoch))) {
+              maxExitEpoch = item.validator.exit_epoch;
             }
           }
 
@@ -122,8 +125,9 @@ export class ValidatorsService {
         );
 
         this.validatorsStorageService.setActiveValidatorsCount(activeValidatorCount);
+        this.validatorsStorageService.setChurnLimit(getChurnLimit(totalActiveBalance).toNumber());
         this.validatorsStorageService.setTotalValidatorsCount(indexedValidators.length);
-        this.validatorsStorageService.setMaxExitEpoch(latestEpoch);
+        this.validatorsStorageService.setMaxExitEpoch(maxExitEpoch);
         await this.findAndSetLidoValidatorsWithdrawableBalances(indexedValidators);
         await this.validatorsCacheService.saveDataToCache();
         this.validatorsStorageService.setLastUpdate(Math.floor(Date.now() / 1000));
@@ -135,7 +139,7 @@ export class ValidatorsService {
         this.logger.log('End update validators', {
           service: ValidatorsService.SERVICE_LOG_NAME,
           activeValidatorCount,
-          latestEpoch,
+          maxExitEpoch,
           frameBalances: stringifyFrameBalances(frameBalances),
           currentFrame,
         });

src/storage/validators/validators.service.ts

@@ -9,6 +9,7 @@ export class ValidatorsStorageService {
   protected lastUpdate: number;
   protected frameBalances: Record<string, BigNumber>;
   protected sweepMeanEpochs: number;
+  protected churnLimit: number;
   protected withdrawableLidoValidatorIds: string[] = [];
 
   /**
@@ -91,6 +92,14 @@ export class ValidatorsStorageService {
     return this.sweepMeanEpochs;
   }
 
+  public setChurnLimit(churnLimit: number) {
+    this.churnLimit = churnLimit;
+  }
+
+  public getChurnLimit() {
+    return this.churnLimit;
+  }
+
   public setWithdrawableLidoValidatorIds(withdrawableLidoValidators: string[]) {
     this.withdrawableLidoValidatorIds = withdrawableLidoValidators;
   }

src/waiting-time/waiting-time.service.ts

@@ -40,6 +40,7 @@ import {
 } from './waiting-time.types';
 import { SimpleFallbackJsonRpcBatchProvider } from '@lido-nestjs/execution';
 import { toEth } from '../common/utils/to-eth';
+import { MAX_SEED_LOOKAHEAD } from '../jobs/validators';
 
 @Injectable()
 export class WaitingTimeService {
@@ -137,10 +138,9 @@ export class WaitingTimeService {
     const queueStETH = calculateUnfinalizedEthToRequestId(requests, request);
     const requestTimestamp = request.timestamp.toNumber() * 1000;
 
-    const currentExitValidatorsDiffEpochs = Number(maxExitEpoch) - currentEpoch;
+    const currentExitValidatorsDiffEpochs = Math.max(Number(maxExitEpoch) - currentEpoch, MAX_SEED_LOOKAHEAD);
     const maxExitEpochInPast =
-      this.genesisTimeService.getEpochByTimestamp(request.timestamp.toNumber() * 1000) +
-      currentExitValidatorsDiffEpochs;
+      this.genesisTimeService.getEpochByTimestamp(requestTimestamp) + currentExitValidatorsDiffEpochs;
 
     const { frame, type: precalculatedType } = await this.calculateWithdrawalFrame({
       unfinalized: queueStETH,
@@ -267,15 +267,12 @@ export class WaitingTimeService {
     unfinalizedETH: BigNumber,
     latestEpoch: string,
   ): Promise<number> {
-    // latest epoch of most late to exit validators
-    const totalValidators = this.validators.getActiveValidatorsCount();
-
-    const churnLimit = Math.max(MIN_PER_EPOCH_CHURN_LIMIT, totalValidators / CHURN_LIMIT_QUOTIENT);
+    const churnLimit = this.validators.getChurnLimit();
     const epochPerFrame = this.contractConfig.getEpochsPerFrame();
 
     // calculate additional source of eth, rewards accumulated each epoch
-    const rewardsPerDay = await this.rewardsStorage.getRewardsPerFrame();
-    const rewardsPerEpoch = rewardsPerDay.div(epochPerFrame);
+    const rewardsPerFrame = this.rewardsStorage.getRewardsPerFrame();
+    const rewardsPerEpoch = rewardsPerFrame.div(epochPerFrame);
 
     const maxValidatorExitRequestsPerFrameVEBO = this.contractConfig.getMaxValidatorExitRequestsPerReport();
     const epochsPerFrameVEBO = this.contractConfig.getEpochsPerFrameVEBO();