@marinade.finance/scoring 1.0.0 → 1.0.1

package/{src/providers → providers}/api-data.provider.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
 import { Rewards, RewardsResponseDto } from '../dto/rewards.dto';
 import { Votes, mSolSnapshotDto, veMNDESnapshotDto } from '../dto/snapshots.dto';
 import { EpochStatDto, ValidatorDto, ValidatorsResponseDto } from '../dto/validators.dto';
@@ -10,6 +9,7 @@ import { writeFile } from 'fs/promises';
 import { Bonds, BondsDto } from '../dto/bonds.dto';
 import { TvlStats } from '../dto/marinade.dto';
 import axios, { AxiosError } from 'axios';
+import { error } from '../logger';
 
 export class URLs {
   validatorsURL: string;
@@ -23,7 +23,7 @@ export class URLs {
 }
 
 export class ApiDataProvider implements IDataProvider {
-  constructor (private urls: URLs) { }
+  constructor (private urls: URLs, private snapshotsBasePath?: string) { }
 
   async fetchValidators (epochsToFetch: number, withSnapshot = false): Promise<ValidatorDto[]> {
     try {
@@ -43,16 +43,16 @@ export class ApiDataProvider implements IDataProvider {
       }
 
       return rawData.validators;
-    } catch (error) {
+    } catch (err) {
       if (axios.isAxiosError(error)) {
         const axiosError = error as AxiosError;
         if (axiosError.response) {
-          console.error(FETCHING_ERROR_MESSAGES.validatorsFetchFailed, axiosError.response.status);
+          error(FETCHING_ERROR_MESSAGES.validatorsFetchFailed, axiosError.response.status);
         } else if (axiosError.request) {
-          console.error(FETCHING_ERROR_MESSAGES.generalValidatorsFetchFailed, axiosError.request);
+          error(FETCHING_ERROR_MESSAGES.generalValidatorsFetchFailed, axiosError.request);
         }
       }
-      throw error;
+      throw err;
     }
   }
 
@@ -63,20 +63,20 @@ export class ApiDataProvider implements IDataProvider {
       const data: TvlStats = response.data;
 
       if (withSnapshot) {
-        await writeFile('./snapshot/tvl.json', JSON.stringify(data, null, 2));
+        await writeFile(`${this.snapshotsBasePath}/tvl.json`, JSON.stringify(data, null, 2));
       }
 
       return data;
-    } catch (error) {
+    } catch (err) {
       if (axios.isAxiosError(error)) {
         const axiosError = error as AxiosError;
         if (axiosError.response) {
-          console.error(FETCHING_ERROR_MESSAGES.tvlFetchFailed, axiosError.response.status);
+          error(FETCHING_ERROR_MESSAGES.tvlFetchFailed, axiosError.response.status);
         } else if (axiosError.request) {
-          console.error(FETCHING_ERROR_MESSAGES.generalTvlFetchFailed, axiosError.request);
+          error(FETCHING_ERROR_MESSAGES.generalTvlFetchFailed, axiosError.request);
         }
       }
-      throw error;
+      throw err;
     }
   }
 
@@ -91,21 +91,21 @@ export class ApiDataProvider implements IDataProvider {
       }, {} as Bonds);
 
       if (withSnapshot) {
-        await writeFile('./snapshot/bonds.json', JSON.stringify(data, null, 2));
+        await writeFile(`${this.snapshotsBasePath}/bonds.json`, JSON.stringify(data, null, 2));
       }
 
       return bonds;
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        const axiosError = error as AxiosError;
+    } catch (err) {
+      if (axios.isAxiosError(err)) {
+        const axiosError = err as AxiosError;
         if (axiosError.response) {
-          console.error(FETCHING_ERROR_MESSAGES.bondsFetchFailed, axiosError.response.status);
+          error(FETCHING_ERROR_MESSAGES.bondsFetchFailed, axiosError.response.status);
         } else if (axiosError.request) {
-          console.error(FETCHING_ERROR_MESSAGES.generalBondsFetchFailed, axiosError.request);
+          error(FETCHING_ERROR_MESSAGES.generalBondsFetchFailed, axiosError.request);
         }
       }
 
-      throw error;
+      throw err;
     }
   }
 
