@marinade.finance/scoring 1.0.0 → 1.0.1

package/computing/cluster.ts

@@ -0,0 +1,102 @@
+import { BlockProductionResult, ClusterInfo } from '../dto/cluster.dto';
+import { ValidatorDto } from '../dto/validators.dto';
+import { mean, stdDev } from '../utils/maths';
+import Decimal from 'decimal.js';
+
+export function computeBlockProduction (validators: ValidatorDto[], startEpoch: number, endEpoch: number): BlockProductionResult {
+  const blockProductions: number[] = [];
+
+  for (const validator of validators) {
+    let leaderSlots = 0;
+    let blocksProduced = 0;
+
+    for (let epoch = startEpoch; epoch <= endEpoch; epoch++) {
+      if (!validator.epochStats) {
+        continue;
+      }
+      const epochStat = validator.epochStats[epoch];
+      if (epochStat) {
+        leaderSlots += epochStat.leader_slots;
+        blocksProduced += epochStat.blocks_produced;
+      }
+    }
+
+    if (leaderSlots) {
+      blockProductions.push(blocksProduced / leaderSlots);
+    }
+  }
+
+  return {
+    mean: mean(blockProductions),
+    stdDev: stdDev(blockProductions),
+  };
+}
+export function computeTargetCreditsByEpoch (validators: ValidatorDto[]): Map<number, number> {
+  const sumOfWeightedCreditsPerEpoch = new Map<number, Decimal>();
+  const sumOfWeightsPerEpoch = new Map<number, Decimal>();
+
+  validators.forEach(validator => {
+    validator.epoch_stats.forEach(epochStat => {
+      if (epochStat.epoch_end_at) {
+        const activatedStakeDecimal = new Decimal(epochStat.activated_stake);
+        const stakeInSol = activatedStakeDecimal.dividedBy(1e9);
+
+        const prevSumOfWeightedCredits = sumOfWeightedCreditsPerEpoch.get(epochStat.epoch) || new Decimal(0);
+        sumOfWeightedCreditsPerEpoch.set(epochStat.epoch, prevSumOfWeightedCredits.plus(new Decimal(epochStat.credits).times(stakeInSol)));
+
+        const prevSumOfWeightsPerEpoch = sumOfWeightsPerEpoch.get(epochStat.epoch) || new Decimal(0);
+        sumOfWeightsPerEpoch.set(epochStat.epoch, prevSumOfWeightsPerEpoch.plus(stakeInSol));
+      }
+    });
+  });
+
+  const result = new Map<number, number>();
+  sumOfWeightsPerEpoch.forEach((sumOfWeights, epoch) => {
+    const weightedCredits = sumOfWeightedCreditsPerEpoch.get(epoch) || new Decimal(0);
+    result.set(epoch, weightedCredits.dividedBy(sumOfWeights).toDecimalPlaces(0, Decimal.ROUND_HALF_UP).toNumber());
+  });
+
+  return result;
+}
+export function computeConcentrations (validators: ValidatorDto[], epoch: number): { city: Map<string, number>, country: Map<string, number>, aso: Map<string, number> } {
+  let total = 0;
+  const city = new Map<string, number>();
+  const country = new Map<string, number>();
+  const aso = new Map<string, number>();
+
+  for (const validator of validators) {
+    const lastEpochStats = validator.epoch_stats[0];
+    if (lastEpochStats?.epoch === epoch) {
+      const cityKey = validator.dc_full_city ?? '???';
+      const countryKey = validator.dc_country ?? '???';
+      const asoKey = validator.dc_aso ?? '???';
+
+      const stake = Number(validator.activated_stake) / 1e9;
+      city.set(cityKey, (city.get(cityKey) ?? 0) + stake);
+      country.set(countryKey, (country.get(countryKey) ?? 0) + stake);
+      aso.set(asoKey, (aso.get(asoKey) ?? 0) + stake);
+
+      total += stake;
+    }
+  }
+
+  if (total > 0) {
+    for (const map of [city, country, aso]) {
+      for (const [key, value] of map) {
+        map.set(key, value / total);
+      }
+    }
+  }
+
+  return { city, country, aso };
+}
+export function computeClusterInfo (validators: ValidatorDto[], basicEligibilityEpochs: number, lastEpoch: number): ClusterInfo {
+  const { mean: meanBlockProduction, stdDev: stdDevBlockProduction } = this.computeBlockProduction(validators, lastEpoch - basicEligibilityEpochs, lastEpoch - 1);
+
+  return {
+    targetCreditsByEpoch: this.computeTargetCreditsByEpoch(validators),
+    ...this.computeConcentrations(validators, lastEpoch),
+    meanBlockProductionOverBasicEligibilityPeriod: meanBlockProduction,
+    stdDevBlockProductionOverBasicEligibilityPeriod: stdDevBlockProduction,
+  };
+}

