@marinade.finance/scoring 1.0.1 → 1.0.3

package/computing/stake.ts

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

package/computing/validators.ts

@@ -1,133 +0,0 @@
-import { AggregatedValidator, AggregatedValidators, ValidatorDto } from '../dto/validators.dto';
-import { JitoValidatorDto } from '../dto/jito.dto';
-import { mean, sum } from '../utils/maths';
-import { ClusterInfo } from '../dto/cluster.dto';
-
-export function aggregateValidatorData (
-  validator: ValidatorDto,
-  mevRecord: JitoValidatorDto,
-  blacklist: Set<string>,
-  firstEpoch: number,
-  lastEpoch: number
-): AggregatedValidator {
-  const currentMarinadeStake = Number(validator.epochStats[lastEpoch]?.marinade_native_stake || 0) / 1e9 + Number(validator.epochStats[lastEpoch]?.marinade_stake || 0) / 1e9;
-  const voteAccount = validator.vote_account;
-  const name = validator.info_name || 'Unknown';
-  const epochs: number[] = [];
-  const commission: number[] = [];
-  const stake: number[] = [];
-  const externalStake: number[] = [];
-  const credits: number[] = [];
-  const blocksProduced: number[] = [];
-  const leaderSlots: number[] = [];
-  const dataAvailable: boolean[] = [];
-
-  const currentStake = Number(validator.epochStats[lastEpoch]?.activated_stake || 0) / 1e9;
-
-  const blacklisted = blacklist.has(voteAccount);
-
-  for (let epoch = lastEpoch; epoch >= firstEpoch; epoch--) {
-    const epochStat = validator.epochStats?.[epoch];
-
-    epochs.push(epoch);
-    commission.push(epochStat?.commission_max_observed || epochStat?.commission_advertised || 0);
-    stake.push(Number(epochStat?.activated_stake || 0) / 1e9);
-    externalStake.push(Number(epochStat?.activated_stake || 0) / 1e9 - Number(epochStat?.marinade_stake || 0) / 1e9 - Number(epochStat?.marinade_native_stake || 0) / 1e9);
-    credits.push(epochStat?.credits || 0);
-    blocksProduced.push(epochStat?.blocks_produced || 0);
-    leaderSlots.push(epochStat?.leader_slots || 0);
-    dataAvailable.push(!!epochStat);
-  }
-
-  const mevCommission = mevRecord?.running_jito ? mevRecord.mev_commission_bps / 100 : 100;
-  return {
-    voteAccount,
-    name,
-    epochs,
-    currentMarinadeStake,
-    currentStake,
-    commission,
-    stake,
-    externalStake,
-    credits,
-    blocksProduced,
-    leaderSlots,
-    dataAvailable,
-    mevCommission,
-    country: validator.dc_country || 'Unknown',
-    city: validator.dc_full_city || 'Unknown',
-    aso: validator.dc_aso || 'Unknown',
-    blacklisted,
-    version: validator.version
-  };
-}
-export async function aggregateValidatorsData (
-  validators: ValidatorDto[],
-  basicEligibilityEpochs: number,
-  bonusEligibilityExtraEpochs: number
-): Promise<AggregatedValidators> {
-  const lastEpoch = this.getMaxEpoch(validators);
-  const firstEpoch = lastEpoch - basicEligibilityEpochs - bonusEligibilityExtraEpochs;
-
-  const jitoMevRecords: Record<string, JitoValidatorDto> = await this.dataProvider.fetchValidatorsJitoMEV(true);
-  const blacklist: Set<string> = await this.dataProvider.fetchBlacklist(true);
-
-  const result: { [voteAccount: string]: AggregatedValidator } = {};
-
-  for (const validator of validators) {
-    const mevRecord = jitoMevRecords[validator.vote_account] ?? {
-      vote_account: validator.vote_account,
-      mev_commission_bps: 100,
-      running_jito: false,
-      active_stake: Number(validator.activated_stake)
-    } as JitoValidatorDto;
-
-    if (mevRecord) {
-      const aggregatedData = this.aggregateValidatorData(validator, mevRecord, blacklist, firstEpoch, lastEpoch);
-      result[validator.vote_account] = aggregatedData;
-    }
-  }
-
-  return result;
-}
-export function getMaxEpoch (validators: ValidatorDto[]): number {
-  return validators.reduce((maxEpoch, validator) => {
-    const validatorMaxEpoch = validator.epoch_stats.reduce((max, { epoch }) => {
-      return Math.max(epoch, max);
-    }, 0);
-    return Math.max(maxEpoch, validatorMaxEpoch);
-  }, 0);
-}
-export function selectExternalStakeMin (validator: AggregatedValidator, fullEpochs: number): number {
-  if (validator.externalStake.length === 0) {
-    throw new Error('Validator has no external stake data.');
-  }
-  return Math.min(...validator.externalStake.slice(0, fullEpochs + 1));
-}
-export function selectCreditsPctMean (validator: AggregatedValidator, clusterInfo: ClusterInfo, fullEpochs: number): number {
-  return mean(validator.epochs.slice(1, fullEpochs + 1).map((epoch, fullEpochIndex) =>
-    (validator.credits[fullEpochIndex + 1] ?? 0) / (clusterInfo.targetCreditsByEpoch.get(epoch) ?? 1)));
-}
-export function selectBlockProductionMean (validator: AggregatedValidator, fullEpochs: number): number {
-  const leaderSlots = sum(validator.leaderSlots.slice(1, fullEpochs + 1));
-  return leaderSlots === 0 ? 1 : sum(validator.blocksProduced.slice(1, fullEpochs + 1)) / leaderSlots;
-}
-export function selectCommissionInflationMax (validator: AggregatedValidator, epochs: number): number {
-  return Math.max(...validator.commission.slice(0, epochs));
-}
-export function selectCommissionMEV (validator: AggregatedValidator): number {
-  return validator.mevCommission;
-}
-export function selectCountryStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): number {
-  return clusterInfo.country.get(validator.country ?? '???') ?? 0;
-}
-export function selectCityStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): number {
-  return clusterInfo.city.get(validator.city ?? '???') ?? 0;
-}
-export function selectASOStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): number {
-  return clusterInfo.aso.get(validator.aso ?? '???') ?? 0;
-}
-export function selectNodeStake (validator: AggregatedValidator): number {
-  return validator.stake[0] ?? 0;
-}
-

