@ledgerhq/live-common 21.5.1-btcjs.0 → 21.7.0

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

@@ -0,0 +1,134 @@
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import { renderHook, act } from "@testing-library/react-hooks";
+import BigNumber from "bignumber.js";
+import { selectorStateDefaultValues } from ".";
+import useBridgeTransaction from "../../../bridge/useBridgeTransaction";
+import { genAccount, genTokenAccount } from "../../../mock/account";
+import { Account } from "../../../types";
+import { useFromState } from "./useFromState";
+
+const BTC = getCryptoCurrencyById("bitcoin");
+const ETH = getCryptoCurrencyById("ethereum");
+const USDT = getTokenById("ethereum/erc20/usd_tether__erc20_");
+
+const mockedAccounts: Account[] = [
+  genAccount("mocked-account-1"),
+  genAccount("mocked-account-2", {
+    currency: ETH,
+  }),
+];
+const mockedTokenAccount = genTokenAccount(1, mockedAccounts[1], USDT);
+const allAccounts = [...mockedAccounts, mockedTokenAccount] as Account[];
+
+describe("useFromState", () => {
+  test("call hook without arguments", () => {
+    const { result } = renderHook(() => {
+      const bridgeTransaction = useBridgeTransaction();
+      return useFromState({
+        bridgeTransaction,
+      });
+    });
+    expect(result.current).toMatchObject({
+      fromState: selectorStateDefaultValues,
+    });
+  });
+
+  test("call hook with default currency", () => {
+    const defaultCurrency = BTC;
+
+    const { result } = renderHook(() => {
+      const bridgeTransaction = useBridgeTransaction();
+      return useFromState({
+        defaultCurrency,
+        bridgeTransaction,
+      });
+    });
+    expect(result.current).toMatchObject({
+      fromState: {
+        ...selectorStateDefaultValues,
+        currency: defaultCurrency,
+      },
+    });
+  });
+
+  test("call hook with default accounts", () => {
+    const defaultAccount = mockedTokenAccount;
+    const defaultParentAccount = mockedAccounts[1];
+
+    const { result } = renderHook(() => {
+      const bridgeTransaction = useBridgeTransaction();
+      return useFromState({
+        defaultAccount,
+        defaultParentAccount,
+        bridgeTransaction,
+      });
+    });
+    expect(result.current).toMatchObject({
+      fromState: {
+        ...selectorStateDefaultValues,
+        account: defaultAccount,
+        parentAccount: defaultParentAccount,
+      },
+    });
+  });
+
+  test("call hook and set the account and all the related properties", () => {
+    const { result } = renderHook(() => {
+      const bridgeTransaction = useBridgeTransaction();
+      return {
+        ...useFromState({
+          accounts: allAccounts,
+          bridgeTransaction,
+        }),
+        bridgeTransaction,
+      };
+    });
+
+    expect(result.current).toMatchObject({
+      fromState: selectorStateDefaultValues,
+    });
+
+    act(() => {
+      result.current.setFromAccount(mockedTokenAccount);
+    });
+
+    expect(result.current).toMatchObject({
+      fromState: {
+        ...selectorStateDefaultValues,
+        account: mockedTokenAccount,
+        parentAccount: mockedAccounts[1],
+        currency: USDT,
+      },
+    });
+
+    expect(result.current.bridgeTransaction).toMatchObject({
+      account: mockedTokenAccount,
+      parentAccount: mockedAccounts[1],
+    });
+  });
+
+  test("call hook and set the amount", () => {
+    const { result } = renderHook(() => {
+      const bridgeTransaction = useBridgeTransaction();
+      return useFromState({
+        accounts: allAccounts,
+        bridgeTransaction,
+      });
+    });
+
+    expect(result.current).toMatchObject({
+      fromState: selectorStateDefaultValues,
+    });
+
+    act(() => {
+      result.current.setFromAmount(new BigNumber(10));
+    });
+
+    expect(result.current).toMatchObject({
+      fromState: {
+        ...selectorStateDefaultValues,
+        amount: new BigNumber(10),
+      },
+    });
+  });
+});

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