package/computing/eligibility.ts

@@ -0,0 +1,163 @@
+import { selectExternalStakeMin } from './validators';
+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, ScoringConfig } from '../dto/scoring.dto';
+import { AggregatedValidator, AggregatedValidators } from '../dto/validators.dto';
+
+export function 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;
+}
+export function 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;
+}
+export function evalBlacklistIssue(validator: AggregatedValidator): Issue | undefined {
+  if (validator.blacklisted) {
+    return { type: IssueType.BLACKLIST, message: 'Validator is blacklisted' };
+  }
+  return undefined;
+}
+export function 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;
+}
+export function 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;
+}
+export function evalBondIssue(validator: AggregatedValidator, bonds: Bonds): Issue | undefined {
+  if (!(validator.voteAccount in bonds)) {
+    return { type: IssueType.NO_BOND, message: 'Validator has no bond' };
+  }
+  return undefined;
+}
+export function 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 [
+    evalBlacklistIssue(validator),
+    evalLowCreditsIssue(validator, epochIndex, eligibilityConfig, clusterInfo),
+    evalLowExternalStakeIssue(validator, epochIndex, eligibilityConfig),
+    evalHighCommissionIssue(validator, epochIndex, eligibilityConfig),
+    evalScoreIssue(epochIndex, eligibilityConfig, score),
+    evalBondIssue(validator, bonds),
+  ].filter(Boolean) as Issue[];
+}
+export function 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 };
+}
+export function 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 } = evalIssuesInEpoch(issuesCollection[epochIndex]!);
+    totalCriticals += criticals;
+    totalWarnings += warnings;
+  }
+  return { criticals: totalCriticals, warnings: totalWarnings };
+}
+export function isBasicEligible(issuesCollection: Issue[][], eligibilityConfig: EligibilityConfig): boolean {
+  const { criticals, warnings } = evalIssues(issuesCollection, eligibilityConfig.basicEligibilityEpochs + 1);
+  return criticals === 0 && warnings <= eligibilityConfig.maxWarnings;
+}
+export function isBonusEligible(issuesCollection: Issue[][], eligibilityConfig: EligibilityConfig): boolean {
+  const totalEpochs = eligibilityConfig.basicEligibilityEpochs + eligibilityConfig.bonusEligibilityExtraEpochs + 1;
+  const { criticals, warnings } = evalIssues(issuesCollection, totalEpochs);
+  return criticals === 0 && warnings <= eligibilityConfig.maxWarnings;
+}
+export function getIssuesCollection(clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, bonds: Bonds, score: ScoreDto, eligibilityConfig: EligibilityConfig): Issue[][] {
+  return Array.from({ length: eligibilityConfig.basicEligibilityEpochs + eligibilityConfig.bonusEligibilityExtraEpochs + 1 }, (_, epochIndex) =>
+    getValidatorIssuesInEpoch(aggregatedValidator, bonds, epochIndex, eligibilityConfig, clusterInfo, score)
+  );
+}
+export function computeValidatorEligibility(clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, bonds: Bonds, scores: ScoreDto, eligibilityConfig: EligibilityConfig, scoringConfig: ScoringConfig): ValidatorEligibility {
+  const issuesCollection = getIssuesCollection(clusterInfo, aggregatedValidator, bonds, scores, eligibilityConfig);
+  const minExternalStake = selectExternalStakeMin(aggregatedValidator, eligibilityConfig.basicEligibilityEpochs);
+
+  return {
+    basicEligibility: isBasicEligible(issuesCollection, eligibilityConfig),
+    bonusEligibility: isBonusEligible(issuesCollection, eligibilityConfig),
+    issuesCollection,
+    capFromBond: scoringConfig.CAP_FROM_BOND,
+    capFromExternalStake: minExternalStake * (eligibilityConfig.maxStakeShare / (1 - eligibilityConfig.maxStakeShare)),
+  };
+}
+export function computeValidatorsEligibilities(clusterInfo: ClusterInfo, scores: Scores, aggregatedValidators: AggregatedValidators, bonds: Bonds, eligibilityConfig: EligibilityConfig, scoringConfig: ScoringConfig): ValidatorsEligibilities {
+  const result: ValidatorsEligibilities = {};
+  for (const [voteAccount, validator] of Object.entries(aggregatedValidators)) {
+    if (!scores[voteAccount]) {
+      continue;
+    }
+    result[voteAccount] = computeValidatorEligibility(clusterInfo, validator, bonds, scores[voteAccount]!, eligibilityConfig, scoringConfig);
+  }
+  return result;
+}

