@ledgerhq/live-common 24.0.0-next.0 → 24.0.0-next.3

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

@@ -1,8 +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 { useProviderRates } from ".";
 import { getExchangeRates } from "..";
+import {
+  SwapExchangeRateAmountTooHigh,
+  SwapExchangeRateAmountTooLow,
+} from "../../../errors";
 import { genAccount } from "../../../mock/account";
 import { mockGetExchangeRates } from "../mock";
 
@@ -184,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/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,

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

@@ -1,10 +1,10 @@
-import { renderHook, act } from "@testing-library/react-hooks";
 import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
-import { useUpdateMaxAmount, ZERO } from "./useUpdateMaxAmount";
-import { genAccount, genTokenAccount } from "../../../mock/account";
+import { act, renderHook } from "@testing-library/react-hooks";
 import BigNumber from "bignumber.js";
-import ethBridge from "../../../families/ethereum/bridge/mock";
 import { checkAccountSupported } from "../../../account/support";
+import ethBridge from "../../../families/ethereum/bridge/mock";
+import { genAccount, genTokenAccount } from "../../../mock/account";
+import { useUpdateMaxAmount, ZERO } from "./useUpdateMaxAmount";
 
 // Needs to be mocked since userSupportedCurrencies is initially empty.
 jest.mock("../../../account/support");
@@ -77,6 +77,33 @@ describe("updateAmountUsingMax", () => {
     expect(setFromAmount.mock.calls[0][0]).toBe(ZERO);
   });
 
