@toruslabs/ethereum-controllers 5.5.3 → 5.5.5

package/src/Preferences/PreferencesController.ts

@@ -1,473 +0,0 @@
-import { stripHexPrefix } from "@ethereumjs/util";
-import {
-  ACCOUNT_TYPE,
-  BasePreferencesController,
-  CustomNft,
-  CustomToken,
-  InitPreferencesParams,
-  IPreferencesController,
-  PreferencesConfig,
-  PreferencesState,
-  TransactionStatus,
-} from "@toruslabs/base-controllers";
-import { get, patch, post, remove } from "@toruslabs/http-helpers";
-import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
-import { Mutex } from "async-mutex";
-import log from "loglevel";
-
-import KeyringController from "../Keyring/KeyringController";
-import NetworkController from "../Network/NetworkController";
-import { ETHERSCAN_SUPPORTED_CHAINS, SUPPORTED_NETWORKS } from "../utils/constants";
-import { addEtherscanTransactions, formatDate, formatPastTx, formatTime, getEthTxStatus } from "../utils/helpers";
-import type {
-  AddChainMessageParams,
-  CustomNetworkPayload,
-  CustomNetworks,
-  CustomNftInfo,
-  CustomTokenInfo,
-  EthereumProviderConfig,
-  EthereumUser,
-  EtherscanTransaction,
-  ExtendedAddressPreferences,
-  FetchedTransaction,
-  FormattedTransactionActivity,
-  TransactionPayload,
-} from "../utils/interfaces";
-
-export interface IPreferencesControllerOptions {
-  config?: Partial<PreferencesConfig> & Pick<PreferencesConfig, "api" | "commonApiHost">;
-  state?: Partial<PreferencesState<ExtendedAddressPreferences>>;
-  provider: SafeEventEmitterProvider;
-  signAuthMessage?: KeyringController["signAuthMessage"];
-  getProviderConfig?: NetworkController["getProviderConfig"];
-  setProviderConfig?: NetworkController["setProviderConfig"];
-  validateSignMessage: (message: string) => Promise<void>;
-}
-
-export default class PreferencesController
-  extends BasePreferencesController<ExtendedAddressPreferences, PreferencesConfig, PreferencesState<ExtendedAddressPreferences>>
-  implements IPreferencesController<ExtendedAddressPreferences, PreferencesConfig, PreferencesState<ExtendedAddressPreferences>>
-{
-  private _handle?: number;
-
-  private _mutex: Mutex = new Mutex();
-
-  private getProviderConfig: NetworkController["getProviderConfig"];
-
-  private setProviderConfig: NetworkController["setProviderConfig"];
-
-  private provider: SafeEventEmitterProvider;
-
-  constructor({
-    config,
-    state,
-    provider,
-    signAuthMessage,
-    getProviderConfig,
-    setProviderConfig,
-    validateSignMessage,
-  }: IPreferencesControllerOptions) {
-    super({
-      config,
-      state,
-      defaultPreferences: { formattedPastTransactions: [], fetchedPastTx: [], paymentTx: [], etherscanTransactions: [] },
-      signAuthMessage,
-      validateSignMessage,
-    });
-    this.provider = provider;
-    this.getProviderConfig = getProviderConfig;
-    this.setProviderConfig = setProviderConfig;
-  }
-
-  public async poll(interval?: number): Promise<void> {
-    const releaseLock = await this._mutex.acquire();
-    if (interval) this.configure({ pollInterval: interval });
-    if (this._handle) window.clearTimeout(this._handle);
-    // call here
-    const storeSelectedAddress = this.state.selectedAddress;
-    if (!storeSelectedAddress) return;
-    if (!this.getAddressState(storeSelectedAddress)?.jwtToken) return;
-    // This should never throw
-    await this.sync(storeSelectedAddress);
-    releaseLock();
-    this._handle = window.setTimeout(() => {
-      this.poll(this.config.pollInterval);
-    }, this.config.pollInterval);
-  }
-
-  public async initPreferences(params: InitPreferencesParams): Promise<void> {
-    const { address, jwtToken, calledFromEmbed, userInfo, rehydrate, locale = "en", type, signatures, web3AuthClientId, web3AuthNetwork } = params;
-    await super.init({ address, userInfo, idToken: jwtToken, type, metadata: { email: userInfo.email, signatures, network: web3AuthNetwork } });
-    const { aggregateVerifier, verifier, verifierId } = userInfo || {};
-    const userExists = await this.sync(address);
-    if (!userExists) {
-      const accountState = this.getAddressState(address);
-      await this.createUser({
-        selectedCurrency: accountState.selectedCurrency,
-        theme: accountState.theme,
-        verifier: aggregateVerifier || verifier,
-        verifierId,
-        locale,
-        address,
-        type,
-        web3AuthNetwork,
-      });
-    }
-    await this.storeUserLogin({
-      verifier: aggregateVerifier || verifier,
-      verifierId,
-      options: { calledFromEmbed, rehydrate },
-      address,
-      web3AuthClientId,
-      web3AuthNetwork,
-    });
-  }
-
-  public getSelectedAddress(): string {
-    return this.state.selectedAddress;
-  }
-
-  async sync(address: string): Promise<boolean> {
-    try {
-      const user = await this.getUser<EthereumUser>(address);
-      if (user) {
-        const {
-          default_currency: defaultCurrency,
-          contacts,
-          theme,
-          locale,
-          public_address: userPublicAddress,
-          default_public_address: defaultPublicAddress,
-          customNetworks,
-          customTokens,
-          customNfts,
-          account_type: accountType,
-        } = user || {};
-
-        // update latest data in state.
-        this.updateState(
-          {
-            contacts,
-            theme,
-            selectedCurrency: defaultCurrency,
-            locale,
-            defaultPublicAddress: defaultPublicAddress || userPublicAddress,
-            customTokens,
-            customNfts,
-            customNetworks,
-            accountType: accountType as ACCOUNT_TYPE,
-          },
-          address
-        );
-        return true;
-      }
-      return false;
-    } catch (error) {
-      log.error(error);
-      return false;
-    } finally {
-      Promise.all([
-        this.getWalletOrders<FetchedTransaction>(address).catch((error) => {
-          log.error("unable to fetch wallet orders", error);
-        }),
-      ])
-        .then((data) => {
-          const [walletTx] = data;
-          // eslint-disable-next-line promise/always-return
-          if (walletTx && walletTx.length > 0) {
-            this.updateState({ fetchedPastTx: [...walletTx] }, address);
-            this.calculatePastTx(walletTx, address);
-          }
-        })
-        .catch((error) => log.error(error));
-    }
-  }
-
-  public async patchNewTx(tx: TransactionPayload, address: string): Promise<void> {
-    const formattedTx = formatPastTx(tx);
-    const storePastTx = this.getAddressState(address)?.formattedPastTransactions || [];
-    const duplicateIndex = storePastTx.findIndex((x) => x.transaction_hash === tx.transaction_hash && x.chainId === tx.chain_id);
-    if (tx.status === TransactionStatus.submitted || tx.status === TransactionStatus.confirmed) {
-      if (duplicateIndex === -1) {
-        // No duplicate found
-
-        const finalTx = this.cancelTxCalculate([...storePastTx, formattedTx]);
-        tx.is_cancel = formattedTx.is_cancel;
-        tx.to = tx.to?.toLowerCase();
-        tx.from = tx.from.toLowerCase();
-
-        this.updateState({ formattedPastTransactions: finalTx }, address);
-        this.postPastTx<TransactionPayload>(tx, address);
-      } else {
-        // avoid overriding is_cancel
-        formattedTx.is_cancel = storePastTx[duplicateIndex].is_cancel;
-        storePastTx[duplicateIndex] = formattedTx;
-        this.updateState({ formattedPastTransactions: this.cancelTxCalculate([...storePastTx]) }, address);
-      }
-    }
-  }
-
-  public recalculatePastTx(address?: string) {
-    // This triggers store update which calculates past Tx status for that network
-    const selectedAddress = address || this.state.selectedAddress;
-    const state = this.getAddressState(selectedAddress);
-    if (!state?.fetchedPastTx) return;
-    this.calculatePastTx(state.fetchedPastTx, selectedAddress);
-  }
-
-  public async refetchEtherscanTx(address?: string) {
-    const selectedAddress = address || this.state.selectedAddress;
-    if (this.getAddressState(selectedAddress)?.jwtToken) {
-      const { chainId } = this.getProviderConfig();
-      if (ETHERSCAN_SUPPORTED_CHAINS.includes(chainId)) {
-        const etherscanTxn = await this.fetchEtherscanTx<EtherscanTransaction>({
-          selectedAddress,
-          chainId: this.getProviderConfig().chainId,
-        });
-        const finalEthScanTxn = await addEtherscanTransactions(etherscanTxn, selectedAddress, this.provider, chainId);
-        log.info("Formatted Etherscan Response", finalEthScanTxn);
-        this.updateState({ etherscanTransactions: finalEthScanTxn });
-        return etherscanTxn;
-      }
-    }
-  }
-
-  async fetchEtherscanTx<T>(parameters: { selectedAddress: string; chainId: string }): Promise<T[]> {
-    try {
-      const url = new URL(`${this.config.api}/etherscan`);
-      url.searchParams.append("chainId", parameters.chainId);
-      const response = await get<{ success: boolean; data: T[] }>(url.href, this.headers(parameters.selectedAddress));
-      log.info("Etherscan Response API", response);
-      return response.success ? response.data : [];
-    } catch (error) {
-      log.error("unable to fetch etherscan tx", error);
-      return [];
-    }
-  }
-
-  public async getEtherScanTokens(address: string, chainId: string): Promise<CustomTokenInfo[]> {
-    const selectedAddress = address;
-    const apiUrl = new URL(this.config.api);
-    apiUrl.pathname = `/tokens`;
-    apiUrl.searchParams.append("chainId", chainId);
-    apiUrl.searchParams.append("address", selectedAddress);
-    const result = await get<{ data: CustomTokenInfo[] }>(apiUrl.href, this.headers(this.state.selectedAddress));
-    return result.data;
-  }
-
-  public async getSimpleHashNfts(address: string, chainId: string): Promise<CustomNftInfo[]> {
-    const selectedAddress = address;
-    const apiUrl = new URL(this.config.api);
-    apiUrl.pathname = `/nfts`;
-    apiUrl.searchParams.append("chainId", chainId);
-    apiUrl.searchParams.append("address", selectedAddress);
-    const result = await get<{ data: CustomNftInfo[] }>(apiUrl.href, this.headers(this.state.selectedAddress));
-    return result.data;
-  }
-
-  public getCustomTokens(address?: string): CustomToken[] {
-    return this.getAddressState(address)?.customTokens ?? [];
-  }
-
-  public getCustomNfts(address?: string): CustomNft[] {
-    return this.getAddressState(address)?.customNfts ?? [];
-  }
-
-  public isChainIdSupported(address: string, chainId: string): boolean {
-    const approveChainOptions = this.getChainOptions(address);
-    const providerConfig = approveChainOptions.find((x) => stripHexPrefix(x.chainId) === chainId);
-    return !!providerConfig;
-  }
-
-  public async addChain(network: AddChainMessageParams): Promise<void> {
-    const approveChainOptions = this.getChainOptions();
-    const providerConfig = approveChainOptions.find((x) => x.chainId === network.chainId);
-
-    if (providerConfig) {
-      throw new Error(`chainId ${network.chainId} already exists`);
-    }
-
-    const newNetwork: CustomNetworkPayload = {
-      displayName: network.chainName,
-      rpcTarget: network.rpcUrls[0],
-      ticker: network.nativeCurrency.symbol,
-      chainId: network.chainId,
-      blockExplorerUrl: network.blockExplorerUrls[0],
-      tickerName: network.nativeCurrency.name,
-      logo: network.nativeCurrency.symbol,
-    };
-
-    const isSuccess = await this.addCustomNetwork({ network: newNetwork });
-    if (!isSuccess) throw new Error("unable to add custom network");
-  }
-
-  switchChain(data: { chainId: string }) {
-    const chainOptions = this.getChainOptions();
-    const providerConfig = chainOptions.find((x) => x.chainId === data.chainId);
-    if (providerConfig) {
-      this.setProviderConfig(providerConfig);
-    } else {
-      throw new Error(`chainId ${data.chainId} is not supported`);
-    }
-  }
-
-  // Custom Network methods
-  public async addCustomNetwork({ network }: { network: CustomNetworkPayload }): Promise<number> {
-    try {
-      const apiUrl = new URL(this.config.api);
-      apiUrl.pathname = `/customnetwork`;
-      const { selectedAddress } = this.state;
-      const payload: Partial<CustomNetworks> = {
-        network_name: network.displayName,
-        rpc_url: network.rpcTarget,
-        chain_id: network.chainId,
-        symbol: network.ticker,
-        block_explorer_url: network.blockExplorerUrl || undefined,
-        is_testnet: network.isTestnet || false,
-        logo: network.logo,
-        symbol_name: network.tickerName,
-      };
-      const res = await post<{ data: CustomNetworks }>(apiUrl.href, payload, this.headers(selectedAddress), { useAPIKey: true });
-      await this.sync(selectedAddress);
-
-      return res.data.id;
-    } catch {
-      log.error("error adding custom network");
-      return null;
-    }
-  }
-
-  async deleteCustomNetwork(id: number) {
-    try {
-      const { selectedAddress } = this.state;
-      const apiUrl = new URL(this.config.api);
-      apiUrl.pathname = `/customnetwork/${id}`;
-      await remove(apiUrl.href, {}, this.headers(selectedAddress), { useAPIKey: true });
-      await this.sync(selectedAddress);
-      return true;
-    } catch {
-      log.error("error deleting custom network");
-      return false;
-    }
-  }
-
-  async editCustomNetwork({ network, id }: { network: CustomNetworkPayload; id: number | null }) {
-    try {
-      const { selectedAddress } = this.state;
-      const apiUrl = new URL(this.config.api);
-      apiUrl.pathname = `/customnetwork/${id}`;
-
-      const payload: Partial<CustomNetworks> = {
-        network_name: network.displayName,
-        rpc_url: network.rpcTarget,
-        chain_id: network.chainId,
-        symbol: network.ticker || undefined,
-        block_explorer_url: network.blockExplorerUrl || undefined,
-        is_testnet: network.isTestnet || false,
-      };
-      await patch(apiUrl.href, payload, this.headers(selectedAddress), { useAPIKey: true });
-      await this.sync(selectedAddress);
-      return true;
-    } catch {
-      log.error("error editing custom network");
-      return false;
-    }
-  }
-
-  private getChainOptions(address: string = this.state.selectedAddress): EthereumProviderConfig[] {
-    const { identities } = this.state;
-    const customNetworks = identities[address]?.customNetworks ?? [];
-
-    const custom: EthereumProviderConfig[] = Object.values(customNetworks).reduce((chains, network) => {
-      const networkItem = {
-        blockExplorerUrl: network.block_explorer_url,
-        chainId: network.chain_id,
-        displayName: network.network_name,
-        logo: "eth.svg",
-        rpcTarget: network.rpc_url,
-        ticker: network.symbol,
-        tickerName: network.symbol.toUpperCase(),
-        isCustom: true,
-        id: network.id,
-      };
-      if (Object.keys(SUPPORTED_NETWORKS).includes(networkItem.chainId)) return chains;
-      chains.push(networkItem);
-      return chains;
-    }, []);
-
-    const supported = Object.values(SUPPORTED_NETWORKS).reduce((chains, network) => {
-      chains.push(network);
-      return chains;
-    }, []);
-
-    return [...supported, ...custom];
-  }
-
-  private async calculatePastTx(txs: FetchedTransaction[], address: string) {
-    const pastTx = [];
-    const pendingTx = [];
-    const lowerCaseSelectedAddress = address.toLowerCase();
-    for (const x of txs) {
-      if (
-        x.chain_id === SUPPORTED_NETWORKS[this.getProviderConfig().chainId].chainId &&
-        x.to &&
-        x.from &&
-        (lowerCaseSelectedAddress === x.from.toLowerCase() || lowerCaseSelectedAddress === x.to?.toLowerCase())
-      ) {
-        if (x.status !== "confirmed") {
-          pendingTx.push(x);
-        } else {
-          const finalObject = formatPastTx(x, lowerCaseSelectedAddress);
-          pastTx.push(finalObject);
-        }
-      }
-    }
-    const pendingTxPromises = pendingTx.map((x) => getEthTxStatus(x.transaction_hash, this.provider).catch((error) => log.error(error)));
-    const resolvedTxStatuses = await Promise.all(pendingTxPromises);
-    for (const [index, element] of pendingTx.entries()) {
-      const finalObject = formatPastTx(element, lowerCaseSelectedAddress);
-      finalObject.status = resolvedTxStatuses[index] || TransactionStatus.submitted;
-      pastTx.push(finalObject);
-      if (lowerCaseSelectedAddress === element.from.toLowerCase() && finalObject.status && finalObject.status !== element.status)
-        this.patchPastTx({ id: element.id, status: finalObject.status }, address);
-    }
-
-    const finalTx = this.cancelTxCalculate(pastTx);
-
-    this.updateState({ formattedPastTransactions: [...finalTx] }, address);
-  }
-
-  private cancelTxCalculate(pastTx: FormattedTransactionActivity[]) {
-    const nonceMap: Record<string, FormattedTransactionActivity[]> = {};
-    for (const x of pastTx) {
-      if (!nonceMap[x.nonce]) nonceMap[x.nonce] = [x];
-      else {
-        nonceMap[x.nonce].push(x);
-      }
-    }
-
-    for (const [, value] of Object.entries(nonceMap)) {
-      // has duplicate
-      if (value.length > 1) {
-        // get latest and mark it as is_cancel
-        const latestTxs = value.sort((a, b) => {
-          const aDate = new Date(a.date).getTime();
-          const bDate = new Date(b.date).getTime();
-          return bDate - aDate;
-        });
-        const latestCancelTx = latestTxs[0];
-        latestCancelTx.is_cancel = true;
-        latestTxs.slice(1).forEach((x) => {
-          x.hasCancel = true;
-          x.status = latestCancelTx.status === "confirmed" ? TransactionStatus.cancelled : TransactionStatus.cancelling;
-          x.cancelDateInitiated = `${formatTime(new Date(latestCancelTx.date).getTime())} - ${formatDate(latestCancelTx.date)}`;
-          x.etherscanLink = latestCancelTx.etherscanLink;
-          x.cancelGas = latestCancelTx.gas;
-          x.cancelGasPrice = latestCancelTx.gasPrice;
-        });
-      }
-    }
-
-    return pastTx;
-  }
-}