@@ -118,7 +118,7 @@ export class ApiDataProvider implements IDataProvider {
       const csv: string = response.data;
 
       if (withSnapshot) {
-        await writeFile('./snapshot/blacklist.csv', csv);
+        await writeFile(`${this.snapshotsBasePath}/blacklist.csv`, csv);
       }
 
       const blacklistSet = new Set(
@@ -129,16 +129,16 @@ export class ApiDataProvider implements IDataProvider {
       );
 
       return blacklistSet;
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        if (error.response) {
-          console.error(FETCHING_ERROR_MESSAGES.blacklistFetchFailed, error.response.status);
-        } else if (error.request) {
-          console.error(FETCHING_ERROR_MESSAGES.generalBlacklistFetchFailed, error.request);
+    } catch (err) {
+      if (axios.isAxiosError(err)) {
+        if (err.response) {
+          error(FETCHING_ERROR_MESSAGES.blacklistFetchFailed, err.response.status);
+        } else if (err.request) {
+          error(FETCHING_ERROR_MESSAGES.generalBlacklistFetchFailed, err.request);
         }
       }
 
-      throw error;
+      throw err;
     }
   }
 
@@ -148,7 +148,7 @@ export class ApiDataProvider implements IDataProvider {
       const data: veMNDESnapshotDto = response.data;
 
       if (withSnapshot) {
-        await writeFile('./snapshot/vemnde-votes.json', JSON.stringify(data, null, 2));
+        await writeFile(`${this.snapshotsBasePath}/vemnde-votes.json`, JSON.stringify(data, null, 2));
       }
 
       const result: Votes = {};
@@ -160,16 +160,16 @@ export class ApiDataProvider implements IDataProvider {
       }
 
       return result;
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        if (error.response) {
-          console.error(FETCHING_ERROR_MESSAGES.vemndeFetchFailed, error.response.status);
-        } else if (error.request) {
-          console.error(FETCHING_ERROR_MESSAGES.generalVemndeFetchFailed, error.request);
+    } catch (err) {
+      if (axios.isAxiosError(err)) {
+        if (err.response) {
+          error(FETCHING_ERROR_MESSAGES.vemndeFetchFailed, err.response.status);
+        } else if (err.request) {
+          error(FETCHING_ERROR_MESSAGES.generalVemndeFetchFailed, err.request);
         }
       }
 
-      throw error;
+      throw err;
     }
   }
 
@@ -179,7 +179,7 @@ export class ApiDataProvider implements IDataProvider {
       const data: mSolSnapshotDto = response.data;
 
       if (withSnapshot) {
-        await writeFile('./snapshot/msol-votes.json', JSON.stringify(data, null, 2));
+        await writeFile(`${this.snapshotsBasePath}/msol-votes.json`, JSON.stringify(data, null, 2));
       }
 
       const result: Votes = {};
@@ -191,16 +191,16 @@ export class ApiDataProvider implements IDataProvider {
       }
 
       return result;
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        if (error.response) {
-          console.error(FETCHING_ERROR_MESSAGES.msolFetchFailed, error.response.status);
-        } else if (error.request) {
-          console.error(FETCHING_ERROR_MESSAGES.generalMsolFetchFailed, error.request);
+    } catch (err) {
+      if (axios.isAxiosError(err)) {
+        if (err.response) {
+          error(FETCHING_ERROR_MESSAGES.msolFetchFailed, err.response.status);
+        } else if (err.request) {
+          error(FETCHING_ERROR_MESSAGES.generalMsolFetchFailed, err.request);
         }
       }
 
-      throw error;
+      throw err;
     }
   }
 
@@ -214,23 +214,23 @@ export class ApiDataProvider implements IDataProvider {
       const data = new RewardsResponseDto(jsonResponse);
 
       if (withSnapshot) {
-        await writeFile('./snapshot/rewards.json', JSON.stringify(jsonResponse, null, 2));
+        await writeFile(`${this.snapshotsBasePath}/rewards.json`, JSON.stringify(jsonResponse, null, 2));
       }
 
       const mev = sum(data.rewards_mev.map(dto => dto.amount));
       const inflation = sum(data.rewards_inflation_est.map(dto => dto.amount));
 
       return { inflation, mev };
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        if (error.response) {
-          console.error(FETCHING_ERROR_MESSAGES.rewardsFetchFailed, error.response.status);
-        } else if (error.request) {
-          console.error(FETCHING_ERROR_MESSAGES.generalRewardsFetchFailed, error.request);
+    } catch (err) {
+      if (axios.isAxiosError(err)) {
+        if (err.response) {
+          error(FETCHING_ERROR_MESSAGES.rewardsFetchFailed, err.response.status);
+        } else if (err.request) {
+          error(FETCHING_ERROR_MESSAGES.generalRewardsFetchFailed, err.request);
         }
       }
 
-      throw error;
+      throw err;
     }
   }
 
@@ -240,22 +240,22 @@ export class ApiDataProvider implements IDataProvider {
       const jitoMevRecords: JitoValidatorsResponseDto = response.data;
 
       if (withSnapshot) {
-        await writeFile('./snapshot/jito-mev-records.json', JSON.stringify(jitoMevRecords, null, 2));
+        await writeFile(`${this.snapshotsBasePath}/jito-mev-records.json`, JSON.stringify(jitoMevRecords, null, 2));
       }
 
       return Object.fromEntries(
         jitoMevRecords.validators.map((validator) => [validator.vote_account, validator])
       );
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        if (error.response) {
-          console.error(FETCHING_ERROR_MESSAGES.jitoMevFetchFailed, error.response.status);
-        } else if (error.request) {
-          console.error(FETCHING_ERROR_MESSAGES.generalJitoMEVFetchFailed, error.request);
+    } catch (err) {
+      if (axios.isAxiosError(err)) {
+        if (err.response) {
+          error(FETCHING_ERROR_MESSAGES.jitoMevFetchFailed, err.response.status);
+        } else if (err.request) {
+          error(FETCHING_ERROR_MESSAGES.generalJitoMEVFetchFailed, err.request);
         }
       }
 
-      throw error;
+      throw err;
     }
   }
 }

