@marinade.finance/scoring 1.0.0 → 1.0.2

package/src/utils/solana.ts

@@ -1,9 +0,0 @@
-/**
- * Converts a lamport value (as a string) to its equivalent in SOL, adding a decimal point before the last 9 digits.
- * @param {string} lamports - The lamport value to convert, represented as a string.
- * @return {string} The equivalent value in SOL, as a string.
- */
-export function lamportsToSol (lamports: string): string {
-  const paddedLamports = lamports.padStart(10, '0');
-  return paddedLamports.replace(/(.{9})$/, '.$1');
-}

package/src/utils/zip.ts

@@ -1,12 +0,0 @@
-export function zip<T1, T2, T3> (...iterables: [Iterable<T1>, Iterable<T2>, Iterable<T3>]): Generator<[T1, T2, T3]>
-export function zip<T1, T2> (...iterables: [Iterable<T1>, Iterable<T2>]): Generator<[T1, T2]>
-export function* zip<T1, T2> (...iterables: Iterable<T1 | T2>[]): Generator<(T1 | T2)[]> {
-  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);
-  }
-}

package/src/validators/validators.module.ts

@@ -1,48 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ValidatorsService } from './validators.service';
-import { ConfigService } from '../config/config.service';
-import { ApiDataProvider } from '../providers/api-data.provider';
-import { FileDataProvider } from '../providers/file-data.provider';
-import { ConfigModule } from '../config/config.module';
-
-@Module({
-  imports: [ConfigModule],
-  providers: [ValidatorsService, {
-    provide: 'IDataProvider',
-    useFactory: (configService: ConfigService) => {
-      const dataSourceType = configService.getDataProviderMode();
-      if (dataSourceType === 'api') {
-        return new ApiDataProvider(
-          {
-            validatorsURL: configService.getValidatorsURL(),
-            blacklistURL: configService.getBlacklistURL(),
-            vemndeVotesURL: configService.getVemndeVotesURL(),
-            msolVotesURL: configService.getMsolVotesURL(),
-            rewardsURL: configService.getRewardsURL(),
-            jitoMevURL: configService.getJitoMevURL(),
-            bondsURL: configService.getBondsURL(),
-            marinadeTvlURL: configService.getMarinadeTvlURL(),
-          }
-        );
-      } else if (dataSourceType === 'file') {
-        return new FileDataProvider(
-          {
-            validatorsPath: configService.getValidatorsPath(),
-            blacklistPath: configService.getBlacklistPath(),
-            vemndeVotesPath: configService.getVemndeVotesPath(),
-            msolVotesPath: configService.getMsolVotesPath(),
-            rewardsPath: configService.getRewardsPath(),
-            jitoMevPath: configService.getJitoMevPath(),
-            bondsPath: configService.getBondsPath(),
-            marinadeTvlPath: configService.getMarinadeTvlPath(),
-          }
-        );
-      } else {
-        throw new Error('Invalid data provider type');
-      }
-    },
-    inject: [ConfigService],
-  }],
-  exports: [ValidatorsService],
-})
-export class ValidatorsModule {}

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;
-  }
-}