package/constants/marinade.json

@@ -1,38 +0,0 @@
-{
-  "DS_PUBKEY": "MarinadeA1gorithmicDe1egationStrategy111111",
-  "REWARDS_PAST_EPOCHS": 14,
-  "CAP_FROM_BOND": 1000000000,
-  "formulaStakeBlockSize": "tvl / ((6000000 /  30000) * 1.5 ^ (log(tvl / 6000000) / log(2)))",
-  "formulaStakeBlocksFromScore": "1 + ((max(0.94, score) - 0.94) / (1 - 0.94)) ^ 10",
-  "formulaVoteCredits": "min(credits_pct_mean ^ 10, 1)",
-  "formulaBlockProduction": "piecewise((bp_mean - bp_cluster_mean) / bp_cluster_std_dev < -1, bp_mean / (bp_cluster_mean - bp_cluster_std_dev), 1)",
-  "formulaInflationCommission": "piecewise(commission_inflation_max <= 10, (100 - commission_inflation_max) / 100, 0)",
-  "formulaMEVCommission": "(100 - commission_mev) / 100",
-  "formulaStakeConcentrationCountry": "piecewise(country_stake_concentration_last < 1/3, (1 - (3 * country_stake_concentration_last)) ^ (1/3), 0)",
-  "formulaStakeConcentrationCity": "piecewise(city_stake_concentration_last < 1/3, (1 - (3 * city_stake_concentration_last)) ^ (1/3), 0)",
-  "formulaStakeConcentrationASO": "piecewise(aso_stake_concentration_last < 1/3, (1 - (3 * aso_stake_concentration_last)) ^ (1/3), 0)",
-  "formulaStakeConcentrationNode": "piecewise(node_stake_last < 100000, 1, node_stake_last < 4000000, 1 - (node_stake_last - 100000) / (4000000 - 100000), 0)",
-  "weightTargetSumOfRewards": 5,
-  "weightMevHeuristic": 0.1,
-  "weightVoteCredits": 10,
-  "weightBlockProduction": 5,
-  "weightInflationCommission": 4.9,
-  "weightMEVCommission": 0.1,
-  "weightStakeConcentrationCountry": 2,
-  "weightStakeConcentrationCity": 3,
-  "weightStakeConcentrationASO": 4,
-  "weightStakeConcentrationNode": 2,
-  "basicEligibilityEpochs": 14,
-  "bonusEligibilityExtraEpochs": 0,
-  "maxCommission": 7,
-  "voteCreditsWarning": 0,
-  "voteCreditsLow": 80,
-  "minExternalStake": 0,
-  "minScore": 0.8,
-  "maxStakeShare": 0.8,
-  "maxWarnings": 1,
-  "mSolControl": 0.2,
-  "veMndeControl": 0.2,
-  "stakeBlocksFromBonus": 0,
-  "concentrationParams": [4, 5, 6, 7]
-}

