@marinade.finance/scoring 1.0.0

package/src/dto/validators.dto.ts

@@ -0,0 +1,146 @@
+
+export class WarningDto {
+  warning: string;
+}
+
+export class EpochStatDto {
+
+  epoch: number;
+
+  epoch_start_at: string;
+
+  epoch_end_at?: string;
+
+  commission_max_observed?: number | null;
+
+  commission_min_observed?: number | null;
+
+  commission_advertised: number;
+
+  commission_effective?: number | null;
+
+  version: string;
+
+  activated_stake: string;
+
+  marinade_stake: string;
+
+  foundation_stake: string;
+
+  marinade_native_stake: string;
+
+  self_stake: string;
+
+  superminority: boolean;
+
+  stake_to_become_superminority: string;
+
+  credits: number;
+
+  leader_slots: number;
+
+  blocks_produced: number;
+
+  skip_rate: number;
+
+  uptime_pct?: number | null;
+
+  uptime?: number | null;
+
+  downtime?: number | null;
+
+  apr?: number | null;
+
+  apy?: number | null;
+
+  score: number;
+
+  rank_score: number;
+
+  rank_activated_stake: number;
+
+  rank_apy: number;
+}
+
+export class ValidatorDto {
+  identity: string;
+  vote_account: string;
+  start_epoch: number;
+  start_date: string;
+  info_name: string;
+  info_url: string;
+  info_keybase: string;
+  node_ip: string;
+  dc_coordinates_lat: number;
+  dc_coordinates_lon: number;
+  dc_continent: string;
+  dc_country_iso: string;
+  dc_country: string;
+  dc_city: string;
+  dc_full_city: string;
+  dc_asn: number;
+  dc_aso: string;
+  dcc_full_city: number;
+  dcc_asn: number;
+  dcc_aso: number;
+  commission_max_observed?: number | null;
+  commission_min_observed?: number | null;
+  commission_advertised: number;
+  commission_effective?: number | null;
+  commission_aggregated?: number | null;
+  rugged_commission_occurrences: number;
+  rugged_commission: boolean;
+  rugged_commission_info: string[];
+  version: string;
+  activated_stake: string;
+  marinade_stake: string;
+  foundation_stake: string;
+  marinade_native_stake: string;
+  self_stake: string;
+  superminority: boolean;
+  credits: number;
+  score: number;
+  warnings: WarningDto[];
+  epoch_stats: EpochStatDto[];
+  epochStats: Record<number, EpochStatDto>;
+  epochs_count: number;
+  has_last_epoch_stats: boolean;
+  avg_uptime_pct: number;
+  avg_apy: number;
+}
+
+export class ValidatorAggregatedDto {
+  epoch: number;
+  epoch_start_date: string;
+  avg_marinade_score?: number | null;
+  avg_apy?: number | null;
+}
+
+export class ValidatorsResponseDto {
+  validators: ValidatorDto[];
+  validators_aggregated: ValidatorAggregatedDto[];
+}
+
+export type AggregatedValidator = {
+    voteAccount: string;
+    name: string;
+    epochs: number[];
+    currentStake: number;
+    currentMarinadeStake: number;
+    commission: number[];
+    stake: number[];
+    externalStake: number[];
+    credits: number[];
+    blocksProduced: number[];
+    leaderSlots: number[];
+    dataAvailable: boolean[];
+    mevCommission: number;
+    country: string;
+    city: string;
+    aso: string;
+    blacklisted: boolean;
+    version: string;
+};
+
+export type AggregatedValidators = Record<string, AggregatedValidator>
+

package/src/eligibility/eligibility.module.ts

@@ -0,0 +1,11 @@
+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 {}

package/src/eligibility/eligibility.service.ts