package/computing/score.ts

@@ -0,0 +1,164 @@
+import { ClusterInfo } from '../dto/cluster.dto';
+import { ScoreDto, ScoreConfig, Scores, Variables } from '../dto/scoring.dto';
+import { AggregatedValidator, AggregatedValidators } from '../dto/validators.dto';
+import { Parser } from 'expr-eval';
+import { mathUtilityFunctions } from '../utils/maths';
+import { zip } from '../utils/zip';
+import { ValidatorsEligibilities } from '../dto/eligibility.dto';
+import { ScoringConfig } from '../dto/scoring.dto';
+import { selectCreditsPctMean, selectBlockProductionMean, selectCommissionInflationMax, selectCommissionMEV, selectCountryStakeConcentration, selectCityStakeConcentration, selectASOStakeConcentration, selectNodeStake } from 'computing/validators';
+import { error } from 'logger';
+
+export function selectVariables(clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, scoreConfig: ScoreConfig): Variables {
+  return {
+    bp_cluster_mean: clusterInfo.meanBlockProductionOverBasicEligibilityPeriod,
+    bp_cluster_std_dev: clusterInfo.stdDevBlockProductionOverBasicEligibilityPeriod,
+    credits_pct_mean: selectCreditsPctMean(aggregatedValidator, clusterInfo, scoreConfig.epochs),
+    bp_mean: selectBlockProductionMean(aggregatedValidator, scoreConfig.epochs),
+    commission_inflation_max: selectCommissionInflationMax(aggregatedValidator, scoreConfig.epochs + 1),
+    commission_mev: selectCommissionMEV(aggregatedValidator),
+    country_stake_concentration_last: selectCountryStakeConcentration(aggregatedValidator, clusterInfo),
+    city_stake_concentration_last: selectCityStakeConcentration(aggregatedValidator, clusterInfo),
+    aso_stake_concentration_last: selectASOStakeConcentration(aggregatedValidator, clusterInfo),
+    node_stake_last: selectNodeStake(aggregatedValidator),
+  };
+}
+export function 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 = { ...selectVariables(clusterInfo, aggregatedValidator, scoreConfig), ...mathUtilityFunctions() };
+
+  for (const [formula, weight, tooltipBuilder] of zip(formulas, weights, getScoreTooltipBuilders())) {
+    let score = 0;
+    try {
+      values.push(0);
+      score = Parser.evaluate(formula, variables);
+      scoreErrors.push(false);
+    } catch (err) {
+      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,
+  };
+}
+export function 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] = computeValidatorScore(clusterInfo, aggregatedValidator, formulas, weights, scoreConfig);
+  }
+
+  return result;
+}
+export function 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(', ')}`;
+}
+export function 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(', ')}`;
+}
+export function scoreTooltipCommissionInflation(validator: AggregatedValidator, _clusterInfo: ClusterInfo): string {
+  return `Inflation commission: ${validator.commission.map(c => `${c}%`).join(', ')}`;
+}
+export function scoreTooltipCommissionMEV(validator: AggregatedValidator, _clusterInfo: ClusterInfo): string {
+  return `MEV commission: ${validator.mevCommission} %`;
+}
+export function scoreTooltipCountryStakeConcentration(validator: AggregatedValidator, _clusterInfo: ClusterInfo): string {
+  return `Country: ${validator.country}`;
+}
+export function scoreTooltipCityStakeConcentration(validator: AggregatedValidator, _clusterInfo: ClusterInfo): string {
+  return `City: ${validator.city}`;
+}
+export function scoreTooltipNodeStake(validator: AggregatedValidator, _clusterInfo: ClusterInfo): string {
+  return `Stake of the node: ${Math.round(validator.stake[0] ?? 0).toLocaleString()} SOL`;
+}
+export function scoreTooltipASOStakeConcentration(validator: AggregatedValidator, _clusterInfo: ClusterInfo): string {
+  return `ASO: ${validator.aso}`;
+}
+export function getScoreTooltipBuilders(): ((validator: AggregatedValidator, clusterInfo: ClusterInfo) => string)[] {
+  return [
+    scoreTooltipCredits,
+    scoreTooltipBlockProduction,
+    scoreTooltipCommissionInflation,
+    scoreTooltipCommissionMEV,
+    scoreTooltipCountryStakeConcentration,
+    scoreTooltipCityStakeConcentration,
+    scoreTooltipASOStakeConcentration,
+    scoreTooltipNodeStake,
+  ];
+}
+export function getDefaultFormulas(scoringConfig: ScoringConfig): string[] {
+  return [
+    scoringConfig.formulaVoteCredits,
+    scoringConfig.formulaBlockProduction,
+    scoringConfig.formulaInflationCommission,
+    scoringConfig.formulaMEVCommission,
+    scoringConfig.formulaStakeConcentrationCountry,
+    scoringConfig.formulaStakeConcentrationCity,
+    scoringConfig.formulaStakeConcentrationASO,
+    scoringConfig.formulaStakeConcentrationNode,
+  ];
+}
+export function getDefaultWeights(scoringConfig: ScoringConfig): number[] {
+  return [
+    scoringConfig.weightVoteCredits,
+    scoringConfig.weightBlockProduction,
+    scoringConfig.weightInflationCommission,
+    scoringConfig.weightMEVCommission,
+    scoringConfig.weightStakeConcentrationCountry,
+    scoringConfig.weightStakeConcentrationCity,
+    scoringConfig.weightStakeConcentrationASO,
+    scoringConfig.weightStakeConcentrationNode,
+  ];
+}
+export function 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/computing/stake.ts