package/dto/bonds.dto.ts

@@ -1,12 +0,0 @@
-export type BondDto = {
-  pubkey: string;
-  vote_account: string;
-  authority: string;
-  cpmpe: number;
-  updated_at: string;
-  epoch: number;
-}
-export type BondsDto = {
-  bonds: BondDto[];
-}
-export type Bonds = Record<string, number>;

package/dto/cluster.dto.ts

@@ -1,12 +0,0 @@
-export type ClusterInfo = {
-    city: Map<string, number>,
-    country: Map<string, number>,
-    aso: Map<string, number>,
-    targetCreditsByEpoch: Map<number, number>,
-    meanBlockProductionOverBasicEligibilityPeriod: number,
-    stdDevBlockProductionOverBasicEligibilityPeriod: number,
-}
-export type BlockProductionResult = {
-  mean: number;
-  stdDev: number;
-}

package/dto/jito.dto.ts

@@ -1,9 +0,0 @@
-export class JitoValidatorDto {
-  vote_account: string;
-  mev_commission_bps: number;
-  running_jito: boolean;
-  active_stake: number;
-}
-export class JitoValidatorsResponseDto {
-  validators: JitoValidatorDto[];
-}

package/dto/marinade.dto.ts

@@ -1,18 +0,0 @@
-export type TvlStats = {
-  staked_sol: number;
-  staked_usd: number;
-  msol_directed_stake_sol: number;
-  msol_directed_stake_msol: number;
-  liquidity_sol: number;
-  liquidity_usd: number;
-  total_sol: number;
-  total_usd: number;
-  self_staked_sol: number;
-  self_staked_usd: number;
-  standard_staked_sol: number;
-  standard_staked_usd: number;
-  total_virtual_staked_sol: number;
-  total_virtual_staked_usd: number;
-  marinade_native_stake_sol: number;
-  marinade_native_stake_usd: number;
-}

package/dto/rewards.dto.ts

@@ -1,19 +0,0 @@
-export class RewardPairDto {
-  epoch: number;
-  amount: number;
-
-  constructor (pair: [number, number]) {
-    this.epoch = pair[0];
-    this.amount = pair[1];
-  }
-}
-export class RewardsResponseDto {
-  rewards_mev: RewardPairDto[];
-  rewards_inflation_est: RewardPairDto[];
-
-  constructor (data: { rewards_mev: [number, number][], rewards_inflation_est: [number, number][] }) {
-    this.rewards_mev = data.rewards_mev.map(pair => new RewardPairDto(pair));
-    this.rewards_inflation_est = data.rewards_inflation_est.map(pair => new RewardPairDto(pair));
-  }
-}
-export type Rewards = { inflation: number, mev: number }

package/dto/scoring.dto.ts