@@ -0,0 +1,183 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { ConfigService } from '../config/config.service';
+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 } from '../dto/scoring.dto';
+import { AggregatedValidator, AggregatedValidators } from '../dto/validators.dto';
+import { ValidatorsService } from '../validators/validators.service';
+
+export class EligibilityService {
+
+  constructor (private validatorsService: ValidatorsService, private configService: ConfigService) {}
+
+  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;
+  }
+
+  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;
+  }
+
+  evalBlacklistIssue (validator: AggregatedValidator): Issue | undefined {
+    if (validator.blacklisted) {
+      return { type: IssueType.BLACKLIST, message: 'Validator is blacklisted' };
+    }
+    return undefined;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  evalBondIssue (validator: AggregatedValidator, bonds: Bonds): Issue | undefined {
+    if (!(validator.voteAccount in bonds)) {
+      return { type: IssueType.NO_BOND, message: 'Validator has no bond' };
+    }
+    return undefined;
+  }
+
+  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 [
+      this.evalBlacklistIssue(validator),
+      this.evalLowCreditsIssue(validator, epochIndex, eligibilityConfig, clusterInfo),
+      this.evalLowExternalStakeIssue(validator, epochIndex, eligibilityConfig),
+      this.evalHighCommissionIssue(validator, epochIndex, eligibilityConfig),
+      this.evalScoreIssue(epochIndex, eligibilityConfig, score),
+      this.evalBondIssue(validator, bonds),
+    ].filter(Boolean) as Issue[];
+  }
+
+  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 };
+  }
+
+  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 } = this.evalIssuesInEpoch(issuesCollection[epochIndex]!);
+      totalCriticals += criticals;
+      totalWarnings += warnings;
+    }
+    return { criticals: totalCriticals, warnings: totalWarnings };
+  }
+
+  isBasicEligible (issuesCollection: Issue[][], eligibilityConfig: EligibilityConfig): boolean {
+    const { criticals, warnings } = this.evalIssues(issuesCollection, eligibilityConfig.basicEligibilityEpochs + 1);
+    return criticals === 0 && warnings <= eligibilityConfig.maxWarnings;
+  }
+
+  isBonusEligible (issuesCollection: Issue[][], eligibilityConfig: EligibilityConfig): boolean {
+    const totalEpochs = eligibilityConfig.basicEligibilityEpochs + eligibilityConfig.bonusEligibilityExtraEpochs + 1;
+    const { criticals, warnings } = this.evalIssues(issuesCollection, totalEpochs);
+    return criticals === 0 && warnings <= eligibilityConfig.maxWarnings;
+  }
+
+  getIssuesCollection (clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, bonds: Bonds, score: ScoreDto, eligibilityConfig: EligibilityConfig): Issue[][] {
+    return Array.from({ length: eligibilityConfig.basicEligibilityEpochs + eligibilityConfig.bonusEligibilityExtraEpochs + 1 }, (_, epochIndex) =>
+      this.getValidatorIssuesInEpoch(aggregatedValidator, bonds, epochIndex, eligibilityConfig, clusterInfo, score)
+    );
+  }
+
+  computeValidatorEligibility (clusterInfo: ClusterInfo, aggregatedValidator: AggregatedValidator, bonds: Bonds, scores: ScoreDto, eligibilityConfig: EligibilityConfig): ValidatorEligibility {
+    const issuesCollection = this.getIssuesCollection(clusterInfo, aggregatedValidator, bonds, scores, eligibilityConfig);
+    const minExternalStake = this.validatorsService.selectExternalStakeMin(aggregatedValidator, eligibilityConfig.basicEligibilityEpochs);
+
+    return {
+      basicEligibility: this.isBasicEligible(issuesCollection, eligibilityConfig),
+      bonusEligibility: this.isBonusEligible(issuesCollection, eligibilityConfig),
+      issuesCollection,
+      capFromBond: this.configService.getScoringConfig().CAP_FROM_BOND,
+      capFromExternalStake: minExternalStake * (eligibilityConfig.maxStakeShare / (1 - eligibilityConfig.maxStakeShare)),
+    };
+  }
+
+  computeValidatorsEligibilities (clusterInfo: ClusterInfo, scores: Scores, aggregatedValidators: AggregatedValidators, bonds: Bonds, eligibilityConfig: EligibilityConfig): ValidatorsEligibilities {
+    const result: ValidatorsEligibilities = {};
+    for (const [voteAccount, validator] of Object.entries(aggregatedValidators)) {
+      if (!scores[voteAccount]) {
+        continue;
+      }
+      result[voteAccount] = this.computeValidatorEligibility(clusterInfo, validator, bonds, scores[voteAccount]!, eligibilityConfig);
+    }
+    return result;
+  }
+}

package/src/errors/fetching.ts

