@marinade.finance/scoring 1.0.0 → 1.0.1

package/src/eligibility/eligibility.service.ts

@@ -1,183 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { ConfigService } from '../config/config.service';
-import { Bonds } from '../dto/bonds.dto';
-import { ClusterInfo } from '../dto/cluster.dto';
-import { EligibilityConfig, EvaluationResult, Issue, IssueType, ValidatorEligibility, ValidatorsEligibilities } from '../dto/eligibility.dto';
-import { ScoreDto, Scores } from '../dto/scoring.dto';
-import { AggregatedValidator, AggregatedValidators } from '../dto/validators.dto';
-import { ValidatorsService } from '../validators/validators.service';
-
-export class EligibilityService {
-
-  constructor (private validatorsService: ValidatorsService, private configService: ConfigService) {}
-
-  evalLowCreditsIssue (validator: AggregatedValidator, epochIndex: number, eligibilityConfig: EligibilityConfig, clusterInfo: ClusterInfo): Issue | null {
-    if (!validator.epochs[epochIndex]) {
-      return null;
-    }
-
-    const targetCredits = clusterInfo.targetCreditsByEpoch.get(validator.epochs[epochIndex]!);
-    if (!targetCredits) {
-      return null;
-    }
-
-    const actualCredits = validator.credits[epochIndex] || 0;
-    const creditsPct = Math.round((100 * actualCredits) / targetCredits);
-
-    if (creditsPct < eligibilityConfig.voteCreditsLow) {
-      return { type: IssueType.VOTE_CREDITS_LOW, message: `Credits @ ${creditsPct}%` };
-    } else if (creditsPct < eligibilityConfig.voteCreditsWarning) {
-      return { type: IssueType.VOTE_CREDITS_WARNING, message: `(Warning) Credits @ ${creditsPct}%` };
-    }
-
-    return null;
-  }
-
-  evalLowExternalStakeIssue (validator: AggregatedValidator, epochIndex: number, eligibilityConfig: EligibilityConfig): Issue | undefined {
-    const externalStake = validator.externalStake[epochIndex];
-
-    if (!externalStake) {
-      return undefined;
-    }
-
-    if (externalStake < eligibilityConfig.minExternalStake) {
-      return { type: IssueType.EXTERNAL_STAKE, message: `External stake: ${externalStake}` };
-    }
-    return undefined;
-  }
-
-  evalBlacklistIssue (validator: AggregatedValidator): Issue | undefined {
-    if (validator.blacklisted) {
-      return { type: IssueType.BLACKLIST, message: 'Validator is blacklisted' };
-    }
-    return undefined;
-  }
-
-  evalHighCommissionIssue (validator: AggregatedValidator, epochIndex: number, eligibilityConfig: EligibilityConfig): Issue | undefined {
-    const commission = validator.commission[epochIndex];
-
-    if (!commission) {
-      return undefined;
-    }
-
-    if (eligibilityConfig.maxCommission < commission!) {
-      return { type: IssueType.COMMISSION, message: `Commission: ${commission}%` };
-    }
-    return undefined;
-  }
-
-  evalScoreIssue (epochIndex: number, eligibilityConfig: EligibilityConfig, { concentrationScore }: ScoreDto): Issue | undefined {
-    if (epochIndex === 0 && concentrationScore < eligibilityConfig.minScore) {
-      return { type: IssueType.SCORE, message: `Concentration Score: ${concentrationScore}` };
-    }
-    return undefined;
-  }
-
-  evalBondIssue (validator: AggregatedValidator, bonds: Bonds): Issue | undefined {
-    if (!(validator.voteAccount in bonds)) {
-      return { type: IssueType.NO_BOND, message: 'Validator has no bond' };
-    }
-    return undefined;
-  }
-
-  getValidatorIssuesInEpoch (validator: AggregatedValidator, bonds: Bonds, epochIndex: number, eligibilityConfig: EligibilityConfig, clusterInfo: ClusterInfo, score: ScoreDto): Issue[] {
-    if (!validator.dataAvailable[epochIndex]) {
-      return [{ type: IssueType.NO_DATA, message: `No data for validator in epoch ${validator.epochs[epochIndex]}` }];
-    }
-    return [
-      this.evalBlacklistIssue(validator),
-      this.evalLowCreditsIssue(validator, epochIndex, eligibilityConfig, clusterInfo),
-      this.evalLowExternalStakeIssue(validator, epochIndex, eligibilityConfig),
-      this.evalHighCommissionIssue(validator, epochIndex, eligibilityConfig),
-      this.evalScoreIssue(epochIndex, eligibilityConfig, score),
-      this.evalBondIssue(validator, bonds),
-    ].filter(Boolean) as Issue[];
-  }
-
-  evalIssuesInEpoch (issues: Issue[]): EvaluationResult {
-    let criticals = 0;
-    let warnings = 0;
-
-    const criticalTypes = new Set([
-      IssueType.NO_BOND,
-      IssueType.NO_DATA,
-      IssueType.BLACKLIST,
-      IssueType.COMMISSION,
-      IssueType.EXTERNAL_STAKE,
-      IssueType.CENTRALIZATION,
-      IssueType.SCORE,
-      IssueType.VOTE_CREDITS_LOW,
-    ]);
-
-    const warningTypes = new Set([
-      IssueType.VOTE_CREDITS_WARNING,
-    ]);
-
-    issues.forEach(issue => {
-      if (criticalTypes.has(issue.type)) {
-        criticals++;
-      } else if (warningTypes.has(issue.type)) {
-        warnings++;
-      } else {
-        throw new Error(`Unexpected issue: ${issue.type}`);
-      }
-    });
-
-    return { criticals, warnings };
-  }
-
-  evalIssues (issuesCollection: Issue[][], epochs: number): EvaluationResult {
-    let totalCriticals = 0;
-    let totalWarnings = 0;
-    for (let epochIndex = 0; epochIndex < epochs; epochIndex++) {
-      if (!issuesCollection[epochIndex]) {
-        continue;
-      }
-      const { criticals, warnings } = this.evalIssuesInEpoch(issuesCollection[epochIndex]!);
-      totalCriticals += criticals;
-      totalWarnings += warnings;
-    }
-    return { criticals: totalCriticals, warnings: totalWarnings };
-  }
-
-  isBasicEligible (issuesCollection: Issue[][], eligibilityConfig: EligibilityConfig): boolean {
-    const { criticals, warnings } = this.evalIssues(issuesCollection, eligibilityConfig.basicEligibilityEpochs + 1);
-    return criticals === 0 && warnings <= eligibilityConfig.maxWarnings;
-  }
-
-  isBonusEligible (issuesCollection: Issue[][], eligibilityConfig: EligibilityConfig): boolean {
-    const totalEpochs = eligibilityConfig.basicEligibilityEpochs + eligibilityConfig.bonusEligibilityExtraEpochs + 1;
-    const { criticals, warnings } = this.evalIssues(issuesCollection, totalEpochs);
-    return criticals === 0 && warnings <= eligibilityConfig.maxWarnings;
-  }
-
-  getIssuesCollection (clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, bonds: Bonds, score: ScoreDto, eligibilityConfig: EligibilityConfig): Issue[][] {
-    return Array.from({ length: eligibilityConfig.basicEligibilityEpochs + eligibilityConfig.bonusEligibilityExtraEpochs + 1 }, (_, epochIndex) =>
-      this.getValidatorIssuesInEpoch(aggregatedValidator, bonds, epochIndex, eligibilityConfig, clusterInfo, score)
-    );
-  }
-
-  computeValidatorEligibility (clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, bonds: Bonds, scores: ScoreDto, eligibilityConfig: EligibilityConfig): ValidatorEligibility {
-    const issuesCollection = this.getIssuesCollection(clusterInfo, aggregatedValidator, bonds, scores, eligibilityConfig);
-    const minExternalStake = this.validatorsService.selectExternalStakeMin(aggregatedValidator, eligibilityConfig.basicEligibilityEpochs);
-
-    return {
-      basicEligibility: this.isBasicEligible(issuesCollection, eligibilityConfig),
-      bonusEligibility: this.isBonusEligible(issuesCollection, eligibilityConfig),
-      issuesCollection,
-      capFromBond: this.configService.getScoringConfig().CAP_FROM_BOND,
-      capFromExternalStake: minExternalStake * (eligibilityConfig.maxStakeShare / (1 - eligibilityConfig.maxStakeShare)),
-    };
-  }
-
-  computeValidatorsEligibilities (clusterInfo: ClusterInfo, scores: Scores, aggregatedValidators: AggregatedValidators, bonds: Bonds, eligibilityConfig: EligibilityConfig): ValidatorsEligibilities {
-    const result: ValidatorsEligibilities = {};
-    for (const [voteAccount, validator] of Object.entries(aggregatedValidators)) {
-      if (!scores[voteAccount]) {
-        continue;
-      }
-      result[voteAccount] = this.computeValidatorEligibility(clusterInfo, validator, bonds, scores[voteAccount]!, eligibilityConfig);
-    }
-    return result;
-  }
-}