+  it("should toggle setIsSendMaxLoading", async () => {
+    const setIsSendMaxLoading = jest.fn();
+
+    const amount = new BigNumber(0.5);
+    mockedEstimateMaxSpendable.mockResolvedValue(amount);
+    const { result } = renderHook(useUpdateMaxAmount, {
+      initialProps: { ...defaultProps, setIsSendMaxLoading },
+    });
+
+    act(() => result.current.toggleMax());
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(true);
+    setIsSendMaxLoading.mockClear();
+
+    // Lest resort solution, since waitFor and other helpers will not work here.
+    await wait();
+
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(false);
+    setIsSendMaxLoading.mockClear();
+
+    act(() => result.current.toggleMax());
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(false);
+    setIsSendMaxLoading.mockClear();
+  });
+
   it("should update the max amount whenever the dependencies change", async () => {
     const { result, rerender } = renderHook(useUpdateMaxAmount, {
       initialProps: defaultProps,

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

@@ -1,13 +1,13 @@
+import BigNumber from "bignumber.js";
 import { useCallback, useEffect, useState } from "react";
 import { getAccountBridge } from "../../../bridge";
-
+import { Transaction } from "../../../generated/types";
 import {
-  SwapTransactionType,
+  SetIsSendMaxLoading,
   SwapDataType,
   SwapSelectorStateType,
+  SwapTransactionType,
 } from "./useSwapTransaction";
-import { Transaction } from "../../../generated/types";
-import BigNumber from "bignumber.js";
 
 export const ZERO = new BigNumber(0);
 
@@ -17,27 +17,31 @@ export const useUpdateMaxAmount = ({
   parentAccount,
   transaction,
   feesStrategy,
+  setIsSendMaxLoading,
 }: {
   setFromAmount: SwapTransactionType["setFromAmount"];
   account: SwapSelectorStateType["account"];
   parentAccount: SwapSelectorStateType["parentAccount"];
   transaction: SwapTransactionType["transaction"];
   feesStrategy: Transaction["feesStrategy"];
+  setIsSendMaxLoading?: SetIsSendMaxLoading;
 }): {
   isMaxEnabled: SwapDataType["isMaxEnabled"];
   toggleMax: SwapTransactionType["toggleMax"];
 } => {
-  const [isMaxEnabled, setMax] = useState<SwapDataType["isMaxEnabled"]>(false);
+  const [isMaxEnabled, setIsMaxEnabled] =
+    useState<SwapDataType["isMaxEnabled"]>(false);
 
   const toggleMax: SwapTransactionType["toggleMax"] = useCallback(
     () =>
-      setMax((previous) => {
+      setIsMaxEnabled((previous) => {
         if (previous) {
           setFromAmount(ZERO);
+          setIsSendMaxLoading?.(false);
         }
         return !previous;
       }),
-    [setFromAmount]
+    [setFromAmount, setIsSendMaxLoading]
   );
 
   /* UPDATE from amount to the estimate max spendable on account
@@ -47,11 +51,13 @@ export const useUpdateMaxAmount = ({
       const updateAmountUsingMax = async () => {
         if (!account) return;
         const bridge = getAccountBridge(account, parentAccount);
+        setIsSendMaxLoading?.(true);
         const amount = await bridge.estimateMaxSpendable({
           account,
           parentAccount,
           transaction,
         });
+        setIsSendMaxLoading?.(false);
         setFromAmount(amount);
       };
 

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

@@ -0,0 +1,36 @@
+import { isSwapOperationPending } from ".";
+
+describe("swap/index", () => {
+  describe("isSwapOperationPending", () => {
+    test("should return false for ok status", () => {
+      const result = isSwapOperationPending("finished");
+
+      expect(result).toBe(false);
+    });
+
+    test("should return false for ko status", () => {
+      const result = isSwapOperationPending("refunded");
+
+      expect(result).toBe(false);
+    });
+
+    test("should return true for other status", () => {
+      const result = isSwapOperationPending("RANDOM_STATUS");
+
+      expect(result).toBe(true);
+    });
+
+    test("should return true if not status provided", () => {
+      /**
+       * Since this TS function can be used in loosly typed JS code, we need
+       * to test the case of the parameter not being provided
+       */
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = isSwapOperationPending();
+
+      expect(result).toBe(true);
+    });
+  });
+});

package/src/exchange/swap/index.ts

@@ -1,45 +1,60 @@
-import type { ExchangeProviderNameAndSignature } from "../";
-import getExchangeRates from "./getExchangeRates";
-import getStatus from "./getStatus";
-import getProviders from "./getProviders";
-import getCompleteSwapHistory from "./getCompleteSwapHistory";
-import getKYCStatus from "./getKYCStatus";
-import submitKYC from "./submitKYC";
-import initSwap from "./initSwap";
+import type { SwapProviderConfig } from "../";
 import { getEnv } from "../../env";
 import {
-  JSONRPCResponseError,
-  JSONDecodeError,
-  NoIPHeaderError,
-  CurrencyNotSupportedError,
-  CurrencyDisabledError,
+  AccessDeniedError,
   CurrencyDisabledAsInputError,
   CurrencyDisabledAsOutputError,
+  CurrencyDisabledError,
   CurrencyNotSupportedByProviderError,
+  CurrencyNotSupportedError,
+  JSONDecodeError,
+  JSONRPCResponseError,
+  NoIPHeaderError,
+  NotImplementedError,
   TradeMethodNotSupportedError,
   UnexpectedError,
-  NotImplementedError,
   ValidationError,
-  AccessDeniedError,
 } from "../../errors";
+import checkQuote from "./checkQuote";
+import getCompleteSwapHistory from "./getCompleteSwapHistory";
+import getExchangeRates from "./getExchangeRates";
+import getKYCStatus from "./getKYCStatus";
+import getProviders from "./getProviders";
+import initSwap from "./initSwap";
+import { postSwapAccepted, postSwapCancelled } from "./postSwapState";
+import submitKYC from "./submitKYC";
 
 export const operationStatusList = {
   finishedOK: ["finished"],
   finishedKO: ["refunded"],
-  pending: ["pending", "onhold", "expired"],
 };
 
+// A swap operation is considered pending if it is not in a finishedOK or finishedKO state
+export const isSwapOperationPending: (status: string) => boolean = (status) =>
+  !operationStatusList.finishedOK.includes(status) &&
+  !operationStatusList.finishedKO.includes(status);
+
 const getSwapAPIBaseURL: () => string = () => getEnv("SWAP_API_BASE");
 
-const swapProviders: Record<
-  string,
-  {
-    nameAndPubkey: Buffer;
-    signature: Buffer;
-    curve: string;
-    needsKYC: boolean;
-  }
-> = {
+const ftx = {
+  nameAndPubkey: Buffer.concat([
+    Buffer.from([3]),
+    Buffer.from("FTX", "ascii"),
+    Buffer.from(
+      "04c89f3e48cde252f6cd6fcccc47c2f6ca6cf05f9f921703d31b7a7dddbf0bd6a690744662fe599f8761612021ba1fc0e8a5a4b7d5910c625b6dd09aa40762e5cd",
+      "hex"
+    ),
+  ]),
+  signature: Buffer.from(
+    "3044022029c0fb80d6e524f811f30cc04a349fa7f8896ce1ba84010da55f7be5eb9d528802202727985361cab969ad9b4f56570f3f6120c1d77d04ba10e5d99366d8eecee8e2",
+    "hex"
+  ),
+  curve: "secp256k1",
+  needsKYC: true,
+  needsBearerToken: true,
+};
+
+const swapProviders: Record<string, SwapProviderConfig> = {
   changelly: {
     nameAndPubkey: Buffer.from(
       "094368616e67656c6c790480d7c0d3a9183597395f58dda05999328da6f18fabd5cda0aff8e8e3fc633436a2dbf48ecb23d40df7c3c7d3e774b77b4b5df0e9f7e08cf1cdf2dba788eb085b",
@@ -51,6 +66,7 @@ const swapProviders: Record<
     ),
     curve: "secpk256k1",
     needsKYC: false,
+    needsBearerToken: false,
   },
   wyre: {
     nameAndPubkey: Buffer.from(
@@ -63,12 +79,13 @@ const swapProviders: Record<
     ),
     curve: "secpk256k1",
     needsKYC: true,
+    needsBearerToken: false,
   },
+  ftx,
+  ftxus: ftx,
 };
 
-const getProviderNameAndSignature = (
-  providerName: string
-): ExchangeProviderNameAndSignature => {
+const getProviderConfig = (providerName: string): SwapProviderConfig => {
   const res = swapProviders[providerName.toLowerCase()];
 
   if (!res) {
@@ -78,6 +95,8 @@ const getProviderNameAndSignature = (
   return res;
 };
 
+export const getAvailableProviders = (): string[] => Object.keys(swapProviders);
+
 const USStates = {
   AL: "Alabama",
   AK: "Alaska",
@@ -160,14 +179,16 @@ export const getSwapAPIError = (errorCode: number, errorMessage?: string) => {
 
 export {
   getSwapAPIBaseURL,
-  getProviderNameAndSignature,
+  getProviderConfig,
   getProviders,
-  getStatus,
   getExchangeRates,
   getCompleteSwapHistory,
+  postSwapAccepted,
+  postSwapCancelled,
   initSwap,
   getKYCStatus,
   submitKYC,
+  checkQuote,
   USStates,
   countries,
 };