@@ -0,0 +1,25 @@
+export class FetchError extends Error {
+  constructor (message: string, public statusCode: number) {
+    super(message);
+    this.name = 'FetchError';
+  }
+}
+
+export const FETCHING_ERROR_MESSAGES = {
+  generalValidatorsFetchFailed: 'An error occured while fetching validators data',
+  generalTvlFetchFailed: 'An error occured while fetching validators data',
+  generalBondsFetchFailed: 'An error occured while fetching bonds data',
+  generalRewardsFetchFailed: 'An error occured while fetching rewards',
+  generalVemndeFetchFailed: 'An error occured while fetching veMNDE votes',
+  generalMsolFetchFailed: 'An error occured while fetching mSOL votes',
+  generalJitoMEVFetchFailed: 'An error occured while fetching Jito MEV',
+  generalBlacklistFetchFailed: 'An error occured while fetching blacklist',
+  validatorsFetchFailed: 'Failed to fetch validators data',
+  tvlFetchFailed: 'Failed to fetch tvl data',
+  bondsFetchFailed: 'Failed to fetch bonds data',
+  vemndeFetchFailed: 'Failed to fetch veMNDE votes',
+  msolFetchFailed: 'Failed to fetch mSOL votes',
+  rewardsFetchFailed: 'Failed to fetch rewards',
+  jitoMevFetchFailed: 'Failed to fetch Jito MEV',
+  blacklistFetchFailed: 'Failed to fetch blacklist'
+};

package/src/interfaces/data-provider.interface.ts

@@ -0,0 +1,17 @@
+import { ValidatorDto } from '../dto/validators.dto';
+import { Rewards } from '../dto/rewards.dto';
+import { Votes } from '../dto/snapshots.dto';
+import { JitoValidatorDto } from '../dto/jito.dto';
+import { Bonds } from '../dto/bonds.dto';
+import { TvlStats } from '../dto/marinade.dto';
+
+export interface IDataProvider {
+  fetchValidators(epochsToFetch: number, withSnapshot: boolean): Promise<ValidatorDto[]>;
+  fetchBlacklist(withSnapshot: boolean): Promise<Set<string>>;
+  fetchVeMndeVotes(withSnapshot: boolean): Promise<Votes>;
+  fetchMSolVotes(withSnapshot: boolean): Promise<Votes>;
+  fetchRewards(epochs: number, withSnapshot: boolean): Promise<Rewards>;
+  fetchValidatorsJitoMEV(withSnapshot: boolean): Promise<Record<string, JitoValidatorDto>>;
+  fetchBonds(withSnapshot: boolean): Promise<Bonds>;
+  fetchTvl(withSnapshot: boolean): Promise<TvlStats>;
+}

package/src/providers/api-data.provider.ts