package/{src/providers → providers}/file-data.provider.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-console */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { TvlStats } from '../dto/marinade.dto';
 import { Bonds, BondsDto } from '../dto/bonds.dto';
@@ -10,6 +9,7 @@ import { readFile } from 'fs/promises';
 import { FETCHING_ERROR_MESSAGES } from '../errors/fetching';
 import { sum } from '../utils/maths';
 import { Votes, mSolSnapshotDto } from '../dto/snapshots.dto';
+import { error } from 'logger';
 
 class Paths {
   validatorsPath: string;
@@ -38,25 +38,21 @@ export class FileDataProvider implements IDataProvider {
       });
 
       return validatorsData.validators;
-    } catch (error) {
-      console.error(FETCHING_ERROR_MESSAGES.generalValidatorsFetchFailed, error);
-      throw error;
+    } catch (err) {
+      error(FETCHING_ERROR_MESSAGES.generalValidatorsFetchFailed, err);
+      throw err;
     }
   }
-
   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);
@@ -68,7 +64,6 @@ export class FileDataProvider implements IDataProvider {
 
     return bonds;
   }
-
   async fetchVeMndeVotes (): Promise<Record<string, number>> {
     const vemndeVotesFile = await readFile(this.paths.vemndeVotesPath, 'utf8');
     const vemndeVotesData = JSON.parse(vemndeVotesFile) as mSolSnapshotDto;
@@ -82,7 +77,6 @@ export class FileDataProvider implements IDataProvider {
 
     return result;
   }
-
   async fetchMSolVotes (): Promise<Record<string, number>> {
     const msolVotesFile = await readFile(this.paths.msolVotesPath, 'utf8');
     const msolVotesData = JSON.parse(msolVotesFile) as mSolSnapshotDto;
@@ -96,7 +90,6 @@ export class FileDataProvider implements IDataProvider {
 
     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][] };
@@ -108,7 +101,6 @@ export class FileDataProvider implements IDataProvider {
 
     return { inflation, mev };
   }
-
   async fetchValidatorsJitoMEV (): Promise<Record<string, JitoValidatorDto>> {
     try {
       const jitoMevFile = await readFile(this.paths.jitoMevPath, 'utf8');
@@ -117,9 +109,9 @@ export class FileDataProvider implements IDataProvider {
       return Object.fromEntries(
         jitoMevData.validators.map((validator) => [validator.vote_account, validator])
       );
-    } catch (error) {
-      console.error(FETCHING_ERROR_MESSAGES.generalJitoMEVFetchFailed, error);
-      throw error;
+    } catch (err) {
+      error(FETCHING_ERROR_MESSAGES.generalJitoMEVFetchFailed, err);
+      throw err;
     }
   }
 }

package/{src/utils → utils}/csv.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable no-console */
 import * as fs from 'fs';
 import { Score } from '../dto/scoring.dto';
+import { error } from 'logger';
 
-export function writeScoresToCsv (filePath: string, data: Score[]): void {
+export function writeScoresToCsv(filePath: string, data: Score[]): void {
   if (data.length === 0) {
     console.error('Data array is empty, no CSV will be written.');
     return;
@@ -24,7 +24,7 @@ export function writeScoresToCsv (filePath: string, data: Score[]): void {
 
   fs.writeFile(filePath, csvString, (err) => {
     if (err) {
-      console.error('Error writing CSV file:', err);
+      error('Error writing CSV file:', err);
     }
   });
 }

package/src/cluster/cluster.module.ts

@@ -1,8 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ClusterService } from './cluster.service';
-
-@Module({
-  providers: [ClusterService],
-  exports: [ClusterService],
-})
-export class ClusterModule {}

package/src/cluster/cluster.service.ts

@@ -1,108 +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 class ClusterService {
-  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),
-    };
-  }
-
-  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 stakeInLamports = activatedStakeDecimal.dividedBy(1e9);
-
-          const prevSumOfWeightedCredits = sumOfWeightedCreditsPerEpoch.get(epochStat.epoch) || new Decimal(0);
-          sumOfWeightedCreditsPerEpoch.set(epochStat.epoch, prevSumOfWeightedCredits.plus(new Decimal(epochStat.credits).times(stakeInLamports)));
-
-          const prevSumOfWeightsPerEpoch = sumOfWeightsPerEpoch.get(epochStat.epoch) || new Decimal(0);
-          sumOfWeightsPerEpoch.set(epochStat.epoch, prevSumOfWeightsPerEpoch.plus(stakeInLamports));
-        }
-      });
-    });
-
-    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;
-  }
-
-  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 };
-  }
-
-  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/src/config/config.module.ts