@@ -1,103 +0,0 @@
-import { ClusterInfo } from './cluster.dto';
-import { AggregatedValidator } from './validators.dto';
-
-export type ScoreDto = {
-    score: number,
-    concentrationScore: number,
-    scores: number[]
-    values: number[]
-    scoreErrors: boolean[]
-    tooltips: string[]
-}
-export type Score = {
-    vote_account: string,
-    score: string,
-    score_credits: string,
-    score_block_production: string,
-    score_inflation_commission: string,
-    score_mev_commission: string,
-    score_country_concentration: string,
-    score_city_concentration: string,
-    score_aso_concentration: string,
-    score_node_concentration: string,
-    ui_hints: string,
-    eligible_stake_algo: number;
-    eligible_bonus: number;
-    in_algo_stake_set: number;
-    msol_votes: string;
-    vemnde_votes: string;
-    blacklisted: number,
-    rank: number,
-    version: string,
-    max_commission: number,
-    marinade_stake: string,
-    target_stake_vemnde: string,
-    target_stake_msol: string,
-    target_stake_algo: string,
-    target_stake: string,
-}
-export type ScoreConfig = {
-    epochs: number,
-    concentrationParams: number[]
-}
-export type ScoringConfig = {
-  DS_PUBKEY: string;
-  REWARDS_PAST_EPOCHS: number;
-  CAP_FROM_BOND: number;
-  formulaStakeBlockSize: string;
-  formulaStakeBlocksFromScore: string;
-  formulaVoteCredits: string;
-  formulaBlockProduction: string;
-  formulaInflationCommission: string;
-  formulaMEVCommission: string;
-  formulaStakeConcentrationCountry: string;
-  formulaStakeConcentrationCity: string;
-  formulaStakeConcentrationASO: string;
-  formulaStakeConcentrationNode: string;
-  weightTargetSumOfRewards: number;
-  weightMevHeuristic: number;
-  weightVoteCredits: number;
-  weightBlockProduction: number;
-  weightInflationCommission: number;
-  weightMEVCommission: number;
-  weightStakeConcentrationCountry: number;
-  weightStakeConcentrationCity: number;
-  weightStakeConcentrationASO: number;
-  weightStakeConcentrationNode: number;
-  basicEligibilityEpochs: number;
-  bonusEligibilityExtraEpochs: number;
-  maxCommission: number;
-  voteCreditsWarning: number;
-  voteCreditsLow: number;
-  minExternalStake: number;
-  minScore: number;
-  maxStakeShare: number;
-  maxWarnings: number;
-  mSolControl: number;
-  veMndeControl: number;
-  stakeBlocksFromBonus: number;
-  concentrationParams: number[];
-};
-
-export type Variables = {
-    bp_cluster_mean: number;
-    bp_cluster_std_dev: number;
-    credits_pct_mean: number;
-    bp_mean: number;
-    commission_inflation_max: number;
-    commission_mev: number;
-    country_stake_concentration_last: number;
-    city_stake_concentration_last: number;
-    aso_stake_concentration_last: number;
-    node_stake_last: number;
-};
-export type Scores = Record<string, ScoreDto>
-export type ScoreTooltipBuilder = (validator: AggregatedValidator, clusterInfo: ClusterInfo) => string
-export type UnstakeHint = {
-  vote_account: string;
-  marinade_stake: string;
-  hints: string[];
-};
-export type UnstakeHints = {
-  unstake_hints: UnstakeHint[];
-};

package/dto/snapshots.dto.ts

@@ -1,16 +0,0 @@
-export class RecordDto {
-  amount: string | null;
-  tokenOwner: string;
-  validatorVoteAccount: string;
-}
-export class veMNDESnapshotDto {
-  voteRecordsCreatedAt: string;
-  records: RecordDto[];
-}
-export class mSolSnapshotDto {
-  mSolSnapshotCreatedAt: string;
-  voteRecordsCreatedAt: string;
-  records: RecordDto[];
-}
-export type Votes = Record<string, number>
-

package/dto/stakes.dto.ts

@@ -1,31 +0,0 @@
-import { Votes } from './snapshots.dto';
-
-export type StakesConfig = {
-    tvl: number
-    mSolControl: number
-    veMndeControl: number
-    stakeBlocksFromBonus: number
-    formulaStakeBlockSize: string
-    formulaStakeBlocksFromScore: string
-}
-export type Stake = {
-    algoStake: number
-    mSolStake: number
-    veMndeStake: number
-    totalStake: number
-    algoStakeFromOverflow: number
-    mSolStakeFromOverflow: number
-    veMndeStakeFromOverflow: number
-    totalStakeFromOverlfow: number
-}
-export type ProcessedVotesAndTVLs = {
-    updatedMSolVotes: Votes;
-    updatedVeMndeVotes: Votes;
-    mSolTvl: number;
-    veMndeTvl: number;
-    totalTvl: number;
-};
-export type StakingVariables = {
-    tvl: number;
-}
-export type Stakes = Record<string, Stake>