@@ -0,0 +1,246 @@
+import { ValidatorsEligibilities } from '../dto/eligibility.dto';
+import { Scores, ScoringConfig } 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 { error } from 'logger';
+
+export interface ComputeStakesForValidatorsParams {
+  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;
+}
+export function removeFromVotes(votes: Votes, toRemove: string): Votes {
+  const votesCopy = { ...votes };
+  delete votesCopy[toRemove];
+  return votesCopy;
+}
+export function processVotesAndCalculateTVLs(
+  mSolVotes: Votes,
+  veMndeVotes: Votes,
+  stakesConfig: StakesConfig,
+  scoringConfig: ScoringConfig
+): ProcessedVotesAndTVLs {
+  const updatedVeMndeVotes = removeFromVotes({ ...veMndeVotes }, scoringConfig.DS_PUBKEY);
+  const veMndeVotesForDS = veMndeVotes[scoringConfig.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 = removeFromVotes({ ...mSolVotes }, scoringConfig.DS_PUBKEY);
+  const mSolVotesForDS = mSolVotes[scoringConfig.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
+  };
+}
+export function filterEligibleValidators(aggregatedValidators: AggregatedValidators, eligibilities: ValidatorsEligibilities): string[] {
+  return Object.keys(aggregatedValidators).filter(voteAccount => eligibilities[voteAccount]?.basicEligibility);
+}
+export function 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;
+}
+export function computeStakesForValidators(
+  params: ComputeStakesForValidatorsParams
+): Stakes {
+  let updatedTotalMSolVotes = params.totalMsolVotes;
+  let updatedTotalVeMndeVotes = params.totalVeMndeVotes;
+  let algoStakeDistributed = 0;
+  let mSolStakeDistributed = 0;
+  let veMndeStakeDistributed = 0;
+  const stakes = initStakes(params.eligibleValidators);
+
+  let round = 1;
+  while (round <= 100 && (params.mSolTvl - mSolStakeDistributed > 1 || params.veMndeTvl - veMndeStakeDistributed > 1)) {
+    let someStakeIncreased = false;
+    const mSolStakeDistributedBeforeRound = mSolStakeDistributed;
+    const veMndeStakeDistributedBeforeRound = veMndeStakeDistributed;
+    for (const voteAccount of params.eligibleValidators) {
+      if (!stakes[voteAccount] || !params.scores[voteAccount] || !params.eligibilities[voteAccount]) {
+        continue;
+      }
+
+      let blocks = 0;
+
+      if (round === 1) {
+        if (params.eligibilities[voteAccount]!.bonusEligibility) {
+          blocks += params.stakesConfig.stakeBlocksFromBonus;
+        }
+
+        blocks += Parser.evaluate(params.stakesConfig.formulaStakeBlocksFromScore, { ...params.stakingVariables, score: params.scores[voteAccount]!.score });
+      }
+
+      const algoStake = Math.round(Math.min(params.blockSize * blocks, Math.max(params.algoTvl - algoStakeDistributed, 0)));
+      const mSolStake = updatedTotalMSolVotes > 0 ? Math.round((params.mSolVotes[voteAccount] ?? 0) / updatedTotalMSolVotes * Math.max(params.mSolTvl - mSolStakeDistributedBeforeRound, 0)) : 0;
+      const veMndeStake = updatedTotalVeMndeVotes > 0 ? Math.round((params.veMndeVotes[voteAccount] ?? 0) / updatedTotalVeMndeVotes * Math.max(params.veMndeTvl - veMndeStakeDistributedBeforeRound, 0)) : 0;
+      const stake = algoStake + veMndeStake + mSolStake;
+
+      if (!stake) {
+        continue;
+      }
+
+      const cappedStake = Math.min(params.eligibilities[voteAccount]!.capFromBond - stakes[voteAccount]!.totalStake, params.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 params.eligibleValidators) {
+      if (Math.round(stakes[voteAccount]!.totalStake) === Math.round(params.eligibilities[voteAccount]!.capFromExternalStake)) {
+        params.veMndeVotes = removeFromVotes(params.veMndeVotes, voteAccount);
+        params.mSolVotes = removeFromVotes(params.mSolVotes, voteAccount);
+      }
+    }
+    updatedTotalVeMndeVotes = sum(Object.values(params.veMndeVotes));
+    updatedTotalMSolVotes = sum(Object.values(params.mSolVotes));
+  }
+
+  const remainingAlgoTvl = Math.max(params.algoTvl - algoStakeDistributed, 0);
+  const remainingMSolTvl = Math.max(params.mSolTvl - mSolStakeDistributed, 0);
+  const remainingVeMndeTvl = Math.max(params.veMndeTvl - veMndeStakeDistributed, 0);
+  for (const voteAccount of params.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;
+}
+export function computeValidatorsStakes(
+  aggregatedValidators: AggregatedValidators,
+  scores: Scores,
+  eligibilities: ValidatorsEligibilities,
+  stakesConfig: StakesConfig,
+  scoringConfig: ScoringConfig,
+  mSolVotes: Votes,
+  veMndeVotes: Votes
+): Stakes {
+  let updatedMSolVotes = { ...mSolVotes };
+  let updatedVeMndeVotes = { ...veMndeVotes };
+
+  const processedVotesAndTvls = processVotesAndCalculateTVLs(updatedMSolVotes, updatedVeMndeVotes, stakesConfig, scoringConfig);
+
+  updatedMSolVotes = processedVotesAndTvls.updatedMSolVotes;
+  updatedVeMndeVotes = processedVotesAndTvls.updatedVeMndeVotes;
+  const algoTvl = stakesConfig.tvl - processedVotesAndTvls.mSolTvl - processedVotesAndTvls.veMndeTvl;
+
+  try {
+    const eligibleValidators = 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 = removeFromVotes(updatedVeMndeVotes, voteAccount);
+      updatedMSolVotes = 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 computeStakesForValidators({
+      stakingVariables: stakingVariables,
+      eligibleValidators: eligibleValidators,
+      scores: scores,
+      eligibilities: eligibilities,
+      stakesConfig: stakesConfig,
+      mSolVotes: updatedMSolVotes,
+      veMndeVotes: updatedVeMndeVotes,
+      totalMsolVotes: updatedTotalMSolVotes,
+      totalVeMndeVotes: updatedTotalVeMndeVotes,
+      mSolTvl: processedVotesAndTvls.mSolTvl,
+      veMndeTvl: processedVotesAndTvls.veMndeTvl,
+      algoTvl: algoTvl,
+      blockSize: blockSize
+    });
+  } catch (err) {
+    error("Computing validators stakes failed.", err);
+  }
+}