package/src/Tokens/ITokensController.ts

@@ -1,13 +0,0 @@
-import { BaseConfig, BaseState } from "@toruslabs/base-controllers";
-
-import { CustomTokenInfo } from "../utils/interfaces";
-
-export interface TokensControllerConfig extends BaseConfig {
-  interval?: number;
-  selectedAddress: string;
-  chainId: string;
-}
-
-export interface TokensControllerState extends BaseState {
-  tokens: Record<string, CustomTokenInfo[]>;
-}

package/src/Tokens/TokenHandler.ts

@@ -1,60 +0,0 @@
-import BigNumber from "bignumber.js";
-import { BrowserProvider, Contract } from "ethers";
-import log from "loglevel";
-
-import { erc20Abi } from "../utils/abis";
-
-export interface ITokenOptions {
-  address: string;
-  symbol: string;
-  decimals: number;
-  name: string;
-  provider: BrowserProvider;
-}
-
-export class TokenHandler {
-  public address: string;
-
-  public symbol: string;
-
-  public decimals: number;
-
-  public name: string;
-
-  public contract: Contract;
-
-  constructor({ address, symbol, decimals, name, provider }: ITokenOptions) {
-    this.address = address;
-
-    this.contract = new Contract(address, erc20Abi, provider);
-    this.symbol = symbol;
-    this.decimals = decimals;
-    this.name = name;
-  }
-
-  public async getSymbol(): Promise<string> {
-    if (!this.symbol || this.symbol === "ERC20") this.symbol = await this.contract.symbol();
-    return this.symbol;
-  }
-
-  public async getDecimals(): Promise<number> {
-    try {
-      if (!this.decimals) this.decimals = await this.contract.decimals();
-      return this.decimals;
-    } catch (error) {
-      log.warn(`Could not get decimals for token ${this.address}`, error);
-      return 0;
-    }
-  }
-
-  public async getName(): Promise<string> {
-    if (!this.name) this.name = await this.contract.name();
-    return this.name;
-  }
-
-  public async getUserBalance(userAddress: string) {
-    if (!this.decimals) await this.getDecimals();
-    const balance = await this.contract.balanceOf(userAddress);
-    return new BigNumber(balance).toString(16);
-  }
-}

