@marinade.finance/scoring 1.0.1 → 1.0.3

package/dto/validators.dto.ts

@@ -1,110 +0,0 @@
-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/errors/fetching.ts

@@ -1,25 +0,0 @@
-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/interfaces/data-provider.interface.ts

@@ -1,17 +0,0 @@
-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/providers/api-data.provider.ts

@@ -1,261 +0,0 @@
-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';
-import { error } from '../logger';
-
-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, private snapshotsBasePath?: string) { }
-
-  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 (err) {
-      if (axios.isAxiosError(error)) {
-        const axiosError = error as AxiosError;
-        if (axiosError.response) {
-          error(FETCHING_ERROR_MESSAGES.validatorsFetchFailed, axiosError.response.status);
-        } else if (axiosError.request) {
-          error(FETCHING_ERROR_MESSAGES.generalValidatorsFetchFailed, axiosError.request);
-        }
-      }
-      throw err;
-    }
-  }
-
-  async fetchTvl (withSnapshot: boolean): Promise<TvlStats> {
-    try {
-      const response = await axios.get(this.urls.marinadeTvlURL);
-
-      const data: TvlStats = response.data;
-
-      if (withSnapshot) {
-        await writeFile(`${this.snapshotsBasePath}/tvl.json`, JSON.stringify(data, null, 2));
-      }
-
-      return data;
-    } catch (err) {
-      if (axios.isAxiosError(error)) {
-        const axiosError = error as AxiosError;
-        if (axiosError.response) {
-          error(FETCHING_ERROR_MESSAGES.tvlFetchFailed, axiosError.response.status);
-        } else if (axiosError.request) {
-          error(FETCHING_ERROR_MESSAGES.generalTvlFetchFailed, axiosError.request);
-        }
-      }
-      throw err;
-    }
-  }
-
-  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(`${this.snapshotsBasePath}/bonds.json`, JSON.stringify(data, null, 2));
-      }
-
-      return bonds;
-    } catch (err) {
-      if (axios.isAxiosError(err)) {
-        const axiosError = err as AxiosError;
-        if (axiosError.response) {
-          error(FETCHING_ERROR_MESSAGES.bondsFetchFailed, axiosError.response.status);
-        } else if (axiosError.request) {
-          error(FETCHING_ERROR_MESSAGES.generalBondsFetchFailed, axiosError.request);
-        }
-      }
-
-      throw err;
-    }
-  }
-
-  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(`${this.snapshotsBasePath}/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 (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 err;
-    }
-  }
-
-  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(`${this.snapshotsBasePath}/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 (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 err;
-    }
-  }
-
-  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(`${this.snapshotsBasePath}/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 (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 err;
-    }
-  }
-
-  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(`${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 (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 err;
-    }
-  }
-
-  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(`${this.snapshotsBasePath}/jito-mev-records.json`, JSON.stringify(jitoMevRecords, null, 2));
-      }
-
-      return Object.fromEntries(
-        jitoMevRecords.validators.map((validator) => [validator.vote_account, validator])
-      );
-    } 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 err;
-    }
-  }
-}

package/providers/file-data.provider.ts

@@ -1,117 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { TvlStats } from '../dto/marinade.dto';
-import { Bonds, BondsDto } from '../dto/bonds.dto';
-import { JitoValidatorDto, JitoValidatorsResponseDto } from '../dto/jito.dto';
-import { Rewards, RewardsResponseDto } from '../dto/rewards.dto';
-import { EpochStatDto, ValidatorDto, ValidatorsResponseDto } from '../dto/validators.dto';
-import { IDataProvider } from '../interfaces/data-provider.interface';
-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;
-  blacklistPath: string;
-  vemndeVotesPath: string;
-  msolVotesPath: string;
-  rewardsPath: string;
-  jitoMevPath: string;
-  bondsPath: string;
-  marinadeTvlPath: string;
-}
-
-export class FileDataProvider implements IDataProvider {
-  constructor (private paths: Paths) { }
-
-  async fetchValidators (epochsToFetch: number): Promise<ValidatorDto[]> {
-    try {
-      const validatorsFile = await readFile(this.paths.validatorsPath, 'utf8');
-      const validatorsData: ValidatorsResponseDto = JSON.parse(validatorsFile);
-
-      validatorsData.validators.forEach(validator => {
-        validator.epochStats = validator.epoch_stats.reduce((acc, epochStat) => {
-          acc[epochStat.epoch] = epochStat;
-          return acc;
-        }, {} as Record<number, EpochStatDto>);
-      });
-
-      return validatorsData.validators;
-    } 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);
-
-    const bonds: Bonds = bondsData.bonds.reduce<Bonds>((acc, bond) => {
-      acc[bond.vote_account] = bond.cpmpe;
-      return acc;
-    }, {} as Bonds);
-
-    return bonds;
-  }
-  async fetchVeMndeVotes (): Promise<Record<string, number>> {
-    const vemndeVotesFile = await readFile(this.paths.vemndeVotesPath, 'utf8');
-    const vemndeVotesData = JSON.parse(vemndeVotesFile) as mSolSnapshotDto;
-    const result: Votes = {};
-    for (const { amount, validatorVoteAccount } of vemndeVotesData.records) {
-      const parsedAmount = Number(amount);
-      if (!isNaN(parsedAmount) && parsedAmount > 0) {
-        result[validatorVoteAccount] = (result[validatorVoteAccount] ?? 0) + parsedAmount;
-      }
-    }
-
-    return result;
-  }
-  async fetchMSolVotes (): Promise<Record<string, number>> {
-    const msolVotesFile = await readFile(this.paths.msolVotesPath, 'utf8');
-    const msolVotesData = JSON.parse(msolVotesFile) as mSolSnapshotDto;
-    const result: Votes = {};
-    for (const { amount, validatorVoteAccount } of msolVotesData.records) {
-      const parsedAmount = Number(amount);
-      if (!isNaN(parsedAmount) && parsedAmount > 0) {
-        result[validatorVoteAccount] = (result[validatorVoteAccount] ?? 0) + parsedAmount;
-      }
-    }
-
-    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][] };
-
-    const data = new RewardsResponseDto(rewardsData);
-
-    const mev = sum(data.rewards_mev.map(dto => dto.amount));
-    const inflation = sum(data.rewards_inflation_est.map(dto => dto.amount));
-
-    return { inflation, mev };
-  }
-  async fetchValidatorsJitoMEV (): Promise<Record<string, JitoValidatorDto>> {
-    try {
-      const jitoMevFile = await readFile(this.paths.jitoMevPath, 'utf8');
-      const jitoMevData: JitoValidatorsResponseDto = JSON.parse(jitoMevFile);
-
-      return Object.fromEntries(
-        jitoMevData.validators.map((validator) => [validator.vote_account, validator])
-      );
-    } catch (err) {
-      error(FETCHING_ERROR_MESSAGES.generalJitoMEVFetchFailed, err);
-      throw err;
-    }
-  }
-}

