@marinade.finance/scoring 1.0.0 → 1.0.1

package/src/validators/validators.service.ts

@@ -1,177 +0,0 @@
-import { AggregatedValidator, AggregatedValidators, ValidatorDto } from '../dto/validators.dto';
-import { IDataProvider } from '../interfaces/data-provider.interface';
-import { JitoValidatorDto } from '../dto/jito.dto';
-import { Inject } from '@nestjs/common';
-import { mean, sum } from '../utils/maths';
-import { ClusterInfo } from '../dto/cluster.dto';
-import { Votes } from '../dto/snapshots.dto';
-import { Bonds } from '../dto/bonds.dto';
-import { Rewards } from '../dto/rewards.dto';
-import { TvlStats } from '../dto/marinade.dto';
-
-export class ValidatorsService {
-  constructor (@Inject('IDataProvider') private dataProvider: IDataProvider) { }
-
-  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
-    };
-  }
-
-  async fetchTvlStats (withSnapshot: boolean): Promise<TvlStats> {
-    return await this.dataProvider.fetchTvl(withSnapshot);
-  }
-
-  async fetchValidators (epochsToFetch: number, withSnapshot: boolean): Promise<ValidatorDto[]> {
-    return this.dataProvider.fetchValidators(epochsToFetch, withSnapshot);
-  }
-
-  async fetchMsolVotes (withSnapshot: boolean): Promise<Votes> {
-    return await this.dataProvider.fetchMSolVotes(withSnapshot);
-  }
-
-  async fetchRewards (epochs:number, withSnapshot: boolean): Promise<Rewards> {
-    return await this.dataProvider.fetchRewards(epochs, withSnapshot);
-  }
-
-  async fetchVeMndeVotes (withSnapshot: boolean): Promise<Votes> {
-    return await this.dataProvider.fetchVeMndeVotes(withSnapshot);
-  }
-
-  async fetchBonds (withSnapshot: boolean): Promise<Bonds> {
-    return this.dataProvider.fetchBonds(withSnapshot);
-  }
-
-  async 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;
-  }
-
-  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);
-  }
-
-  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));
-  }
-
-  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)));
-  }
-
-  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;
-  }
-
-  selectCommissonInflationMax (validator: AggregatedValidator, epochs: number): number {
-    return Math.max(...validator.commission.slice(0, epochs));
-  }
-
-  selectCommissonMEV (validator: AggregatedValidator): number {
-    return validator.mevCommission;
-  }
-
-  selectCountryStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): number {
-    return clusterInfo.country.get(validator.country ?? '???') ?? 0;
-  }
-
-  selectCityStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): number {
-    return clusterInfo.city.get(validator.city ?? '???') ?? 0;
-  }
-
-  selectASOStakeConcentration (validator: AggregatedValidator, clusterInfo: ClusterInfo): number {
-    return clusterInfo.aso.get(validator.aso ?? '???') ?? 0;
-  }
-
-  selectNodeStake (validator: AggregatedValidator): number {
-    return validator.stake[0] ?? 0;
-  }
-}