@marinade.finance/scoring 1.0.1 → 1.0.3

package/dist/utils/maths.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mathUtilityFunctions = exports.piecewise = exports.stdDev = exports.mean = exports.sum = void 0;
+function sum(amounts) {
+    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);
+}
+exports.sum = sum;
+function mean(data) {
+    if (data.length === 0) {
+        throw new Error('Cannot calculate mean for empty data');
+    }
+    return sum(data) / data.length;
+}
+exports.mean = mean;
+function stdDev(data) {
+    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);
+}
+exports.stdDev = stdDev;
+function piecewise(...args) {
+    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;
+}
+exports.piecewise = piecewise;
+function mathUtilityFunctions() {
+    return {
+        piecewise
+    };
+}
+exports.mathUtilityFunctions = mathUtilityFunctions;
+//# sourceMappingURL=maths.js.map

package/dist/utils/maths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maths.js","sourceRoot":"","sources":["../../src/utils/maths.ts"],"names":[],"mappings":";;;AAOA,SAAgB,GAAG,CAAE,OAAiB;IACpC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC,EAAE;QACjF,MAAM,IAAI,SAAS,CAAC,mCAAmC,CAAC,CAAC;KAC1D;IACD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,GAAG,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC;AAC1D,CAAC;AALD,kBAKC;AAOD,SAAgB,IAAI,CAAE,IAAc;IAClC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;QACrB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;KACzD;IAED,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;AACjC,CAAC;AAND,oBAMC;AAQD,SAAgB,MAAM,CAAE,IAAc;IACpC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;QACrB,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;KAC9D;IAED,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;AACtG,CAAC;AAPD,wBAOC;AAED,SAAgB,SAAS,CAAE,GAAG,IAAa;IACzC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;QACrB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;KAC5D;IAED,KAAK,IAAI,cAAc,GAAG,CAAC,EAAE,UAAU,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC,MAAM,EAAE,cAAc,IAAI,CAAC,EAAE,UAAU,IAAI,CAAC,EAAE;QAC3G,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC;QACvC,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC;QAE/B,IAAI,OAAO,SAAS,KAAK,SAAS,EAAE;YAClC,MAAM,IAAI,KAAK,CAAC,wBAAwB,cAAc,qBAAqB,CAAC,CAAC;SAC9E;QAED,IAAI,SAAS,EAAE;YACb,IAAI,KAAK,KAAK,SAAS,EAAE;gBACvB,MAAM,IAAI,KAAK,CAAC,+DAA+D,cAAc,sBAAsB,CAAC,CAAC;aACtH;YACD,OAAO,KAAK,CAAC;SACd;KACF;IAED,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC3C,IAAI,YAAY,KAAK,SAAS,EAAE;QAC9B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;KAClE;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AA1BD,8BA0BC;AAED,SAAgB,oBAAoB;IAClC,OAAO;QACL,SAAS;KACV,CAAC;AACJ,CAAC;AAJD,oDAIC"}

package/dist/utils/solana.d.ts

@@ -0,0 +1 @@
+export declare function lamportsToSol(lamports: string): string;

package/dist/utils/solana.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lamportsToSol = void 0;
+function lamportsToSol(lamports) {
+    const paddedLamports = lamports.padStart(10, '0');
+    return paddedLamports.replace(/(.{9})$/, '.$1');
+}
+exports.lamportsToSol = lamportsToSol;
+//# sourceMappingURL=solana.js.map

package/dist/utils/solana.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solana.js","sourceRoot":"","sources":["../../src/utils/solana.ts"],"names":[],"mappings":";;;AAKA,SAAgB,aAAa,CAAE,QAAgB;IAC7C,MAAM,cAAc,GAAG,QAAQ,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IAClD,OAAO,cAAc,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AAClD,CAAC;AAHD,sCAGC"}

package/dist/utils/zip.d.ts

@@ -0,0 +1,2 @@
+export declare function zip<T1, T2, T3>(...iterables: [Iterable<T1>, Iterable<T2>, Iterable<T3>]): Generator<[T1, T2, T3]>;
+export declare function zip<T1, T2>(...iterables: [Iterable<T1>, Iterable<T2>]): Generator<[T1, T2]>;

package/dist/utils/zip.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zip = void 0;
+function* zip(...iterables) {
+    const iterators = iterables.map((iterable) => iterable[Symbol.iterator]());
+    while (true) {
+        const results = iterators.map((iter) => iter.next());
+        if (results.some((result) => result.done)) {
+            return;
+        }
+        yield results.map((result) => result.value);
+    }
+}
+exports.zip = zip;
+//# sourceMappingURL=zip.js.map

package/dist/utils/zip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.js","sourceRoot":"","sources":["../../src/utils/zip.ts"],"names":[],"mappings":";;;AAEA,QAAe,CAAC,CAAC,GAAG,CAAU,GAAG,SAA8B;IAC7D,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC3E,OAAO,IAAI,EAAE;QACX,MAAM,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACrD,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YACzC,OAAO;SACR;QACD,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;KAC7C;AACH,CAAC;AATD,kBASC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marinade.finance/scoring",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Delegation Strategy Scoring",
   "repository": {
     "type": "git",
@@ -10,21 +10,11 @@
     "access": "public"
   },
   "files": [
-    "computing",
-    "constants",
-    "dto",
-    "errors",
-    "interfaces",
-    "providers",
-    "utils",
+    "dist",
     "generated",
     "README.md"
   ],
-  "main": "index.js",
-  "scripts": {
-    "build": "tsc",
-    "test": "jest"
-  },
+  "main": "dist/index.js",
   "keywords": [
     "solana",
     "marinade.finance",
@@ -44,5 +34,9 @@
     "@types/node": "^20.12.7",
     "jest": "29.5.0",
     "ts-jest": "29.0.5"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
   }
 }

package/computing/cluster.ts

@@ -1,102 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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;
-}