package/utils/csv.ts

@@ -1,30 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import * as fs from 'fs';
-import { Score } from '../dto/scoring.dto';
-import { error } from 'logger';
-
-export function writeScoresToCsv(filePath: string, data: Score[]): void {
-  if (data.length === 0) {
-    console.error('Data array is empty, no CSV will be written.');
-    return;
-  }
-  const headers = Object.keys(data[0]!);
-  let csvString = headers.join(',') + '\n';
-
-  data.forEach(score => {
-    const rowData = headers.map(header => {
-      const value = score[header as keyof Score];
-      if (typeof value === 'string' && (value.includes(',') || value.includes('\n') || value.includes('"'))) {
-        return `"${value.replace(/"/g, '""')}"`;
-      }
-      return `"${value}"`;
-    }).join(',');
-    csvString += rowData + '\n';
-  });
-
-  fs.writeFile(filePath, csvString, (err) => {
-    if (err) {
-      error('Error writing CSV file:', err);
-    }
-  });
-}

package/utils/maths.ts

@@ -1,75 +0,0 @@
-import { Value } from 'expr-eval';
-
-/**
- * Calculates the sum of an array of numbers.
- * @param {number[]} amounts - The array of numbers to sum.
- * @return {number} The sum of the numbers in the array.
- */
-export function sum (amounts: number[]): number {
-  if (!Array.isArray(amounts) || amounts.some(amount => typeof amount !== 'number')) {
-    throw new TypeError('Input must be an array of numbers');
-  }
-  return amounts.reduce((acc, amount) => acc + amount, 0);
-}
-
-/**
- * Calculates the mean (average) of an array of numbers.
- * @param {number[]} data - The array of numbers for which to calculate the mean.
- * @return {number} The mean of the numbers in the array. Throws an error if the array is empty.
- */
-export function mean (data: number[]): number {
-  if (data.length === 0) {
-    throw new Error('Cannot calculate mean for empty data');
-  }
-
-  return sum(data) / data.length;
-}
-
-/**
- * Calculates the standard deviation of an array of numbers.
- * Standard deviation is a measure of the amount of variation or dispersion of a set of values.
- * @param {number[]} data - The array of numbers for which to calculate the standard deviation.
- * @return {number} The standard deviation of the numbers in the array. Throws an error if the array is empty.
- */
-export function stdDev (data: number[]): number {
-  if (data.length === 0) {
-    throw new Error('Cannot calculate std. dev. for empty data');
-  }
-
-  const dataMean = mean(data);
-  return Math.sqrt(data.reduce((sum, value) => sum + Math.pow(value - dataMean, 2), 0) / data.length);
-}
-
-export function piecewise (...args: Value[]): Value {
-  if (args.length === 0) {
-    throw new Error('At least one argument must be provided!');
-  }
-
-  for (let conditionIndex = 0, valueIndex = 1; valueIndex < args.length; conditionIndex += 2, valueIndex += 2) {
-    const condition = args[conditionIndex];
-    const value = args[valueIndex];
-
-    if (typeof condition !== 'boolean') {
-      throw new Error(`Argument at position ${conditionIndex} must be a boolean!`);
-    }
-
-    if (condition) {
-      if (value === undefined) {
-        throw new Error(`Expected a value corresponding to the condition at position ${conditionIndex}, but got undefined.`);
-      }
-      return value;
-    }
-  }
-
-  const defaultValue = args[args.length - 1];
-  if (defaultValue === undefined) {
-    throw new Error('Unexpected error: Default value is undefined.');
-  }
-  return defaultValue;
-}
-
-export function mathUtilityFunctions () {
-  return {
-    piecewise
-  };
-}

package/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/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);
-  }
-}