package/src/Tokens/TokenRatesController.ts

@@ -1,134 +0,0 @@
-import { BaseConfig, BaseController, BaseState, PreferencesState } from "@toruslabs/base-controllers";
-import { get } from "@toruslabs/http-helpers";
-import log from "loglevel";
-
-import { COINGECKO_PLATFORMS_CHAIN_CODE_MAP, COINGECKO_SUPPORTED_CURRENCIES } from "../utils/constants";
-import { idleTimeTracker } from "../utils/helpers";
-import { CustomTokenInfo, EthereumNetworkState, ExtendedAddressPreferences } from "../utils/interfaces";
-import { TokensControllerState } from "./ITokensController";
-
-export interface CoinGeckoResponse {
-  [address: string]: {
-    [currency: string]: number;
-  };
-}
-
-export type ContractExchangeRates = Record<string, number | undefined>;
-
-export const DEFAULT_CURRENCY = "eth";
-
-export interface ITokenRatesControllerState extends BaseState {
-  contractExchangeRates: ContractExchangeRates;
-}
-
-export interface ITokenRatesControllerConfig extends BaseConfig {
-  pollInterval: number;
-  api: string;
-  currencyApi: string;
-  chainId: string;
-  selectedAddress: string;
-  nativeCurrency: string;
-  tokens: CustomTokenInfo[];
-}
-
-export interface TokenRatesControllerOptions {
-  config: Partial<ITokenRatesControllerConfig>;
-  state: Partial<ITokenRatesControllerState>;
-  onPreferencesStateChange: (listener: (preferencesState: PreferencesState<ExtendedAddressPreferences>) => void) => void;
-  onTokensStateChange: (listener: (tokensState: TokensControllerState) => void) => void;
-  onNetworkStateChange: (listener: (networkState: EthereumNetworkState) => void) => void;
-}
-
-export class TokenRatesController extends BaseController<ITokenRatesControllerConfig, ITokenRatesControllerState> {
-  private conversionInterval: number;
-
-  constructor({ config, state, onPreferencesStateChange, onNetworkStateChange, onTokensStateChange }: TokenRatesControllerOptions) {
-    super({ config, state });
-    this.defaultState = {
-      ...this.defaultState,
-      contractExchangeRates: {},
-    };
-    this.initialize();
-
-    onPreferencesStateChange((preferencesState) => {
-      const { selectedAddress } = preferencesState;
-      this.configure({ selectedAddress });
-    });
-
-    onNetworkStateChange((networkState) => {
-      const { chainId, ticker } = networkState.providerConfig;
-      this.configure({ chainId, nativeCurrency: ticker });
-    });
-
-    onTokensStateChange((tokensState) => {
-      const { tokens } = tokensState;
-      const currentUserTokens = tokens[this.config.selectedAddress];
-      if (currentUserTokens?.length > 0 && this.config.tokens !== tokens[this.config.selectedAddress]) {
-        this.configure({ tokens: tokens[this.config.selectedAddress] });
-        this.updateExchangeRates();
-      }
-    });
-  }
-
-  /**
-   * Creates a new poll, using setInterval, to periodically call updateConversionRate. The id of the interval is
-   * stored at the controller's conversionInterval property. If it is called and such an id already exists, the
-   * previous interval is clear and a new one is created.
-   */
-  public scheduleConversionInterval(): void {
-    if (this.conversionInterval) {
-      window.clearInterval(this.conversionInterval);
-    }
-    this.conversionInterval = window.setInterval(() => {
-      if (!idleTimeTracker.checkIfIdle()) {
-        this.updateExchangeRates();
-      }
-    }, this.config.pollInterval);
-  }
-
-  public async updateExchangeRates() {
-    const chainCodes = COINGECKO_PLATFORMS_CHAIN_CODE_MAP[this.config.chainId];
-    let newContractExchangeRates: ContractExchangeRates = {};
-    if (!chainCodes) {
-      log.info(`ChainId ${this.config.chainId} not supported by coingecko`);
-      this.config.tokens.forEach((token) => {
-        newContractExchangeRates[token.tokenAddress] = undefined;
-      });
-    } else {
-      newContractExchangeRates = await this.fetchExchangeRates(this.config.nativeCurrency, chainCodes);
-    }
-    this.update({ contractExchangeRates: newContractExchangeRates });
-  }
-
-  private async fetchExchangeRates(nativeCurrency: string, chainCodes: { platform: string; currency: string }): Promise<ContractExchangeRates> {
-    const contractAddresses = this.config.tokens.map((token) => token.tokenAddress);
-
-    const isNativeCurrencySupported = COINGECKO_SUPPORTED_CURRENCIES.has(nativeCurrency.toLowerCase());
-    if (isNativeCurrencySupported) {
-      const response = await get<CoinGeckoResponse>(
-        `${this.config.api}/simple/token_price/${chainCodes.platform}?contract_addresses=${contractAddresses.join(
-          ","
-        )}&vs_currencies=${nativeCurrency.toLowerCase()}&include_market_cap=false&include_24hr_vol=false&include_24hr_change=false&include_last_updated_at=false`
-      );
-      const newContractExchangeRates: ContractExchangeRates = {};
-      Object.keys(response).forEach((contractAddress) => {
-        newContractExchangeRates[contractAddress] = response[contractAddress][nativeCurrency.toLowerCase()] || 0;
-      });
-      return newContractExchangeRates;
-    }
-    const [response, currencyResponse] = await Promise.all([
-      get<CoinGeckoResponse>(
-        `${this.config.api}/simple/token_price/${chainCodes.platform}?contract_addresses=${contractAddresses.join(
-          ","
-        )}&vs_currencies=${DEFAULT_CURRENCY}&include_market_cap=false&include_24hr_vol=false&include_24hr_change=false&include_last_updated_at=false`
-      ),
-      get<Record<string, string>>(`${this.config.currencyApi}/currency?fsym=${nativeCurrency.toUpperCase()}&tsyms=${DEFAULT_CURRENCY.toUpperCase()}`),
-    ]);
-    const newContractExchangeRates: ContractExchangeRates = {};
-    Object.keys(response).forEach((contractAddress) => {
-      newContractExchangeRates[contractAddress] =
-        response[contractAddress][DEFAULT_CURRENCY] * Number.parseFloat(currencyResponse[DEFAULT_CURRENCY]) || 0;
-    });
-    return newContractExchangeRates;
-  }
-}