@ledgerhq/live-common 23.1.0 → 24.0.0-next.2

package/src/derivation.ts

@@ -157,12 +157,13 @@ const modes = Object.freeze({
   // glif legacy derivation
   gliflegacy: {
     overridesDerivation: "44'/1'/0'/0/<account>",
-    tag: "legacy",
+    tag: "glif-legacy",
   },
   // glif normal derivation
   glif: {
     overridesDerivation: "44'/461'/0'/0/<account>",
     startsAt: 1,
+    tag: "glif",
   },
   solanaMain: {
     isNonIterable: true,

package/src/env.ts

@@ -1,7 +1,7 @@
-import { $ElementType } from "utility-types";
+import mapValues from "lodash/mapValues";
 // set and get environment & config variables
 import { Subject } from "rxjs";
-import mapValues from "lodash/mapValues";
+import { $ElementType } from "utility-types";
 type EnvDef<V> = {
   desc: string;
   def: V;
@@ -400,6 +400,16 @@ const envDefinitions = {
     parser: stringParser,
     desc: "mock the server response for the exchange KYC check, options are 'open', 'pending', 'closed' or 'approved'.",
   },
+  MOCK_SWAP_CHECK_QUOTE: {
+    def: "",
+    parser: stringParser,
+    desc: "mock the server response for the exchange check quote, options are 'RATE_VALID', 'KYC_FAILED', 'KYC_PENDING', 'KYC_UNDEFINED', 'KYC_UPGRADE_REQUIRED', 'MFA_REQUIRED', 'OVER_TRADE_LIMIT', 'UNKNOW_USER' or 'UNKNOWN_ERROR'.",
+  },
+  MOCK_SWAP_WIDGET_BASE_URL: {
+    def: "",
+    parser: stringParser,
+    desc: "mock the FTX swap widget base url",
+  },
   /**
    * Note: the mocked cryptoassets config and test partner are signed with the
    * Ledger test private key

package/src/errors.ts

@@ -160,7 +160,6 @@ export const SwapSubmitKYCFailed = createCustomErrorClass(
   "SwapSubmitKYCFailed"
 );
 
-export const SwapUnknownSwapId = createCustomErrorClass("SwapUnknownSwapId");
 export const SwapGenericAPIError = createCustomErrorClass(
   "SwapGenericAPIError"
 );

package/src/exchange/index.ts

@@ -46,6 +46,13 @@ export type ExchangeProviderNameAndSignature = {
   nameAndPubkey: Buffer;
   signature: Buffer;
 };
+
+export type SwapProviderConfig = ExchangeProviderNameAndSignature & {
+  curve: string;
+  needsKYC: boolean;
+  needsBearerToken: boolean;
+};
+
 export const isExchangeSupportedByApp = (
   appName: string,
   appVersion: string

package/src/exchange/swap/checkQuote.test.ts

@@ -0,0 +1,53 @@
+import axios from "axios";
+import checkQuote from "./checkQuote";
+
+jest.mock("axios");
+const mockedAxios = jest.mocked(axios);
+
+const provider = "changelly";
+const quoteId = "RATE_ID";
+const bearerToken = "BEARER_TOKEN";
+
+describe("swap/checkQuote", () => {
+  test("should return response in case of valid rate", async () => {
+    const data = {
+      code: 1,
+      codeName: "RATE_VALID",
+      description: "KYC check passed",
+    };
+
+    const resp = {
+      data,
+      status: 200,
+      statusText: "",
+      headers: {},
+      config: {},
+    };
+
+    mockedAxios.mockResolvedValue(Promise.resolve(resp));
+    const res = await checkQuote({ provider, quoteId, bearerToken });
+
+    expect(res).toEqual(data);
+  });
+
+  test("should return response in case of invalid rate", async () => {
+    const data = {
+      code: 204,
+      codeName: "MFA_REQUIRED",
+      description: "MFA Required",
+    };
+
+    const resp = {
+      data,
+      status: 200,
+      statusText: "",
+      headers: {},
+      config: {},
+    };
+
+    mockedAxios.mockResolvedValue(Promise.resolve(resp));
+    const res = await checkQuote({ provider, quoteId, bearerToken });
+
+    expect(res).toEqual(data);
+  });
+});

package/src/exchange/swap/checkQuote.ts

@@ -0,0 +1,34 @@
+import { getEnv } from "../../env";
+import network from "../../network";
+import { getSwapAPIBaseURL } from "./";
+import { mockCheckQuote } from "./mock";
+import type { CheckQuote } from "./types";
+
+const checkQuote: CheckQuote = async ({ provider, quoteId, bearerToken }) => {
+  if (getEnv("MOCK") || getEnv("MOCK_SWAP_CHECK_QUOTE")) {
+    return mockCheckQuote({ provider, quoteId, bearerToken });
+  }
+
+  const request = {
+    provider,
+    rateId: quoteId,
+  };
+
+  const { data } = await network({
+    method: "POST",
+    url: `${getSwapAPIBaseURL()}/rate/check`,
+    headers: {
+      Authorization: `Bearer ${bearerToken}`,
+    },
+    data: request,
+  });
+
+  /**
+   * TODO: we might want to handle various status and error here
+   * cf. https://github.com/LedgerHQ/swap/blob/master/modules/model/src/main/scala/co/ledger/swap/model/RateStatus.scala
+   */
+
+  return data;
+};
+
+export default checkQuote;

package/src/exchange/swap/completeExchange.ts

@@ -1,22 +1,20 @@
+import { TransportStatusError, WrongDeviceForAccount } from "@ledgerhq/errors";
 import { log } from "@ledgerhq/logs";
 import { from, Observable } from "rxjs";
 import secp256k1 from "secp256k1";
-import { TransportStatusError, WrongDeviceForAccount } from "@ledgerhq/errors";
-
-import { delay } from "../../promise";
-import ExchangeTransport from "../hw-app-exchange/Exchange";
-import perFamily from "../../generated/exchange";
+import { getCurrencyExchangeConfig } from "../";
 import { getAccountCurrency, getMainAccount } from "../../account";
 import { getAccountBridge } from "../../bridge";
 import { TransactionRefusedOnDevice } from "../../errors";
+import perFamily from "../../generated/exchange";
 import { withDevice } from "../../hw/deviceAccess";
-import { getProviderNameAndSignature } from "./";
-import { getCurrencyExchangeConfig } from "../";
-
+import { delay } from "../../promise";
+import ExchangeTransport from "../hw-app-exchange/Exchange";
 import type {
   CompleteExchangeInputSwap,
   CompleteExchangeRequestEvent,
 } from "../platform/types";
+import { getProviderConfig } from "./";
 
 const withDevicePromise = (deviceId, fn) =>
   withDevice(deviceId)((transport) => from(fn(transport))).toPromise();
@@ -45,7 +43,7 @@ const completeExchange = (
 
     const confirmExchange = async () => {
       await withDevicePromise(deviceId, async (transport) => {
-        const providerNameAndSignature = getProviderNameAndSignature(provider);
+        const providerConfig = getProviderConfig(provider);
         const exchange = new ExchangeTransport(
           transport,
           exchangeType,
@@ -75,10 +73,10 @@ const completeExchange = (
         const errorsKeys = Object.keys(errors);
         if (errorsKeys.length > 0) throw errors[errorsKeys[0]]; // throw the first error
 
-        await exchange.setPartnerKey(providerNameAndSignature.nameAndPubkey);
+        await exchange.setPartnerKey(providerConfig.nameAndPubkey);
         if (unsubscribed) return;
 
-        await exchange.checkPartner(providerNameAndSignature.signature);
+        await exchange.checkPartner(providerConfig.signature);
         if (unsubscribed) return;
 
         await exchange.processTransaction(

package/src/exchange/swap/getExchangeRates.test.ts

@@ -1,13 +1,12 @@
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import axios from "axios";
 import BigNumber from "bignumber.js";
-import { mocked } from "ts-jest/utils";
 import { Account, Transaction } from "../../types";
 import getExchangeRates from "./getExchangeRates";
 import { Exchange, ExchangeRate } from "./types";
 
 jest.mock("axios");
-const mockedAxios = mocked(axios);
+const mockedAxios = jest.mocked(axios);
 
 const bitcoinCurrency = getCryptoCurrencyById("bitcoin");
 const ethereumCurrency = getCryptoCurrencyById("ethereum");

package/src/exchange/swap/getExchangeRates.ts

@@ -13,9 +13,9 @@ import type {
   Transaction,
   Unit,
 } from "../../types";
-import { getSwapAPIBaseURL, getSwapAPIError } from "./";
+import { getAvailableProviders, getSwapAPIBaseURL, getSwapAPIError } from "./";
 import { mockGetExchangeRates } from "./mock";
-import type { Exchange, GetExchangeRates } from "./types";
+import type { CustomMinOrMaxError, Exchange, GetExchangeRates } from "./types";
 
 const getExchangeRates: GetExchangeRates = async (
   exchange: Exchange,
@@ -40,6 +40,7 @@ const getExchangeRates: GetExchangeRates = async (
     from,
     to,
     amountFrom: apiAmount.toString(),
+    providers: usesV3 ? getAvailableProviders() : undefined,
   };
   const res = await network({
     method: "POST",
@@ -122,7 +123,7 @@ const inferError = (
     errorCode?: number;
     errorMessage?: string;
   }
-): Error | undefined => {
+): Error | CustomMinOrMaxError | undefined => {
   const tenPowMagnitude = new BigNumber(10).pow(unitFrom.magnitude);
   const { amountTo, minAmountFrom, maxAmountFrom, errorCode, errorMessage } =
     responseData;
@@ -157,6 +158,7 @@ const inferError = (
             showCode: true,
           }
         ),
+        amount: new BigNumber(amount),
       });
     }
   }

package/src/exchange/swap/getProviders.ts

@@ -1,15 +1,23 @@
-import type { GetProviders } from "./types";
-import network from "../../network";
-import { getSwapAPIBaseURL } from "./";
+import qs from "qs";
 import { getEnv } from "../../env";
-import { mockGetProviders } from "./mock";
 import { SwapNoAvailableProviders } from "../../errors";
+import network from "../../network";
+import { getAvailableProviders, getSwapAPIBaseURL } from "./";
+import { mockGetProviders } from "./mock";
+import type { GetProviders } from "./types";
 
 const getProviders: GetProviders = async () => {
   if (getEnv("MOCK")) return mockGetProviders();
+
+  // Rely on the api base to determine the version logic
+  const usesV3 = getSwapAPIBaseURL().endsWith("v3");
+
   const res = await network({
     method: "GET",
     url: `${getSwapAPIBaseURL()}/providers`,
+    params: usesV3 ? { whitelist: getAvailableProviders() } : undefined,
+    paramsSerializer: (params) =>
+      qs.stringify(params, { arrayFormat: "comma" }),
   });
 
   if (!res.data.length) {

package/src/exchange/swap/getStatus.ts

@@ -1,18 +1,9 @@
+import { getEnv } from "../../env";
 import network from "../../network";
 import { getSwapAPIBaseURL } from "./";
-import type { GetMultipleStatus, GetStatus } from "./types";
-import { getEnv } from "../../env";
 import { mockGetStatus } from "./mock";
-import { SwapUnknownSwapId } from "../../errors";
-export const getStatus: GetStatus = async (status) => {
-  const updatedStatus = await getMultipleStatus([status]);
+import type { GetMultipleStatus } from "./types";
 
-  if (updatedStatus && updatedStatus.length) {
-    return updatedStatus[0];
-  }
-
-  throw new SwapUnknownSwapId(undefined, { ...status });
-};
 export const getMultipleStatus: GetMultipleStatus = async (statusList) => {
   if (getEnv("MOCK")) return mockGetStatus(statusList);
   const res = await network({
@@ -22,4 +13,3 @@ export const getMultipleStatus: GetMultipleStatus = async (statusList) => {
   });
   return res.data;
 };
-export default getStatus;

package/src/exchange/swap/hooks/usePollKYCStatus.test.ts

@@ -1,6 +1,4 @@
 import { renderHook } from "@testing-library/react-hooks";
-import { mocked } from "ts-jest/utils";
-
 import {
   usePollKYCStatus,
   KYC_STATUS_POLLING_INTERVAL,
@@ -12,7 +10,7 @@ import { KYCStatus } from "../types";
 
 // mock getKYCStatus
 jest.mock("..");
-const mockedGetKYCStatus = mocked(getKYCStatus, true);
+const mockedGetKYCStatus = jest.mocked(getKYCStatus, true);
 
 describe("usePollKYCStatus", () => {
   const defaultInput: UsePollKYCStatusProps = {

package/src/exchange/swap/hooks/useProviderRates.test.ts

@@ -1,9 +1,12 @@
-import { renderHook, act } from "@testing-library/react-hooks";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { act, renderHook } from "@testing-library/react-hooks";
 import BigNumber from "bignumber.js";
-import { mocked } from "ts-jest/utils";
 import { useProviderRates } from ".";
 import { getExchangeRates } from "..";
+import {
+  SwapExchangeRateAmountTooHigh,
+  SwapExchangeRateAmountTooLow,
+} from "../../../errors";
 import { genAccount } from "../../../mock/account";
 import { mockGetExchangeRates } from "../mock";
 
@@ -15,7 +18,7 @@ const fromAccount = genAccount("from-account", {
   currency: ETH,
 });
 
-const mockedGetExchangeRates = mocked(getExchangeRates, true);
+const mockedGetExchangeRates = jest.mocked(getExchangeRates, true);
 const mockedRatesPromise = mockGetExchangeRates(
   { fromAccount } as any,
   { amount: new BigNumber(1) } as any,
@@ -185,6 +188,104 @@ describe("useProviderRates", () => {
     expect(result.current.rates.value).toBeUndefined();
   });
 
+  it("should sort SwapExchangeRateAmountTooLow based on amount", async () => {
+    const swapExchangeRateAmountTooLowError1 = new SwapExchangeRateAmountTooLow(
+      undefined,
+      {
+        amount: new BigNumber(1),
+      }
+    );
+
+    const swapExchangeRateAmountTooLowError2 = new SwapExchangeRateAmountTooLow(
+      undefined,
+      {
+        amount: new BigNumber(2),
+      }
+    );
+
+    mockedRates[0].error = swapExchangeRateAmountTooLowError2;
+    mockedRates[1].error = swapExchangeRateAmountTooLowError1;
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRates);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(swapExchangeRateAmountTooLowError1);
+    expect(result.current.rates.value).toBeUndefined();
+  });
+
+  it("should sort SwapExchangeRateAmountTooHigh based on amount", async () => {
+    const swapExchangeRateAmountTooHighError1 =
+      new SwapExchangeRateAmountTooHigh(undefined, {
+        amount: new BigNumber(1),
+      });
+
+    const swapExchangeRateAmountTooHighError2 =
+      new SwapExchangeRateAmountTooHigh(undefined, {
+        amount: new BigNumber(2),
+      });
+
+    mockedRates[0].error = swapExchangeRateAmountTooHighError1;
+    mockedRates[1].error = swapExchangeRateAmountTooHighError2;
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRates);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(
+      swapExchangeRateAmountTooHighError2
+    );
+    expect(result.current.rates.value).toBeUndefined();
+  });
+
+  it("SwapExchangeRateAmountTooLow should take precedence over standard errors", async () => {
+    const swapExchangeRateAmountTooLowError = new SwapExchangeRateAmountTooLow(
+      undefined,
+      {
+        amount: new BigNumber(1),
+      }
+    );
+
+    const standardError = new Error("Error");
+
+    mockedRates[0].error = standardError;
+    mockedRates[1].error = swapExchangeRateAmountTooLowError;
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRates);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(swapExchangeRateAmountTooLowError);
+    expect(result.current.rates.value).toBeUndefined();
+  });
+
+  it("SwapExchangeRateAmountTooHigh should take precedence over standard errors", async () => {
+    const SwapExchangeRateAmountTooHighError =
+      new SwapExchangeRateAmountTooHigh(undefined, {
+        amount: new BigNumber(1),
+      });
+
+    const standardError = new Error("Error");
+
+    mockedRates[0].error = standardError;
+    mockedRates[1].error = SwapExchangeRateAmountTooHighError;
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRates);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(SwapExchangeRateAmountTooHighError);
+    expect(result.current.rates.value).toBeUndefined();
+  });
+
   it("should call 'onNoRates' if there are no rates returned by the server", async () => {
     const onNoRates = jest.fn(() => {});
     mockedGetExchangeRates.mockResolvedValue([]);

package/src/exchange/swap/hooks/useProviderRates.ts

@@ -1,13 +1,12 @@
 import { useCallback, useEffect, useReducer, useState } from "react";
+import { getExchangeRates } from "..";
+import { Transaction } from "../../../generated/types";
+import type { CustomMinOrMaxError, Exchange, ExchangeRate } from "../types";
 import {
   OnNoRatesCallback,
   SetExchangeRateCallback,
   SwapSelectorStateType,
 } from "./useSwapTransaction";
-import { getExchangeRates } from "..";
-import { Exchange, ExchangeRate } from "../types";
-import { pickExchangeRate } from "../utils";
-import { Transaction } from "../../../generated/types";
 
 export type RatesReducerState = {
   status?: string | null;
@@ -34,14 +33,12 @@ const ratesReducer = (state: RatesReducerState, action): RatesReducerState => {
 export const useProviderRates = ({
   fromState,
   toState,
-  exchangeRate,
   transaction,
   onNoRates,
   setExchangeRate,
 }: {
   fromState: SwapSelectorStateType;
   toState: SwapSelectorStateType;
-  exchangeRate?: ExchangeRate | null | undefined;
   transaction?: Transaction | null | undefined;
   onNoRates?: OnNoRatesCallback | null | undefined;
   setExchangeRate?: SetExchangeRateCallback | null | undefined;
@@ -82,23 +79,74 @@ export const useProviderRates = ({
             undefined,
             toCurrency
           );
+
           if (abort) return;
           if (rates.length === 0) {
             onNoRates && onNoRates({ fromState, toState });
           }
+
           // Discard bad provider rates
-          let rateError: Error | null | undefined = null;
+          let rateError: Error | CustomMinOrMaxError | null | undefined = null;
           rates = rates.reduce<ExchangeRate[]>((acc, rate) => {
             rateError = rateError ?? rate.error;
+
+            /**
+             * If we have an error linked to the ammount, this error takes
+             * precedence over the other (like a "CurrencyNotSupportedError" one
+             * for example)
+             */
+            if (
+              rateError?.name !== rate.error?.name &&
+              (rate.error?.name === "SwapExchangeRateAmountTooLow" ||
+                rate.error?.name === "SwapExchangeRateAmountTooHigh")
+            ) {
+              rateError = rate.error;
+            }
+
+            if (
+              rateError?.name === rate.error?.name &&
+              (rate.error?.name === "SwapExchangeRateAmountTooLow" ||
+                rate.error?.name === "SwapExchangeRateAmountTooHigh")
+            ) {
+              /**
+               * Comparison pivot, depending on the order in which we want to sort errors
+               * If the order is ascending, the pivot is -1, otherwise it's 1
+               * Based on returns from https://mikemcl.github.io/bignumber.js/#cmp
+               */
+              const cmp =
+                rateError?.name === "SwapExchangeRateAmountTooLow" ? -1 : 1;
+
+              /**
+               * If the amount is too low, the user should put at least the
+               * minimum amount possible
+               * If the amount is too high, the user should put at most the
+               * maximum amount possible
+               */
+
+              rateError =
+                (rateError as CustomMinOrMaxError).amount.comparedTo(
+                  (rate.error as CustomMinOrMaxError)?.amount
+                ) === cmp
+                  ? rateError
+                  : rate.error;
+            }
+
             return rate.error ? acc : [...acc, rate];
           }, []);
+
           if (rates.length === 0 && rateError) {
             // If all the rates are in error
             dispatchRates({ type: "error", payload: rateError });
           } else {
             dispatchRates({ type: "set", payload: rates });
-            setExchangeRate &&
-              pickExchangeRate(rates, exchangeRate, setExchangeRate);
+
+            /**
+             * Select the first rate returned by the API. Should be the prefered
+             * rate for the user. Rate ordering logic is handeled on backend side
+             */
+            const rate = rates?.length > 0 ? rates[0] : null;
+
+            setExchangeRate && setExchangeRate(rate);
           }
         } catch (error) {
           !abort && dispatchRates({ type: "error", payload: error });

package/src/exchange/swap/hooks/useSwapProviders.test.ts

@@ -1,12 +1,10 @@
 import { renderHook } from "@testing-library/react-hooks";
-import { mocked } from "ts-jest/utils";
-
 import { useSwapProviders } from "./useSwapProviders";
 import { getProviders } from "..";
 
 jest.mock("..");
 
-const mockedGetProviders = mocked(getProviders);
+const mockedGetProviders = jest.mocked(getProviders);
 
 describe("useSwapProviders", () => {
   const OLD_ENV = process.env;

package/src/exchange/swap/hooks/useSwapTransaction.ts

@@ -1,24 +1,24 @@
-import { useMemo } from "react";
+import { AmountRequired } from "@ledgerhq/errors";
 import { BigNumber } from "bignumber.js";
+import { useMemo } from "react";
+import {
+  RatesReducerState,
+  useFromState,
+  useProviderRates,
+  useToState,
+} from ".";
 import useBridgeTransaction, {
   Result as UseBridgeTransactionReturnType,
 } from "../../../bridge/useBridgeTransaction";
 import type {
   Account,
+  CryptoCurrency,
   TokenAccount,
   TokenCurrency,
-  CryptoCurrency,
 } from "../../../types";
 import { ExchangeRate } from "../types";
-import { AmountRequired } from "@ledgerhq/errors";
-import { useUpdateMaxAmount } from "./useUpdateMaxAmount";
-import {
-  RatesReducerState,
-  useFromState,
-  useProviderRates,
-  useToState,
-} from ".";
 import { useReverseAccounts } from "./useReverseAccounts";
+import { useUpdateMaxAmount } from "./useUpdateMaxAmount";
 
 export type SwapSelectorStateType = {
   currency: null | undefined | TokenCurrency | CryptoCurrency;
@@ -65,6 +65,7 @@ export type OnNoRatesCallback = (arg: {
 export type SetExchangeRateCallback = (
   exchangeRate?: ExchangeRate | null
 ) => void;
+export type SetIsSendMaxLoading = (boolean) => void;
 
 export const useFromAmountError = (
   errors: Record<string, Error | undefined>
@@ -82,16 +83,16 @@ export const useFromAmountError = (
 
 export const useSwapTransaction = ({
   accounts,
-  exchangeRate,
   setExchangeRate,
+  setIsSendMaxLoading,
   defaultCurrency = selectorStateDefaultValues.currency,
   defaultAccount = selectorStateDefaultValues.account,
   defaultParentAccount = selectorStateDefaultValues.parentAccount,
   onNoRates,
 }: {
   accounts?: Account[];
-  exchangeRate?: ExchangeRate;
   setExchangeRate?: SetExchangeRateCallback;
+  setIsSendMaxLoading?: SetIsSendMaxLoading;
   defaultCurrency?: SwapSelectorStateType["currency"];
   defaultAccount?: SwapSelectorStateType["account"];
   defaultParentAccount?: SwapSelectorStateType["parentAccount"];
@@ -136,12 +137,12 @@ export const useSwapTransaction = ({
     parentAccount: fromParentAccount,
     transaction,
     feesStrategy: transaction?.feesStrategy,
+    setIsSendMaxLoading,
   });
 
   const { rates, refetchRates } = useProviderRates({
     fromState,
     toState,
-    exchangeRate,
     transaction,
     onNoRates,
     setExchangeRate,