@@ -0,0 +1,261 @@
+/* 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';
+import { IDataProvider } from '../interfaces/data-provider.interface';
+import { sum } from '../utils/maths';
+import { FETCHING_ERROR_MESSAGES } from '../errors/fetching';
+import { JitoValidatorDto, JitoValidatorsResponseDto } from '../dto/jito.dto';
+import { writeFile } from 'fs/promises';
+import { Bonds, BondsDto } from '../dto/bonds.dto';
+import { TvlStats } from '../dto/marinade.dto';
+import axios, { AxiosError } from 'axios';
+
+export class URLs {
+  validatorsURL: string;
+  blacklistURL: string;
+  vemndeVotesURL: string;
+  msolVotesURL: string;
+  rewardsURL: string;
+  jitoMevURL: string;
+  bondsURL: string;
+  marinadeTvlURL: string;
+}
+
+export class ApiDataProvider implements IDataProvider {
+  constructor (private urls: URLs) { }
+
+  async fetchValidators (epochsToFetch: number, withSnapshot = false): Promise<ValidatorDto[]> {
+    try {
+      const response = await axios.get(`${this.urls.validatorsURL}?limit=9999&epochs=${epochsToFetch + 1}`);
+
+      const rawData = response.data as ValidatorsResponseDto;
+
+      rawData.validators.forEach(validator => {
+        validator.epochStats = validator.epoch_stats.reduce((acc, epochStat) => {
+          acc[epochStat.epoch] = epochStat;
+          return acc;
+        }, {} as Record<number, EpochStatDto>);
+      });
+
+      if (withSnapshot) {
+        await writeFile('./snapshot/validators.json', JSON.stringify(rawData, null, 2));
+      }
+
+      return rawData.validators;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError;
+        if (axiosError.response) {
+          console.error(FETCHING_ERROR_MESSAGES.validatorsFetchFailed, axiosError.response.status);
+        } else if (axiosError.request) {
+          console.error(FETCHING_ERROR_MESSAGES.generalValidatorsFetchFailed, axiosError.request);
+        }
+      }
+      throw error;
+    }
+  }
+
+  async fetchTvl (withSnapshot: boolean): Promise<TvlStats> {
+    try {
+      const response = await axios.get(this.urls.marinadeTvlURL);
+
+      const data: TvlStats = response.data;
+
+      if (withSnapshot) {
+        await writeFile('./snapshot/tvl.json', JSON.stringify(data, null, 2));
+      }
+
+      return data;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError;
+        if (axiosError.response) {
+          console.error(FETCHING_ERROR_MESSAGES.tvlFetchFailed, axiosError.response.status);
+        } else if (axiosError.request) {
+          console.error(FETCHING_ERROR_MESSAGES.generalTvlFetchFailed, axiosError.request);
+        }
+      }
+      throw error;
+    }
+  }
+
+  async fetchBonds (withSnapshot: boolean): Promise<Bonds> {
+    try {
+      const response = await axios.get<BondsDto>(this.urls.bondsURL);
+      const data: BondsDto = response.data;
+
+      const bonds: Bonds = data.bonds.reduce<Bonds>((acc, bond) => {
+        acc[bond.vote_account] = bond.cpmpe;
+        return acc;
+      }, {} as Bonds);
+
+      if (withSnapshot) {
+        await writeFile('./snapshot/bonds.json', JSON.stringify(data, null, 2));
+      }
+
+      return bonds;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError;
+        if (axiosError.response) {
+          console.error(FETCHING_ERROR_MESSAGES.bondsFetchFailed, axiosError.response.status);
+        } else if (axiosError.request) {
+          console.error(FETCHING_ERROR_MESSAGES.generalBondsFetchFailed, axiosError.request);
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  async fetchBlacklist (withSnapshot = false): Promise<Set<string>> {
+    try {
+      const response = await axios.get<string>(this.urls.blacklistURL, {
+        responseType: 'text'
+      });
+
+      const csv: string = response.data;
+
+      if (withSnapshot) {
+        await writeFile('./snapshot/blacklist.csv', csv);
+      }
+
+      const blacklistSet = new Set(
+        csv
+          .split('\n')
+          .map((line) => line.trim().split(',')[0])
+          .filter((value): value is string => !!value)
+      );
+
+      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);
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  async fetchVeMndeVotes (withSnapshot = false): Promise<Votes> {
+    try {
+      const response = await axios.get<veMNDESnapshotDto>(this.urls.vemndeVotesURL);
+      const data: veMNDESnapshotDto = response.data;
+
+      if (withSnapshot) {
+        await writeFile('./snapshot/vemnde-votes.json', JSON.stringify(data, null, 2));
+      }
+
+      const result: Votes = {};
+      for (const { amount, validatorVoteAccount } of data.records) {
+        const parsedAmount = Number(amount);
+        if (!isNaN(parsedAmount) && parsedAmount > 0) {
+          result[validatorVoteAccount] = (result[validatorVoteAccount] ?? 0) + parsedAmount;
+        }
+      }
+
+      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);
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  async fetchMSolVotes (withSnapshot = false): Promise<Votes> {
+    try {
+      const response = await axios.get<mSolSnapshotDto>(this.urls.msolVotesURL);
+      const data: mSolSnapshotDto = response.data;
+
+      if (withSnapshot) {
+        await writeFile('./snapshot/msol-votes.json', JSON.stringify(data, null, 2));
+      }
+
+      const result: Votes = {};
+      for (const { amount, validatorVoteAccount } of data.records) {
+        const parsedAmount = Number(amount);
+        if (!isNaN(parsedAmount) && parsedAmount > 0) {
+          result[validatorVoteAccount] = (result[validatorVoteAccount] ?? 0) + parsedAmount;
+        }
+      }
+
+      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);
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  async fetchRewards (epochs: number, withSnapshot = false): Promise<Rewards> {
+    try {
+      const response = await axios.get<{ rewards_mev: [number, number][], rewards_inflation_est: [number, number][] }>(
+        `${this.urls.rewardsURL}?epochs=${epochs}`
+      );
+
+      const jsonResponse = response.data;
+      const data = new RewardsResponseDto(jsonResponse);
+
+      if (withSnapshot) {
+        await writeFile('./snapshot/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);
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  async fetchValidatorsJitoMEV (withSnapshot = false): Promise<Record<string, JitoValidatorDto>> {
+    try {
+      const response = await axios.get<JitoValidatorsResponseDto>(this.urls.jitoMevURL);
+      const jitoMevRecords: JitoValidatorsResponseDto = response.data;
+
+      if (withSnapshot) {
+        await writeFile('./snapshot/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);
+        }
+      }
+
+      throw error;
+    }
+  }
+}