chore: use price-api to fetch exchange rates and fallback to crypto-compare

Author: sahar-fehri

packages/assets-controllers/src/CurrencyRateController.test.ts

@@ -12,6 +12,7 @@ import { StaticIntervalPollingController } from '@metamask/polling-controller';
 import { Mutex } from 'async-mutex';
 
 import { fetchMultiExchangeRate as defaultFetchMultiExchangeRate } from './crypto-compare-service';
+import type { AbstractTokenPricesService } from './token-prices-service/abstract-token-prices-service';
 
 /**
  * @type CurrencyRateState
@@ -107,6 +108,8 @@ export class CurrencyRateController extends StaticIntervalPollingController<Curr
 
   private readonly useExternalServices: () => boolean;
 
+  readonly #tokenPricesService: AbstractTokenPricesService;
+
   /**
    * Creates a CurrencyRateController instance.
    *
@@ -117,6 +120,7 @@ export class CurrencyRateController extends StaticIntervalPollingController<Curr
    * @param options.state - Initial state to set on this controller.
    * @param options.useExternalServices - Feature Switch for using external services (default: true)
    * @param options.fetchMultiExchangeRate - Fetches the exchange rate from an external API. This option is primarily meant for use in unit tests.
+   * @param options.tokenPricesService - An object in charge of retrieving token prices
    */
   constructor({
     includeUsdRate = false,
@@ -125,13 +129,15 @@ export class CurrencyRateController extends StaticIntervalPollingController<Curr
     messenger,
     state,
     fetchMultiExchangeRate = defaultFetchMultiExchangeRate,
+    tokenPricesService,
   }: {
     includeUsdRate?: boolean;
     interval?: number;
     messenger: CurrencyRateMessenger;
     state?: Partial<CurrencyRateState>;
     useExternalServices?: () => boolean;
     fetchMultiExchangeRate?: typeof defaultFetchMultiExchangeRate;
+    tokenPricesService: AbstractTokenPricesService;
   }) {
     super({
       name,
@@ -143,6 +149,7 @@ export class CurrencyRateController extends StaticIntervalPollingController<Curr
     this.useExternalServices = useExternalServices;
     this.setIntervalLength(interval);
     this.fetchMultiExchangeRate = fetchMultiExchangeRate;
+    this.#tokenPricesService = tokenPricesService;
   }
 
   /**
@@ -168,6 +175,73 @@ export class CurrencyRateController extends StaticIntervalPollingController<Curr
     this.updateExchangeRate(nativeCurrencies);
   }
 
+  async #fetchExchangeRatesWithFallback(
+    nativeCurrenciesToFetch: Record<string, string>,
+  ): Promise<CurrencyRateState['currencyRates']> {
+    const { currentCurrency } = this.state;
+
+    try {
+      const priceApiExchangeRatesResponse =
+        await this.#tokenPricesService.fetchExchangeRates({
+          baseCurrency: currentCurrency,
+          includeUsdRate: this.includeUsdRate,
+          cryptocurrencies: [
+            ...new Set(Object.values(nativeCurrenciesToFetch)),
+          ],
+        });
+
+      const ratesPriceApi = Object.entries(nativeCurrenciesToFetch).reduce(
+        (acc, [nativeCurrency, fetchedCurrency]) => {
+          const rate =
+            priceApiExchangeRatesResponse[fetchedCurrency.toLowerCase()];
+
+          acc[nativeCurrency] = {
+            conversionDate: rate !== undefined ? Date.now() / 1000 : null,
+            conversionRate: rate?.value
+              ? Number((1 / rate?.value).toFixed(2))
+              : null,
+            usdConversionRate: rate?.usd
+              ? Number((1 / rate?.usd).toFixed(2))
+              : null,
+          };
+          return acc;
+        },
+        {} as CurrencyRateState['currencyRates'],
+      );
+      return ratesPriceApi;
+    } catch (error) {
+      console.error('Failed to fetch exchange rates.', error);
+    }
+
+    // fallback to crypto compare
+
+    try {
+      const fetchExchangeRateResponse = await this.fetchMultiExchangeRate(
+        currentCurrency,
+        [...new Set(Object.values(nativeCurrenciesToFetch))],
+        this.includeUsdRate,
+      );
+
+      const rates = Object.entries(nativeCurrenciesToFetch).reduce(
+        (acc, [nativeCurrency, fetchedCurrency]) => {
+          const rate = fetchExchangeRateResponse[fetchedCurrency.toLowerCase()];
+          acc[nativeCurrency] = {
+            conversionDate: rate !== undefined ? Date.now() / 1000 : null,
+            conversionRate: rate?.[currentCurrency.toLowerCase()] ?? null,
+            usdConversionRate: rate?.usd ?? null,
+          };
+          return acc;
+        },
+        {} as CurrencyRateState['currencyRates'],
+      );
+
+      return rates;
+    } catch (error) {
+      console.error('Failed to fetch exchange rates.', error);
+      throw error;
+    }
+  }
+
   /**
    * Updates the exchange rate for the current currency and native currency pairs.
    *
@@ -182,8 +256,6 @@ export class CurrencyRateController extends StaticIntervalPollingController<Curr
 
     const releaseLock = await this.mutex.acquire();
     try {
-      const { currentCurrency } = this.state;
-
       // For preloaded testnets (Goerli, Sepolia) we want to fetch exchange rate for real ETH.
       // Map each native currency to the symbol we want to fetch for it.
       const testnetSymbols = Object.values(TESTNET_TICKER_SYMBOLS);
@@ -201,23 +273,8 @@ export class CurrencyRateController extends StaticIntervalPollingController<Curr
         {} as Record<string, string>,
       );
 
-      const fetchExchangeRateResponse = await this.fetchMultiExchangeRate(
-        currentCurrency,
-        [...new Set(Object.values(nativeCurrenciesToFetch))],
-        this.includeUsdRate,
-      );
-
-      const rates = Object.entries(nativeCurrenciesToFetch).reduce(
-        (acc, [nativeCurrency, fetchedCurrency]) => {
-          const rate = fetchExchangeRateResponse[fetchedCurrency.toLowerCase()];
-          acc[nativeCurrency] = {
-            conversionDate: rate !== undefined ? Date.now() / 1000 : null,
-            conversionRate: rate?.[currentCurrency.toLowerCase()] ?? null,
-            usdConversionRate: rate?.usd ?? null,
-          };
-          return acc;
-        },
-        {} as CurrencyRateState['currencyRates'],
+      const rates = await this.#fetchExchangeRatesWithFallback(
+        nativeCurrenciesToFetch,
       );
 
       this.update((state) => {

packages/assets-controllers/src/CurrencyRateController.ts

@@ -2973,6 +2973,9 @@ function buildMockTokenPricesService(
     async fetchTokenPrices() {
       return {};
     },
+    async fetchExchangeRates() {
+      return {};
+    },
     validateChainIdSupported(_chainId: unknown): _chainId is Hex {
       return true;
     },

packages/assets-controllers/src/TokenRatesController.test.ts

@@ -130,6 +130,9 @@ function buildMockTokenPricesService(
   overrides: Partial<AbstractTokenPricesService> = {},
 ): AbstractTokenPricesService {
   return {
+    async fetchExchangeRates() {
+      return {};
+    },
     async fetchTokenPrices() {
       return {};
     },

packages/assets-controllers/src/TokenSearchDiscoveryDataController/TokenSearchDiscoveryDataController.test.ts

@@ -783,5 +783,8 @@ function createMockPriceService(): AbstractTokenPricesService {
     async fetchTokenPrices() {
       return {};
     },
+    async fetchExchangeRates() {
+      return {};
+    },
   };
 }

packages/assets-controllers/src/assetsUtil.test.ts

@@ -27,6 +27,17 @@ export type TokenPrice<TokenAddress extends Hex, Currency extends string> = {
   totalVolume: number;
 };
 
+/**
+ * Represents an exchange rate.
+ */
+export type ExchangeRate = {
+  name: string;
+  ticker: string;
+  value: number;
+  currencyType: string;
+  usd?: number;
+};
+
 /**
  * A map of token address to its price.
  */
@@ -37,6 +48,13 @@ export type TokenPricesByTokenAddress<
   [A in TokenAddress]: TokenPrice<A, Currency>;
 };
 
+/**
+ * A map of currency to its exchange rate.
+ */
+export type ExchangeRatesByCurrency<Currency extends string> = {
+  [C in Currency]: ExchangeRate;
+};
+
 /**
  * An ideal token prices service. All implementations must confirm to this
  * interface.
@@ -75,6 +93,25 @@ export type AbstractTokenPricesService<
     currency: Currency;
   }): Promise<Partial<TokenPricesByTokenAddress<TokenAddress, Currency>>>;
 
+  /**
+   * Retrieves exchange rates in the given currency.
+   *
+   * @param args - The arguments to this function.
+   * @param args.baseCurrency - The desired currency of the token prices.
+   * @param args.includeUsdRate - Whether to include the USD rate in the response.
+   * @param args.cryptocurrencies - The cryptocurrencies to get exchange rates for.
+   * @returns The exchange rates in the requested base currency.
+   */
+  fetchExchangeRates({
+    baseCurrency,
+    includeUsdRate,
+    cryptocurrencies,
+  }: {
+    baseCurrency: Currency;
+    includeUsdRate: boolean;
+    cryptocurrencies: string[];
+  }): Promise<ExchangeRatesByCurrency<Currency>>;
+
   /**
    * Type guard for whether the API can return token prices for the given chain
    * ID.