@@ -0,0 +1,84 @@
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+import { useCallback, useState } from "react";
+import {
+  selectorStateDefaultValues,
+  SwapSelectorStateType,
+  SwapTransactionType,
+} from ".";
+import { getAccountCurrency, getMainAccount } from "../../../account";
+import { Account, AccountLike } from "../../../types";
+import { Result as UseBridgeTransactionReturnType } from "../../../bridge/useBridgeTransaction";
+
+export const useFromState = ({
+  accounts,
+  defaultCurrency,
+  defaultAccount,
+  defaultParentAccount,
+  bridgeTransaction,
+}: {
+  accounts?: Account[];
+  defaultCurrency?: SwapSelectorStateType["currency"];
+  defaultAccount?: SwapSelectorStateType["account"];
+  defaultParentAccount?: SwapSelectorStateType["parentAccount"];
+  bridgeTransaction: UseBridgeTransactionReturnType;
+}): {
+  fromState: SwapSelectorStateType;
+  setFromAccount: SwapTransactionType["setFromAccount"];
+  setFromAmount: SwapTransactionType["setFromAmount"];
+} => {
+  const [fromState, setFromState] = useState<SwapSelectorStateType>({
+    ...selectorStateDefaultValues,
+    currency: defaultCurrency ?? selectorStateDefaultValues.currency,
+    account: defaultAccount ?? selectorStateDefaultValues.account,
+    parentAccount:
+      defaultParentAccount ?? selectorStateDefaultValues.parentAccount,
+  });
+
+  /* UPDATE from account */
+  const setFromAccount: SwapTransactionType["setFromAccount"] = useCallback(
+    (account) => {
+      const parentAccount =
+        account?.type !== "Account"
+          ? accounts?.find((a) => a.id === account?.parentId)
+          : null;
+      const currency = getAccountCurrency(account as AccountLike);
+
+      bridgeTransaction.setAccount(account as AccountLike, parentAccount);
+      setFromState({
+        ...selectorStateDefaultValues,
+        currency,
+        account,
+        parentAccount,
+      });
+
+      /* @DEV: That populates fake seed. This is required to use Transaction object */
+      const mainAccount = getMainAccount(account as AccountLike, parentAccount);
+      const mainCurrency = getAccountCurrency(mainAccount);
+      const recipient = getAbandonSeedAddress(mainCurrency.id);
+      bridgeTransaction.updateTransaction((transaction) => ({
+        ...transaction,
+        recipient,
+      }));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [accounts, bridgeTransaction.updateTransaction]
+  );
+
+  const setFromAmount: SwapTransactionType["setFromAmount"] = useCallback(
+    (amount) => {
+      bridgeTransaction.updateTransaction((transaction) => ({
+        ...transaction,
+        amount,
+      }));
+      setFromState((previousState) => ({ ...previousState, amount: amount }));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [bridgeTransaction.updateTransaction]
+  );
+
+  return {
+    fromState,
+    setFromAccount,
+    setFromAmount,
+  };
+};

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

@@ -0,0 +1,167 @@
+import { renderHook } from "@testing-library/react-hooks";
+import BigNumber from "bignumber.js";
+
+import { usePickDefaultAccount } from "./usePickDefaultAccount";
+import { genAccount } from "../../../mock/account";
+import type { Account, CryptoCurrency } from "../../../types";
+import { getCryptoCurrencyById } from "../../../currencies";
+
+function* accountGenerator(currency: CryptoCurrency): Generator<Account> {
+  let id = 0;
+  while (true) {
+    id += 1;
+    // operations are not taken into account by the usePickDefaultAccount hooks
+    yield genAccount(`mocked-account-${id}`, { currency, operationsSize: 0 });
+  }
+}
+
+const getAccountCreator = (currencyId: string) => {
+  const generator = accountGenerator(getCryptoCurrencyById(currencyId));
+  return () => generator.next().value;
+};
+
+describe("usePickDefaultAccount", () => {
+  const getEthAccount = getAccountCreator("ethereum");
+  const getBtcAccount = getAccountCreator("bitcoin");
+  const getPolkadotAccount = getAccountCreator("polkadot");
+  const getCosmosAccount = getAccountCreator("cosmos");
+  const setFromAccount = jest.fn();
+
+  beforeEach(() => {
+    setFromAccount.mockClear();
+  });
+
+  test("do nothing when fromAccount is not null/undefined", () => {
+    const accounts: Account[] = [getEthAccount(), getBtcAccount()];
+
+    renderHook(() =>
+      usePickDefaultAccount(accounts, getEthAccount(), setFromAccount)
+    );
+
+    expect(setFromAccount).toHaveBeenCalledTimes(0);
+  });
+
+  test("do nothing when all passed accounts are disabled", () => {
+    const accounts: Account[] = [
+      { ...getEthAccount(), disabled: true },
+      { ...getBtcAccount(), disabled: true },
+      { ...getEthAccount(), disabled: true },
+      { ...getEthAccount(), disabled: true },
+    ];
+
+    renderHook(() =>
+      usePickDefaultAccount(accounts, undefined, setFromAccount)
+    );
+
+    expect(setFromAccount).toHaveBeenCalledTimes(0);
+  });
+
+  test("returns an ethereum account when it's available", () => {
+    const ethAccount = getEthAccount();
+
+    const accounts: Account[] = [ethAccount, getBtcAccount()];
+
+    renderHook(() =>
+      usePickDefaultAccount(accounts, undefined, setFromAccount)
+    );
+
+    expect(setFromAccount).toHaveBeenCalledTimes(1);
+    expect(setFromAccount).toHaveBeenCalledWith(ethAccount);
+  });
+
+  test("returns the first ethereum account when all of the enabled accounts have the same balance", () => {
+    const ethAccount = getEthAccount();
+
+    const accounts: Account[] = [
+      ethAccount,
+      getBtcAccount(),
+      getEthAccount(),
+      { ...getEthAccount(), disabled: true },
+    ];
+
+    renderHook(() =>
+      usePickDefaultAccount(accounts, undefined, setFromAccount)
+    );
+
+    expect(setFromAccount).toHaveBeenCalledTimes(1);
+    expect(setFromAccount).toHaveBeenCalledWith(ethAccount);
+  });
+
+  test("returns the ethereum enabled account with the highest balance", () => {
+    const ethAccount = getEthAccount();
+    const ethAccount2 = getEthAccount();
+
+    ethAccount.amount = new BigNumber(1000);
+    ethAccount2.amount = new BigNumber(0);
+
+    const accounts: Account[] = [
+      { ...getEthAccount(), disabled: true },
+      ethAccount,
+      getBtcAccount(),
+      ethAccount2,
+    ];
+
+    renderHook(() =>
+      usePickDefaultAccount(accounts, undefined, setFromAccount)
+    );
+
+    expect(setFromAccount).toHaveBeenCalledTimes(1);
+    expect(setFromAccount).toHaveBeenCalledWith(ethAccount);
+  });
+
+  test("returns the first bitcoin account when no ethereum accounts are passed/enabled and all btc accounts have the same balance", () => {
+    const BtcAccount = getBtcAccount();
+
+    const accounts: Account[] = [
+      { ...getEthAccount(), disabled: true },
+      BtcAccount,
+      getBtcAccount(),
+    ];
+
+    renderHook(() =>
+      usePickDefaultAccount(accounts, undefined, setFromAccount)
+    );
+
+    expect(setFromAccount).toHaveBeenCalledTimes(1);
+    expect(setFromAccount).toHaveBeenCalledWith(BtcAccount);
+  });
+
+  test("returns the bitcoin enabled account with the highest balance when no ETH accounts are passed", () => {
+    const btcAccount = getBtcAccount();
+    const btcAccount2 = getBtcAccount();
+
+    btcAccount.amount = new BigNumber(1000);
+    btcAccount2.amount = new BigNumber(0);
+
+    const accounts: Account[] = [
+      { ...getEthAccount(), disabled: true },
+      btcAccount,
+      btcAccount2,
+    ];
+
+    renderHook(() =>
+      usePickDefaultAccount(accounts, undefined, setFromAccount)
+    );
+
+    expect(setFromAccount).toHaveBeenCalledTimes(1);
+    expect(setFromAccount).toHaveBeenCalledWith(btcAccount);
+  });
+
+  test("returns the first enabled account when no ethereum/bitcoin accounts are passed", () => {
+    const dotAccount = getPolkadotAccount();
+
+    const accounts: Account[] = [
+      { ...getCosmosAccount(), disabled: true },
+      dotAccount,
+      getPolkadotAccount(),
+      getCosmosAccount(),
+    ];
+
+    renderHook(() =>
+      usePickDefaultAccount(accounts, undefined, setFromAccount)
+    );
+
+    expect(setFromAccount).toHaveBeenCalledTimes(1);
+    expect(setFromAccount).toHaveBeenCalledWith(dotAccount);
+  });
+});

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

@@ -0,0 +1,47 @@
+import { useEffect } from "react";
+import { Account, TokenAccount } from "../../../types";
+
+// Pick a default source account if none are selected.
+export const usePickDefaultAccount = (
+  accounts: ((Account | TokenAccount) & { disabled?: boolean })[],
+  fromAccount: Account | TokenAccount | null | undefined,
+  setFromAccount: (account: Account | TokenAccount) => void
+): void => {
+  useEffect(() => {
+    if (!fromAccount) {
+      const possibleDefaults = accounts.reduce<
+        [
+          Account | TokenAccount | undefined | null,
+          Account | TokenAccount | undefined | null,
+          Account | TokenAccount | undefined | null
+        ]
+      >(
+        (acc, account) => {
+          if (account.disabled) return acc;
+          if (
+            // eventually needs a type guard because the "currency" property does not exist in TokenAccount
+            account["currency"]?.id === "ethereum" &&
+            (acc[0]?.balance ?? -1) < account.balance
+          ) {
+            acc[0] = account;
+          }
+          if (
+            // eventually needs a type guard because the "currency" property does not exist in TokenAccount
+            account["currency"]?.id === "bitcoin" &&
+            (acc[1]?.balance ?? -1) < account.balance
+          ) {
+            acc[1] = account;
+          }
+          const maxFundsAccount = acc[2];
+          if (!maxFundsAccount || maxFundsAccount.balance < account.balance) {
+            acc[2] = account;
+          }
+          return acc;
+        },
+        [null, null, null]
+      );
+      const defaultAccount = possibleDefaults.find(Boolean);
+      defaultAccount && setFromAccount(defaultAccount);
+    }
+  }, [accounts, fromAccount, setFromAccount]);
+};

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

@@ -0,0 +1,107 @@
+import { renderHook } from "@testing-library/react-hooks";
+
+import { usePickDefaultCurrency } from "./usePickDefaultCurrency";
+import { getCryptoCurrencyById } from "../../../currencies";
+import { CryptoCurrency, TokenCurrency } from "../../../types";
+
+describe("usePickDefaultCurrency", () => {
+  const setCurrency = jest.fn();
+
+  beforeEach(() => {
+    setCurrency.mockClear();
+  });
+
+  test("do nothing when the passed currency is valid", () => {
+    const currencies: (CryptoCurrency | TokenCurrency)[] = [
+      getCryptoCurrencyById("ethereum"),
+      getCryptoCurrencyById("bitcoin"),
+      getCryptoCurrencyById("bsc"),
+    ];
+
+    renderHook(() =>
+      usePickDefaultCurrency(
+        currencies,
+        getCryptoCurrencyById("ethereum"),
+        setCurrency
+      )
+    );
+
+    expect(setCurrency).toHaveBeenCalledTimes(0);
+  });
+
+  test("do nothing if the currency is undefined/null and the currencies list don't include eth/btc", () => {
+    const currencies: (CryptoCurrency | TokenCurrency)[] = [
+      getCryptoCurrencyById("solana"),
+      getCryptoCurrencyById("polkadot"),
+      getCryptoCurrencyById("bsc"),
+    ];
+
+    renderHook(() =>
+      usePickDefaultCurrency(currencies, undefined, setCurrency)
+    );
+
+    expect(setCurrency).toHaveBeenCalledTimes(0);
+  });
+
+  test("do nothing if the currency passed isn't valid in the list and the currencies list don't include eth/btc", () => {
+    const currencies: (CryptoCurrency | TokenCurrency)[] = [
+      getCryptoCurrencyById("solana"),
+      getCryptoCurrencyById("polkadot"),
+      getCryptoCurrencyById("bsc"),
+    ];
+
+    renderHook(() =>
+      usePickDefaultCurrency(
+        currencies,
+        getCryptoCurrencyById("stellar"),
+        setCurrency
+      )
+    );
+
+    expect(setCurrency).toHaveBeenCalledTimes(0);
+  });
+
+  test("returns the ethereum currency if the passed currency isn't valid and ethereum comes before bitcoin in the list", () => {
+    const ethereumCurrency = getCryptoCurrencyById("ethereum");
+
+    const currencies: (CryptoCurrency | TokenCurrency)[] = [
+      getCryptoCurrencyById("bsc"),
+      ethereumCurrency,
+      getCryptoCurrencyById("bitcoin"),
+      getCryptoCurrencyById("polkadot"),
+    ];
+
+    renderHook(() =>
+      usePickDefaultCurrency(
+        currencies,
+        getCryptoCurrencyById("stellar"),
+        setCurrency
+      )
+    );
+
+    expect(setCurrency).toHaveBeenCalledTimes(1);
+    expect(setCurrency).toHaveBeenCalledWith(ethereumCurrency);
+  });
+
+  test("returns the bitcoin currency if the passed currency isn't valid and bitcoin comes before ethereum in the list", () => {
+    const bitcoinCurrency = getCryptoCurrencyById("bitcoin");
+
+    const currencies: (CryptoCurrency | TokenCurrency)[] = [
+      getCryptoCurrencyById("bsc"),
+      bitcoinCurrency,
+      getCryptoCurrencyById("ethereum"),
+      getCryptoCurrencyById("polkadot"),
+    ];
+
+    renderHook(() =>
+      usePickDefaultCurrency(
+        currencies,
+        getCryptoCurrencyById("stellar"),
+        setCurrency
+      )
+    );
+
+    expect(setCurrency).toHaveBeenCalledTimes(1);
+    expect(setCurrency).toHaveBeenCalledWith(bitcoinCurrency);
+  });
+});

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

@@ -0,0 +1,20 @@
+import { useEffect } from "react";
+import { CryptoCurrency, TokenCurrency } from "../../../types";
+
+// Pick a default currency target if none are selected.
+export const usePickDefaultCurrency = (
+  currencies: (CryptoCurrency | TokenCurrency)[],
+  currency: (CryptoCurrency | TokenCurrency) | null | undefined,
+  setCurrency: (currency: CryptoCurrency | TokenCurrency) => void
+): void => {
+  useEffect(() => {
+    // Keep the same currency target if it is still valid.
+    const isCurrencyValid = currency && currencies.indexOf(currency) >= 0;
+    if (!currency || !isCurrencyValid) {
+      const defaultCurrency = currencies.find(
+        (currency) => currency.id === "ethereum" || currency.id === "bitcoin"
+      );
+      defaultCurrency && setCurrency(defaultCurrency);
+    }
+  }, [currency, currencies, setCurrency]);
+};

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

@@ -0,0 +1,89 @@
+import { renderHook } from "@testing-library/react-hooks";
+import { mocked } from "ts-jest/utils";
+
+import {
+  usePollKYCStatus,
+  KYC_STATUS_POLLING_INTERVAL,
+} from "./usePollKYCStatus";
+import type { UsePollKYCStatusProps } from "./usePollKYCStatus";
+import { KYC_STATUS } from "../utils";
+import { getKYCStatus } from "..";
+import { KYCStatus } from "../types";
+
+// mock getKYCStatus
+jest.mock("..");
+const mockedGetKYCStatus = mocked(getKYCStatus, true);
+
+describe("usePollKYCStatus", () => {
+  const defaultInput: UsePollKYCStatusProps = {
+    provider: "changelly",
+    kyc: { id: "1", status: KYC_STATUS.pending },
+    onChange: () => {},
+  };
+
+  beforeEach(() => {
+    mockedGetKYCStatus.mockReset();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+  });
+
+  test("KYC status isn't fetched when the local status isn't PENDING", () => {
+    Object.values(KYC_STATUS)
+      .filter((status) => status !== "pending")
+      .forEach((status) => {
+        const input = { ...defaultInput, kyc: { id: "1", status } };
+        renderHook(() => usePollKYCStatus(input));
+        expect(mockedGetKYCStatus).toHaveBeenCalledTimes(0);
+      });
+  });
+
+  test("onChange isn't triggered when the local/remote status are equals", () => {
+    const onChange = jest.fn();
+    const input = { ...defaultInput, onChange };
+
+    const fetchedValue: KYCStatus = { status: "pending", id: "1" };
+    mockedGetKYCStatus.mockResolvedValueOnce(fetchedValue);
+
+    renderHook(() => usePollKYCStatus(input));
+    expect(mockedGetKYCStatus).toHaveBeenCalledTimes(1);
+    expect(mockedGetKYCStatus).toHaveBeenCalledWith(
+      input.provider,
+      input.kyc.id
+    );
+    expect(onChange).toHaveBeenCalledTimes(0);
+  });
+
+  test("onChange is triggered when the local/remote status are different", () => {
+    const onChange = jest.fn();
+    const input = { ...defaultInput, onChange };
+
+    const fetchedValue: KYCStatus = { status: "approved", id: "1" };
+    mockedGetKYCStatus.mockResolvedValueOnce(fetchedValue);
+
+    const { waitFor } = renderHook(() => usePollKYCStatus(input));
+    expect(mockedGetKYCStatus).toHaveBeenCalledTimes(1);
+    waitFor(() => expect(onChange).toHaveBeenCalledTimes(1));
+  });
+
+  test("setInterval retriggers the updateKYCStatus function", () => {
+    const onChange = jest.fn();
+    const input = { ...defaultInput, onChange };
+
+    const fetchedValue: KYCStatus = { status: "approved", id: "1" };
+    mockedGetKYCStatus.mockResolvedValue(fetchedValue);
+
+    const { waitFor } = renderHook(() => usePollKYCStatus(input));
+    waitFor(() => expect(onChange).toHaveBeenCalledTimes(1));
+    waitFor(() => expect(mockedGetKYCStatus).toHaveBeenCalledTimes(1));
+
+    // manually trigger the setInterval
+    jest.advanceTimersByTime(KYC_STATUS_POLLING_INTERVAL);
+
+    waitFor(() => expect(onChange).toHaveBeenCalledTimes(2));
+    waitFor(() => expect(mockedGetKYCStatus).toHaveBeenCalledTimes(2));
+  });
+});

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

@@ -0,0 +1,43 @@
+import { useEffect } from "react";
+import { KYC_STATUS } from "../utils";
+import { getKYCStatus } from "..";
+
+// Poll the server to update the KYC status of a given provider.
+export const KYC_STATUS_POLLING_INTERVAL = 10000;
+export type KYCItem = {
+  id: string;
+  status: string;
+};
+export type UsePollKYCStatusProps = {
+  provider: string;
+  kyc: KYCItem;
+  onChange: (item: KYCItem) => void;
+};
+export const usePollKYCStatus = (
+  { provider, kyc, onChange }: UsePollKYCStatusProps,
+  dependencies = []
+): void => {
+  useEffect(
+    () => {
+      if (kyc?.status !== KYC_STATUS.pending) return;
+      let cancelled = false;
+      async function updateKYCStatus() {
+        if (!kyc?.id) return;
+        const res = await getKYCStatus(provider, kyc.id);
+        if (cancelled || res?.status === kyc?.status) return;
+        onChange(res);
+      }
+      const intervalId = setInterval(
+        updateKYCStatus,
+        KYC_STATUS_POLLING_INTERVAL
+      );
+      updateKYCStatus();
+      return () => {
+        cancelled = true;
+        clearInterval(intervalId);
+      };
+    },
+    // eslint-disable-next-line
+    [provider, kyc, ...dependencies]
+  );
+};