@marinade.finance/scoring 1.0.0 → 1.0.2

package/src/providers/file-data.provider.ts

@@ -1,125 +0,0 @@
-/* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { TvlStats } from '../dto/marinade.dto';
-import { Bonds, BondsDto } from '../dto/bonds.dto';
-import { JitoValidatorDto, JitoValidatorsResponseDto } from '../dto/jito.dto';
-import { Rewards, RewardsResponseDto } from '../dto/rewards.dto';
-import { EpochStatDto, ValidatorDto, ValidatorsResponseDto } from '../dto/validators.dto';
-import { IDataProvider } from '../interfaces/data-provider.interface';
-import { readFile } from 'fs/promises';
-import { FETCHING_ERROR_MESSAGES } from '../errors/fetching';
-import { sum } from '../utils/maths';
-import { Votes, mSolSnapshotDto } from '../dto/snapshots.dto';
-
-class Paths {
-  validatorsPath: string;
-  blacklistPath: string;
-  vemndeVotesPath: string;
-  msolVotesPath: string;
-  rewardsPath: string;
-  jitoMevPath: string;
-  bondsPath: string;
-  marinadeTvlPath: string;
-}
-
-export class FileDataProvider implements IDataProvider {
-  constructor (private paths: Paths) { }
-
-  async fetchValidators (epochsToFetch: number): Promise<ValidatorDto[]> {
-    try {
-      const validatorsFile = await readFile(this.paths.validatorsPath, 'utf8');
-      const validatorsData: ValidatorsResponseDto = JSON.parse(validatorsFile);
-
-      validatorsData.validators.forEach(validator => {
-        validator.epochStats = validator.epoch_stats.reduce((acc, epochStat) => {
-          acc[epochStat.epoch] = epochStat;
-          return acc;
-        }, {} as Record<number, EpochStatDto>);
-      });
-
-      return validatorsData.validators;
-    } catch (error) {
-      console.error(FETCHING_ERROR_MESSAGES.generalValidatorsFetchFailed, error);
-      throw error;
-    }
-  }
-
-  async fetchTvl (withSnapshot: boolean): Promise<TvlStats> {
-    const tvlFile = await readFile(this.paths.marinadeTvlPath, 'utf8');
-    const tvlData: TvlStats = JSON.parse(tvlFile);
-
-    return tvlData;
-  }
-
-  async fetchBlacklist (): Promise<Set<string>> {
-    const blacklistFile = await readFile(this.paths.blacklistPath, 'utf8');
-    const blacklistSet = new Set(blacklistFile.split('\n').map((line) => line.split(',')[0]).filter((value): value is string => !!value));
-    return blacklistSet;
-  }
-
-  async fetchBonds (): Promise<Bonds> {
-    const bondsFile = await readFile(this.paths.bondsPath, 'utf8');
-    const bondsData: BondsDto = JSON.parse(bondsFile);
-
-    const bonds: Bonds = bondsData.bonds.reduce<Bonds>((acc, bond) => {
-      acc[bond.vote_account] = bond.cpmpe;
-      return acc;
-    }, {} as Bonds);
-
-    return bonds;
-  }
-
-  async fetchVeMndeVotes (): Promise<Record<string, number>> {
-    const vemndeVotesFile = await readFile(this.paths.vemndeVotesPath, 'utf8');
-    const vemndeVotesData = JSON.parse(vemndeVotesFile) as mSolSnapshotDto;
-    const result: Votes = {};
-    for (const { amount, validatorVoteAccount } of vemndeVotesData.records) {
-      const parsedAmount = Number(amount);
-      if (!isNaN(parsedAmount) && parsedAmount > 0) {
-        result[validatorVoteAccount] = (result[validatorVoteAccount] ?? 0) + parsedAmount;
-      }
-    }
-
-    return result;
-  }
-
-  async fetchMSolVotes (): Promise<Record<string, number>> {
-    const msolVotesFile = await readFile(this.paths.msolVotesPath, 'utf8');
-    const msolVotesData = JSON.parse(msolVotesFile) as mSolSnapshotDto;
-    const result: Votes = {};
-    for (const { amount, validatorVoteAccount } of msolVotesData.records) {
-      const parsedAmount = Number(amount);
-      if (!isNaN(parsedAmount) && parsedAmount > 0) {
-        result[validatorVoteAccount] = (result[validatorVoteAccount] ?? 0) + parsedAmount;
-      }
-    }
-
-    return result;
-  }
-
-  async fetchRewards (epochs: number): Promise<Rewards> {
-    const rewardsFile = await readFile(this.paths.rewardsPath, 'utf8');
-    const rewardsData = JSON.parse(rewardsFile) as { rewards_mev: [number, number][], rewards_inflation_est: [number, number][] };
-
-    const data = new RewardsResponseDto(rewardsData);
-
-    const mev = sum(data.rewards_mev.map(dto => dto.amount));
-    const inflation = sum(data.rewards_inflation_est.map(dto => dto.amount));
-
-    return { inflation, mev };
-  }
-
-  async fetchValidatorsJitoMEV (): Promise<Record<string, JitoValidatorDto>> {
-    try {
-      const jitoMevFile = await readFile(this.paths.jitoMevPath, 'utf8');
-      const jitoMevData: JitoValidatorsResponseDto = JSON.parse(jitoMevFile);
-
-      return Object.fromEntries(
-        jitoMevData.validators.map((validator) => [validator.vote_account, validator])
-      );
-    } catch (error) {
-      console.error(FETCHING_ERROR_MESSAGES.generalJitoMEVFetchFailed, error);
-      throw error;
-    }
-  }
-}

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/utils/csv.ts

@@ -1,30 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable no-console */
-import * as fs from 'fs';
-import { Score } from '../dto/scoring.dto';
-
-export function writeScoresToCsv (filePath: string, data: Score[]): void {
-  if (data.length === 0) {
-    console.error('Data array is empty, no CSV will be written.');
-    return;
-  }
-  const headers = Object.keys(data[0]!);
-  let csvString = headers.join(',') + '\n';
-
-  data.forEach(score => {
-    const rowData = headers.map(header => {
-      const value = score[header as keyof Score];
-      if (typeof value === 'string' && (value.includes(',') || value.includes('\n') || value.includes('"'))) {
-        return `"${value.replace(/"/g, '""')}"`;
-      }
-      return `"${value}"`;
-    }).join(',');
-    csvString += rowData + '\n';
-  });
-
-  fs.writeFile(filePath, csvString, (err) => {
-    if (err) {
-      console.error('Error writing CSV file:', err);
-    }
-  });
-}