package/src/scoring/scoring.module.ts

@@ -1,11 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ScoringService } from './scoring.service';
-import { ValidatorsModule } from '../validators/validators.module';
-import { ConfigModule } from '../config/config.module';
-
-@Module({
-  imports: [ValidatorsModule, ConfigModule],
-  providers: [ScoringService],
-  exports: [ScoringService],
-})
-export class ScoringModule {}

package/src/scoring/scoring.service.ts

@@ -1,184 +0,0 @@
-/* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { ClusterInfo } from '../dto/cluster.dto';
-import { ScoreDto, ScoreConfig, Scores, Variables } from '../dto/scoring.dto';
-import { AggregatedValidator, AggregatedValidators } from '../dto/validators.dto';
-import { ValidatorsService } from '../validators/validators.service';
-import { Parser } from 'expr-eval';
-import { mathUtilityFunctions } from '../utils/maths';
-import { zip } from '../utils/zip';
-import { ValidatorsEligibilities } from '../dto/eligibility.dto';
-import { ConfigService } from '../config/config.service';
-
-export class ScoringService {
-  constructor (private readonly validatorsService: ValidatorsService, private readonly configService: ConfigService) {}
-
-  selectVariables (clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, scoreConfig: ScoreConfig): Variables {
-    return {
-      bp_cluster_mean: clusterInfo.meanBlockProductionOverBasicEligibilityPeriod,
-      bp_cluster_std_dev: clusterInfo.stdDevBlockProductionOverBasicEligibilityPeriod,
-      credits_pct_mean: this.validatorsService.selectCreditsPctMean(aggregatedValidator, clusterInfo, scoreConfig.epochs),
-      bp_mean: this.validatorsService.selectBlockProductionMean(aggregatedValidator, scoreConfig.epochs),
-      commission_inflation_max: this.validatorsService.selectCommissonInflationMax(aggregatedValidator, scoreConfig.epochs + 1),
-      commission_mev: this.validatorsService.selectCommissonMEV(aggregatedValidator),
-      country_stake_concentration_last: this.validatorsService.selectCountryStakeConcentration(aggregatedValidator, clusterInfo),
-      city_stake_concentration_last: this.validatorsService.selectCityStakeConcentration(aggregatedValidator, clusterInfo),
-      aso_stake_concentration_last: this.validatorsService.selectASOStakeConcentration(aggregatedValidator, clusterInfo),
-      node_stake_last: this.validatorsService.selectNodeStake(aggregatedValidator),
-    };
-  }
-
-  computeValidatorScore (clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, formulas: string[], weights: number[], scoreConfig: ScoreConfig): ScoreDto {
-    const scoreErrors: boolean[] = [];
-    const scores: number[] = [];
-    const values: number[] = [];
-    const tooltips: string[] = [];
-    let totalWeight = 0;
-    let totalScore = 0;
-    let totalConcentrationWeight = 0;
-    let totalConcentrationScore = 0;
-    const variables = { ...this.selectVariables(clusterInfo, aggregatedValidator, scoreConfig), ...mathUtilityFunctions() };
-
-    for (const [formula, weight, tooltipBuilder] of zip(formulas, weights, this.getScoreTooltipBuilders())) {
-      let score = 0;
-      try {
-        values.push(0);
-        score = Parser.evaluate(formula, variables);
-        scoreErrors.push(false);
-      } catch (err) {
-        console.error('Failed to calculate', formula, 'for', aggregatedValidator.voteAccount, 'err:', err);
-        scoreErrors.push(true);
-      }
-      totalWeight += weight;
-      totalScore += weight * score;
-      if (scoreConfig.concentrationParams.includes(scores.length)) {
-        totalConcentrationWeight += weight;
-        totalConcentrationScore += weight * score;
-      }
-      tooltips.push(tooltipBuilder(aggregatedValidator, clusterInfo));
-      scores.push(score);
-    }
-
-    return {
-      score: totalScore / totalWeight,
-      concentrationScore: totalConcentrationScore / totalConcentrationWeight,
-      scores,
-      values,
-      scoreErrors,
-      tooltips,
-    };
-  }
-
-  computeValidatorsScores (clusterInfo: ClusterInfo, aggregatedValidators: AggregatedValidators, formulas: string[], weights: number[], scoreConfig: ScoreConfig): Scores {
-    const result: Scores = {};
-
-    for (const [voteAccount, aggregatedValidator] of Object.entries(aggregatedValidators)) {
-      result[voteAccount] = this.computeValidatorScore(clusterInfo, aggregatedValidator, formulas, weights, scoreConfig);
-    }
-
-    return result;
-  }
-
-  scoreTooltipCredits (validator: AggregatedValidator, clusterInfo: ClusterInfo): string {
-    return `Credits: ${validator.credits.slice(1).map((credits, e) => {
-      const epoch = validator.epochs[e + 1];
-      if (epoch !== undefined) {
-        const targetCredits = clusterInfo.targetCreditsByEpoch.get(epoch) || 1;
-        return `${(100 * credits / targetCredits).toFixed(2)}%`;
-      } else {
-        return 'N/A';
-      }
-    }).join(', ')}`;
-  }
-
-  scoreTooltipBlockProduction (validator: AggregatedValidator, clusterInfo: ClusterInfo): string {
-    return `Block production: ${validator.blocksProduced.map((blocksProduced, e) => {
-      const leaderSlot = validator.leaderSlots[e];
-      if (leaderSlot) {
-        return `${(100 * blocksProduced / leaderSlot).toFixed(2)}%`;
-      } else {
-        return '-';
-      }
-    }).join(', ')}`;
-  }
-
-  scoreTooltipCommissionInflation (validator: AggregatedValidator, clusterInfo: ClusterInfo): string {
-    return `Inflation commission: ${validator.commission.map(c => `${c}%`).join(', ')}`;
-  }
-
-  scoreTooltipCommissionMEV (validator: AggregatedValidator, clusterInfo: ClusterInfo): string {
-    return `MEV commission: ${validator.mevCommission} %`;
-  }
-
-  scoreTooltipCountryStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): string {
-    return `Country: ${validator.country}`;
-  }
-
-  scoreTooltipCityStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): string {
-    return `City: ${validator.city}`;
-  }
-
-  scoreTooltipNodeStake (validator: AggregatedValidator, clusterInfo: ClusterInfo): string {
-    return `Stake of the node: ${Math.round(validator.stake[0] ?? 0).toLocaleString()} SOL`;
-  }
-
-  scoreTooltipASOStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): string {
-    return `ASO: ${validator.aso}`;
-  }
-
-  getScoreTooltipBuilders (): ((validator: AggregatedValidator, clusterInfo: ClusterInfo) => string)[] {
-    return [
-      this.scoreTooltipCredits,
-      this.scoreTooltipBlockProduction,
-      this.scoreTooltipCommissionInflation,
-      this.scoreTooltipCommissionMEV,
-      this.scoreTooltipCountryStakeConcentration,
-      this.scoreTooltipCityStakeConcentration,
-      this.scoreTooltipASOStakeConcentration,
-      this.scoreTooltipNodeStake,
-    ];
-  }
-
-  getDefaultFormulas (): string[] {
-    return [
-      this.configService.getScoringConfig().formulaVoteCredits,
-      this.configService.getScoringConfig().formulaBlockProduction,
-      this.configService.getScoringConfig().formulaInflationCommission,
-      this.configService.getScoringConfig().formulaMEVCommission,
-      this.configService.getScoringConfig().formulaStakeConcentrationCountry,
-      this.configService.getScoringConfig().formulaStakeConcentrationCity,
-      this.configService.getScoringConfig().formulaStakeConcentrationASO,
-      this.configService.getScoringConfig().formulaStakeConcentrationNode,
-    ];
-  }
-
-  getDefaultWeights (): number[] {
-
-    return [
-      this.configService.getScoringConfig().weightVoteCredits,
-      this.configService.getScoringConfig().weightBlockProduction,
-      this.configService.getScoringConfig().weightInflationCommission,
-      this.configService.getScoringConfig().weightMEVCommission,
-      this.configService.getScoringConfig().weightStakeConcentrationCountry,
-      this.configService.getScoringConfig().weightStakeConcentrationCity,
-      this.configService.getScoringConfig().weightStakeConcentrationASO,
-      this.configService.getScoringConfig().weightStakeConcentrationNode,
-    ];
-  }
-
-  orderByEligibiltyAndScore (scores: Scores, eligibilities: ValidatorsEligibilities): string[] {
-    const voteAccounts = Object.keys(scores);
-    voteAccounts.sort((a, b) => {
-      const eligibilityOrder = Number(eligibilities[b]?.basicEligibility ?? 0) - Number(eligibilities[a]?.basicEligibility ?? 0);
-      if (eligibilityOrder === 0) {
-        const scoreA = scores[a]?.score ?? 0;
-        const scoreB = scores[b]?.score ?? 0;
-
-        return scoreB - scoreA;
-      }
-      return eligibilityOrder;
-    });
-
-    return voteAccounts;
-  }
-}

package/src/stake/stake.module.ts

@@ -1,10 +0,0 @@
-import { Module } from '@nestjs/common';
-import { StakeService } from './stake.service';
-import { ConfigModule } from '../config/config.module';
-
-@Module({
-  imports: [ConfigModule],
-  providers: [StakeService],
-  exports: [StakeService],
-})
-export class StakeModule {}

package/src/stake/stake.service.ts

@@ -1,242 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { ValidatorsEligibilities } from '../dto/eligibility.dto';
-import { Scores } from '../dto/scoring.dto';
-import { Votes } from '../dto/snapshots.dto';
-import { ProcessedVotesAndTVLs, Stakes, StakesConfig, StakingVariables } from '../dto/stakes.dto';
-import { AggregatedValidators } from '../dto/validators.dto';
-import { Parser } from 'expr-eval';
-import { sum } from '../utils/maths';
-import { ConfigService } from '../config/config.service';
-
-export class StakeService {
-  constructor (private readonly configService: ConfigService) { }
-
-  private removeFromVotes (votes: Votes, toRemove: string): Votes {
-    const votesCopy = { ...votes };
-    delete votesCopy[toRemove];
-    return votesCopy;
-  }
-
-  private processVotesAndCalculateTVLs (
-    mSolVotes: Votes,
-    veMndeVotes: Votes,
-    stakesConfig: StakesConfig
-  ): ProcessedVotesAndTVLs {
-    const updatedVeMndeVotes = this.removeFromVotes({ ...veMndeVotes }, this.configService.getScoringConfig().DS_PUBKEY);
-    const veMndeVotesForDS = veMndeVotes[this.configService.getScoringConfig().DS_PUBKEY] ?? 0;
-    const totalVeMndeVotes = sum(Object.values(veMndeVotes));
-    const veMndeTvl = Math.round(
-      totalVeMndeVotes > 0
-        ? (1 - veMndeVotesForDS / totalVeMndeVotes) * stakesConfig.veMndeControl * stakesConfig.tvl
-        : 0
-    );
-
-    const updatedMSolVotes = this.removeFromVotes({ ...mSolVotes }, this.configService.getScoringConfig().DS_PUBKEY);
-    const mSolVotesForDS = mSolVotes[this.configService.getScoringConfig().DS_PUBKEY] ?? 0;
-    const totalMSolVotes = sum(Object.values(mSolVotes));
-    const mSolTvl = Math.round(
-      totalMSolVotes > 0
-        ? (1 - mSolVotesForDS / totalMSolVotes) * stakesConfig.mSolControl * stakesConfig.tvl
-        : 0
-    );
-
-    return {
-      updatedMSolVotes,
-      updatedVeMndeVotes,
-      mSolTvl,
-      veMndeTvl,
-      totalTvl: stakesConfig.tvl
-    };
-  }
-
-  public filterEligibleValidators (aggregatedValidators: AggregatedValidators, eligibilities: ValidatorsEligibilities): string[] {
-    return Object.keys(aggregatedValidators).filter(voteAccount => eligibilities[voteAccount]?.basicEligibility);
-  }
-
-  private initStakes (eligibleValidators: string[]): Stakes {
-    const result: Stakes = {};
-    for (const voteAccount of eligibleValidators) {
-      result[voteAccount] = {
-        algoStake: 0,
-        mSolStake: 0,
-        veMndeStake: 0,
-        totalStake: 0,
-        algoStakeFromOverflow: 0,
-        mSolStakeFromOverflow: 0,
-        veMndeStakeFromOverflow: 0,
-        totalStakeFromOverlfow: 0,
-      };
-    }
-    return result;
-  }
-
-  private computeStakesForValidators (
-    stakingVariables: StakingVariables,
-    eligibleValidators: string[],
-    scores: Scores,
-    eligibilities: ValidatorsEligibilities,
-    stakesConfig: StakesConfig,
-    mSolVotes: Votes,
-    veMndeVotes: Votes,
-    totalMsolVotes: number,
-    totalVeMndeVotes: number,
-    mSolTvl: number,
-    veMndeTvl: number,
-    algoTvl: number,
-    blockSize: number
-  ): Stakes {
-    let updatedTotalMSolVotes = totalMsolVotes;
-    let updatedTotalVeMndeVotes = totalVeMndeVotes;
-    let algoStakeDistributed = 0;
-    let mSolStakeDistributed = 0;
-    let veMndeStakeDistributed = 0;
-    const stakes = this.initStakes(eligibleValidators);
-
-    let round = 1;
-    while (round <= 100 && (mSolTvl - mSolStakeDistributed > 1 || veMndeTvl - veMndeStakeDistributed > 1)) {
-      let someStakeIncreased = false;
-      const mSolStakeDistributedBeforeRound = mSolStakeDistributed;
-      const veMndeStakeDistributedBeforeRound = veMndeStakeDistributed;
-      for (const voteAccount of eligibleValidators) {
-        if (!stakes[voteAccount] || !scores[voteAccount] || !eligibilities[voteAccount]) {
-          continue;
-        }
-
-        let blocks = 0;
-
-        if (round === 1) {
-          if (eligibilities[voteAccount]!.bonusEligibility) {
-            blocks += stakesConfig.stakeBlocksFromBonus;
-          }
-
-          blocks += Parser.evaluate(stakesConfig.formulaStakeBlocksFromScore, { ...stakingVariables, score: scores[voteAccount]!.score });
-        }
-
-        const algoStake = Math.round(Math.min(blockSize * blocks, Math.max(algoTvl - algoStakeDistributed, 0)));
-        const mSolStake = updatedTotalMSolVotes > 0 ? Math.round((mSolVotes[voteAccount] ?? 0) / updatedTotalMSolVotes * Math.max(mSolTvl - mSolStakeDistributedBeforeRound, 0)) : 0;
-        const veMndeStake = updatedTotalVeMndeVotes > 0 ? Math.round((veMndeVotes[voteAccount] ?? 0) / updatedTotalVeMndeVotes * Math.max(veMndeTvl - veMndeStakeDistributedBeforeRound, 0)) : 0;
-        const stake = algoStake + veMndeStake + mSolStake;
-
-        if (!stake) {
-          continue;
-        }
-
-        const cappedStake = Math.min(eligibilities[voteAccount]!.capFromBond - stakes[voteAccount]!.totalStake, eligibilities[voteAccount]!.capFromExternalStake - stakes[voteAccount]!.totalStake, stake);
-        const stakeOverflow = stake - cappedStake;
-        const algoStakeOverflow = Math.round(algoStake / stake * stakeOverflow);
-        const mSolStakeOverflow = Math.round(mSolStake / stake * stakeOverflow);
-        const veMndeStakeOverflow = Math.round(veMndeStake / stake * stakeOverflow);
-        const cappedAlgoStake = algoStake - algoStakeOverflow;
-        const cappedMSolStake = mSolStake - mSolStakeOverflow;
-        const cappedVeMndeStake = veMndeStake - veMndeStakeOverflow;
-
-        if (cappedAlgoStake + cappedMSolStake + cappedVeMndeStake > 0) {
-          someStakeIncreased = true;
-        }
-
-        algoStakeDistributed += cappedAlgoStake;
-        mSolStakeDistributed += cappedMSolStake;
-        veMndeStakeDistributed += cappedVeMndeStake;
-
-        stakes[voteAccount]!.algoStake += cappedAlgoStake;
-        stakes[voteAccount]!.mSolStake += cappedMSolStake;
-        stakes[voteAccount]!.veMndeStake += cappedVeMndeStake;
-        stakes[voteAccount]!.totalStake += cappedAlgoStake + cappedMSolStake + cappedVeMndeStake;
-        if (round > 1) {
-          stakes[voteAccount]!.algoStakeFromOverflow += cappedAlgoStake;
-          stakes[voteAccount]!.mSolStakeFromOverflow += cappedMSolStake;
-          stakes[voteAccount]!.veMndeStakeFromOverflow += cappedVeMndeStake;
-          stakes[voteAccount]!.totalStakeFromOverlfow += cappedAlgoStake + cappedMSolStake + cappedVeMndeStake;
-        }
-      }
-
-      round++;
-
-      if (!someStakeIncreased) {
-        break;
-      }
-
-      for (const voteAccount of eligibleValidators) {
-        if (Math.round(stakes[voteAccount]!.totalStake) === Math.round(eligibilities[voteAccount]!.capFromExternalStake)) {
-          veMndeVotes = this.removeFromVotes(veMndeVotes, voteAccount);
-          mSolVotes = this.removeFromVotes(mSolVotes, voteAccount);
-        }
-      }
-      updatedTotalVeMndeVotes = sum(Object.values(veMndeVotes));
-      updatedTotalMSolVotes = sum(Object.values(mSolVotes));
-    }
-
-    const remainingAlgoTvl = Math.max(algoTvl - algoStakeDistributed, 0);
-    const remainingMSolTvl = Math.max(mSolTvl - mSolStakeDistributed, 0);
-    const remainingVeMndeTvl = Math.max(veMndeTvl - veMndeStakeDistributed, 0);
-    for (const voteAccount of eligibleValidators) {
-      if (!stakes[voteAccount]) {
-        continue;
-      }
-      if (algoStakeDistributed) {
-        const extraStake = Math.round((stakes[voteAccount]?.algoStake ?? 0) / algoStakeDistributed * remainingAlgoTvl);
-        stakes[voteAccount]!.totalStake += extraStake;
-        stakes[voteAccount]!.algoStake += extraStake;
-        stakes[voteAccount]!.algoStakeFromOverflow += extraStake;
-      }
-      if (mSolStakeDistributed) {
-        const extraStake = Math.round((stakes[voteAccount]?.algoStake ?? 0) / mSolStakeDistributed * remainingMSolTvl);
-        stakes[voteAccount]!.totalStake += extraStake;
-        stakes[voteAccount]!.mSolStake += extraStake;
-        stakes[voteAccount]!.mSolStakeFromOverflow += extraStake;
-      }
-      if (veMndeStakeDistributed) {
-        const extraStake = Math.round((stakes[voteAccount]?.algoStake ?? 0) / veMndeStakeDistributed * remainingVeMndeTvl);
-        stakes[voteAccount]!.totalStake += extraStake;
-        stakes[voteAccount]!.veMndeStake += extraStake;
-        stakes[voteAccount]!.veMndeStakeFromOverflow += extraStake;
-      }
-    }
-    return stakes;
-  }
-
-  computeValidatorsStakes (
-    aggregatedValidators: AggregatedValidators,
-    scores: Scores,
-    eligibilities: ValidatorsEligibilities,
-    stakesConfig: StakesConfig,
-    mSolVotes: Votes,
-    veMndeVotes: Votes
-  ): Stakes {
-    let updatedMSolVotes = { ...mSolVotes };
-    let updatedVeMndeVotes = { ...veMndeVotes };
-
-    const processedVotesAndTvls = this.processVotesAndCalculateTVLs(updatedMSolVotes, updatedVeMndeVotes, stakesConfig);
-
-    updatedMSolVotes = processedVotesAndTvls.updatedMSolVotes;
-    updatedVeMndeVotes = processedVotesAndTvls.updatedVeMndeVotes;
-    const algoTvl = stakesConfig.tvl - processedVotesAndTvls.mSolTvl - processedVotesAndTvls.veMndeTvl;
-
-    try {
-      const eligibleValidators = this.filterEligibleValidators(aggregatedValidators, eligibilities);
-      const stakingVariables: StakingVariables = { tvl: algoTvl };
-      const blockSize = Parser.evaluate(stakesConfig.formulaStakeBlockSize, stakingVariables);
-
-      Object.keys(aggregatedValidators).filter((v) => !eligibilities[v]?.basicEligibility).forEach((voteAccount) => {
-        updatedVeMndeVotes = this.removeFromVotes(updatedVeMndeVotes, voteAccount);
-        updatedMSolVotes = this.removeFromVotes(updatedMSolVotes, voteAccount);
-      });
-      const updatedTotalVeMndeVotes = sum(Object.values(updatedVeMndeVotes));
-      const updatedTotalMSolVotes = sum(Object.values(updatedMSolVotes));
-      eligibleValidators.sort((a, b) => {
-        const scoreA = scores[a]?.score ?? 0;
-        const scoreB = scores[b]?.score ?? 0;
-        return scoreB - scoreA;
-      });
-
-      return this.computeStakesForValidators(stakingVariables, eligibleValidators, scores, eligibilities,
-        stakesConfig, updatedMSolVotes, updatedVeMndeVotes,
-        updatedTotalMSolVotes, updatedTotalVeMndeVotes,
-        processedVotesAndTvls.mSolTvl, processedVotesAndTvls.veMndeTvl,
-        algoTvl, blockSize);
-
-    } catch (err) {
-      return {};
-    }
-  }
-}

package/src/validators/validators.module.ts

@@ -1,48 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ValidatorsService } from './validators.service';
-import { ConfigService } from '../config/config.service';
-import { ApiDataProvider } from '../providers/api-data.provider';
-import { FileDataProvider } from '../providers/file-data.provider';
-import { ConfigModule } from '../config/config.module';
-
-@Module({
-  imports: [ConfigModule],
-  providers: [ValidatorsService, {
-    provide: 'IDataProvider',
-    useFactory: (configService: ConfigService) => {
-      const dataSourceType = configService.getDataProviderMode();
-      if (dataSourceType === 'api') {
-        return new ApiDataProvider(
-          {
-            validatorsURL: configService.getValidatorsURL(),
-            blacklistURL: configService.getBlacklistURL(),
-            vemndeVotesURL: configService.getVemndeVotesURL(),
-            msolVotesURL: configService.getMsolVotesURL(),
-            rewardsURL: configService.getRewardsURL(),
-            jitoMevURL: configService.getJitoMevURL(),
-            bondsURL: configService.getBondsURL(),
-            marinadeTvlURL: configService.getMarinadeTvlURL(),
-          }
-        );
-      } else if (dataSourceType === 'file') {
-        return new FileDataProvider(
-          {
-            validatorsPath: configService.getValidatorsPath(),
-            blacklistPath: configService.getBlacklistPath(),
-            vemndeVotesPath: configService.getVemndeVotesPath(),
-            msolVotesPath: configService.getMsolVotesPath(),
-            rewardsPath: configService.getRewardsPath(),
-            jitoMevPath: configService.getJitoMevPath(),
-            bondsPath: configService.getBondsPath(),
-            marinadeTvlPath: configService.getMarinadeTvlPath(),
-          }
-        );
-      } else {
-        throw new Error('Invalid data provider type');
-      }
-    },
-    inject: [ConfigService],
-  }],
-  exports: [ValidatorsService],
-})
-export class ValidatorsModule {}