@@ -1,8 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ConfigService } from './config.service';
-
-@Module({
-  providers: [ConfigService],
-  exports: [ConfigService],
-})
-export class ConfigModule {}

package/src/config/config.service.ts

@@ -1,136 +0,0 @@
-import * as dotenv from 'dotenv';
-import { Injectable } from '@nestjs/common';
-import { Logger } from '../../../../src/logger';
-import { ScoringConfig } from '../dto/scoring.dto';
-import { readFileSync } from 'fs';
-import * as defaultScoringConfig from '../constants/marinade.json';
-
-dotenv.config();
-
-@Injectable()
-export class ConfigService {
-  private readonly logger = new Logger();
-  readonly scoringConfig: ScoringConfig;
-  private getEnvVar (key: string): string {
-    const val = process.env[key];
-    if (!val) {
-      this.logger.error(`Missing environment variable: ${key}`);
-      throw new Error(`Missing environment variable: ${key}`);
-    }
-    return val;
-  }
-
-  getScoringConfig (): ScoringConfig {
-    const scoringConfigPath = process.env['SCORING_CONFIG_PATH'];
-
-    if (!scoringConfigPath) {
-      return {
-        DS_PUBKEY: defaultScoringConfig.DS_PUBKEY,
-        REWARDS_PAST_EPOCHS: defaultScoringConfig.REWARDS_PAST_EPOCHS,
-        CAP_FROM_BOND: defaultScoringConfig.CAP_FROM_BOND,
-        formulaStakeBlockSize: defaultScoringConfig.formulaStakeBlockSize,
-        formulaStakeBlocksFromScore: defaultScoringConfig.formulaStakeBlocksFromScore,
-        formulaVoteCredits: defaultScoringConfig.formulaVoteCredits,
-        formulaBlockProduction: defaultScoringConfig.formulaBlockProduction,
-        formulaInflationCommission: defaultScoringConfig.formulaInflationCommission,
-        formulaMEVCommission: defaultScoringConfig.formulaMEVCommission,
-        formulaStakeConcentrationCountry: defaultScoringConfig.formulaStakeConcentrationCountry,
-        formulaStakeConcentrationCity: defaultScoringConfig.formulaStakeConcentrationCity,
-        formulaStakeConcentrationASO: defaultScoringConfig.formulaStakeConcentrationASO,
-        formulaStakeConcentrationNode: defaultScoringConfig.formulaStakeConcentrationNode,
-        weightTargetSumOfRewards: defaultScoringConfig.weightTargetSumOfRewards,
-        weightMevHeuristic: defaultScoringConfig.weightMevHeuristic,
-        weightVoteCredits: defaultScoringConfig.weightVoteCredits,
-        weightBlockProduction: defaultScoringConfig.weightBlockProduction,
-        weightInflationCommission: defaultScoringConfig.weightInflationCommission,
-        weightMEVCommission: defaultScoringConfig.weightMEVCommission,
-        weightStakeConcentrationCountry: defaultScoringConfig.weightStakeConcentrationCountry,
-        weightStakeConcentrationCity: defaultScoringConfig.weightStakeConcentrationCity,
-        weightStakeConcentrationASO: defaultScoringConfig.weightStakeConcentrationASO,
-        weightStakeConcentrationNode: defaultScoringConfig.weightStakeConcentrationNode,
-        basicEligibilityEpochs: defaultScoringConfig.basicEligibilityEpochs,
-        bonusEligibilityExtraEpochs: defaultScoringConfig.bonusEligibilityExtraEpochs,
-        maxCommission: defaultScoringConfig.maxCommission,
-        voteCreditsWarning: defaultScoringConfig.voteCreditsWarning,
-        voteCreditsLow: defaultScoringConfig.voteCreditsLow,
-        minExternalStake: defaultScoringConfig.minExternalStake,
-        minScore: defaultScoringConfig.minScore,
-        maxStakeShare: defaultScoringConfig.maxStakeShare,
-        maxWarnings: defaultScoringConfig.maxWarnings,
-        mSolControl: defaultScoringConfig.mSolControl,
-        veMndeControl: defaultScoringConfig.veMndeControl,
-        stakeBlocksFromBonus: defaultScoringConfig.stakeBlocksFromBonus,
-        concentrationParams: defaultScoringConfig.concentrationParams,
-      };
-    } else {
-      const scoringConfigData = readFileSync(scoringConfigPath, 'utf8');
-      return JSON.parse(scoringConfigData) as ScoringConfig;
-    }
-  }
-
-  getDataProviderMode (): string {
-    return this.getEnvVar('DATA_PROVIDER_MODE');
-  }
-
-  getMarinadeTvlURL (): string {
-    return this.getEnvVar('MARINADE_TVL_URL');
-  }
-
-  getValidatorsURL (): string {
-    return this.getEnvVar('VALIDATORS_URL');
-  }
-
-  getBlacklistURL (): string {
-    return this.getEnvVar('BLACKLIST_URL');
-  }
-
-  getBondsURL (): string {
-    return this.getEnvVar('BONDS_URL');
-  }
-
-  getVemndeVotesURL (): string {
-    return this.getEnvVar('VEMNDE_VOTES_URL');
-  }
-
-  getMsolVotesURL (): string {
-    return this.getEnvVar('MSOL_VOTES_URL');
-  }
-
-  getRewardsURL (): string {
-    return this.getEnvVar('REWARDS_URL');
-  }
-  getJitoMevURL (): string {
-    return this.getEnvVar('JITO_MEV_URL');
-  }
-  getValidatorsPath (): string {
-    return this.getEnvVar('VALIDATORS_PATH');
-  }
-
-  getBlacklistPath (): string {
-    return this.getEnvVar('BLACKLIST_PATH');
-  }
-
-  getVemndeVotesPath (): string {
-    return this.getEnvVar('VEMNDE_VOTES_PATH');
-  }
-
-  getMsolVotesPath (): string {
-    return this.getEnvVar('MSOL_VOTES_PATH');
-  }
-
-  getRewardsPath (): string {
-    return this.getEnvVar('REWARDS_PATH');
-  }
-
-  getJitoMevPath (): string {
-    return this.getEnvVar('JITO_MEV_PATH');
-  }
-
-  getBondsPath (): string {
-    return this.getEnvVar('JITO_MEV_PATH');
-  }
-
-  getMarinadeTvlPath (): string {
-    return this.getEnvVar('MARINADE_TVL_PATH');
-  }
-}

package/src/eligibility/eligibility.module.ts

@@ -1,11 +0,0 @@
-import { Module } from '@nestjs/common';
-import { EligibilityService } from './eligibility.service';
-import { ValidatorsModule } from '../validators/validators.module';
-import { ConfigModule } from '../config/config.module';
-
-@Module({
-  imports: [ValidatorsModule, ConfigModule],
-  providers: [EligibilityService],
-  exports: [EligibilityService],
-})
-export class EligibilityModule {}