package/src/utils/maths.ts

@@ -1,75 +0,0 @@
-import { Value } from 'expr-eval';
-
-/**
- * Calculates the sum of an array of numbers.
- * @param {number[]} amounts - The array of numbers to sum.
- * @return {number} The sum of the numbers in the array.
- */
-export function sum (amounts: number[]): number {
-  if (!Array.isArray(amounts) || amounts.some(amount => typeof amount !== 'number')) {
-    throw new TypeError('Input must be an array of numbers');
-  }
-  return amounts.reduce((acc, amount) => acc + amount, 0);
-}
-
-/**
- * Calculates the mean (average) of an array of numbers.
- * @param {number[]} data - The array of numbers for which to calculate the mean.
- * @return {number} The mean of the numbers in the array. Throws an error if the array is empty.
- */
-export function mean (data: number[]): number {
-  if (data.length === 0) {
-    throw new Error('Cannot calculate mean for empty data');
-  }
-
-  return sum(data) / data.length;
-}
-
-/**
- * Calculates the standard deviation of an array of numbers.
- * Standard deviation is a measure of the amount of variation or dispersion of a set of values.
- * @param {number[]} data - The array of numbers for which to calculate the standard deviation.
- * @return {number} The standard deviation of the numbers in the array. Throws an error if the array is empty.
- */
-export function stdDev (data: number[]): number {
-  if (data.length === 0) {
-    throw new Error('Cannot calculate std. dev. for empty data');
-  }
-
-  const dataMean = mean(data);
-  return Math.sqrt(data.reduce((sum, value) => sum + Math.pow(value - dataMean, 2), 0) / data.length);
-}
-
-export function piecewise (...args: Value[]): Value {
-  if (args.length === 0) {
-    throw new Error('At least one argument must be provided!');
-  }
-
-  for (let conditionIndex = 0, valueIndex = 1; valueIndex < args.length; conditionIndex += 2, valueIndex += 2) {
-    const condition = args[conditionIndex];
-    const value = args[valueIndex];
-
-    if (typeof condition !== 'boolean') {
-      throw new Error(`Argument at position ${conditionIndex} must be a boolean!`);
-    }
-
-    if (condition) {
-      if (value === undefined) {
-        throw new Error(`Expected a value corresponding to the condition at position ${conditionIndex}, but got undefined.`);
-      }
-      return value;
-    }
-  }
-
-  const defaultValue = args[args.length - 1];
-  if (defaultValue === undefined) {
-    throw new Error('Unexpected error: Default value is undefined.');
-  }
-  return defaultValue;
-}
-
-export function mathUtilityFunctions () {
-  return {
-    piecewise
-  };
-}