@ledgerhq/live-common 21.5.1 → 21.7.1-patch.1

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]
+  );
+};

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

@@ -0,0 +1,200 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import BigNumber from "bignumber.js";
+import { mocked } from "ts-jest/utils";
+import { useProviderRates } from ".";
+import { getExchangeRates } from "..";
+import { genAccount } from "../../../mock/account";
+import { mockGetExchangeRates } from "../mock";
+
+jest.mock("..");
+
+const BTC = getCryptoCurrencyById("bitcoin");
+const ETH = getCryptoCurrencyById("ethereum");
+const fromAccount = genAccount("from-account", {
+  currency: ETH,
+});
+
+const mockedGetExchangeRates = mocked(getExchangeRates, true);
+const mockedRatesPromise = mockGetExchangeRates(
+  { fromAccount } as any,
+  { amount: new BigNumber(1) } as any,
+  BTC
+);
+
+describe("useProviderRates", () => {
+  let mockedRates;
+  const baseInitalProps = {
+    fromState: { account: fromAccount } as any,
+    toState: { currency: ETH } as any,
+    transaction: { amount: new BigNumber(1) } as any,
+  };
+
+  beforeAll(async () => {
+    mockedRates = await mockedRatesPromise;
+  });
+
+  beforeEach(() => {
+    mockedGetExchangeRates.mockReset();
+  });
+
+  it("should fetch and store the rates", async () => {
+    mockedGetExchangeRates.mockResolvedValue(mockedRatesPromise);
+    const setExchangeRate = jest.fn();
+
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: {
+        ...baseInitalProps,
+        setExchangeRate,
+      },
+    });
+
+    expect(result.current.rates.status).toBe("loading");
+
+    await waitForNextUpdate({ timeout: 1000 });
+
+    // Check mock
+    expect(mockedGetExchangeRates).toHaveBeenCalledTimes(1);
+    // Check callback
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate.mock.calls[0][0]).toBe(mockedRates[0]);
+    // Check result
+    const { rates } = result.current;
+    expect(rates.error).toBeUndefined();
+    expect(rates.status).toBeNull();
+    expect(rates.value).toMatchObject(mockedRates);
+  });
+
+  it("should not fetch the rates if the conditions are not met", async () => {
+    const testProps = [
+      // No account
+      {
+        ...baseInitalProps,
+        fromState: { account: null } as any,
+      },
+      // No currency
+      {
+        ...baseInitalProps,
+        toState: { currency: null } as any,
+      },
+      // No transaction
+      {
+        ...baseInitalProps,
+        transaction: null,
+      },
+      // Amount <= 0
+      {
+        ...baseInitalProps,
+        transaction: { amount: new BigNumber(0) } as any,
+      },
+      // Nothing
+      {} as any,
+    ];
+
+    testProps.forEach((initialProps) => {
+      renderHook(useProviderRates, {
+        initialProps,
+      });
+      expect(mockedGetExchangeRates).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  it("should refetch the rates if a dependency has been updated", async () => {
+    mockedGetExchangeRates.mockResolvedValue(mockedRatesPromise);
+
+    const { waitForNextUpdate, rerender } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(mockedGetExchangeRates).toHaveBeenCalledTimes(1);
+    mockedGetExchangeRates.mockClear();
+
+    rerender();
+    expect(mockedGetExchangeRates).toHaveBeenCalledTimes(0);
+
+    rerender({
+      ...baseInitalProps,
+      fromState: { account: { ...fromAccount } } as any,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(mockedGetExchangeRates).toHaveBeenCalledTimes(1);
+    mockedGetExchangeRates.mockClear();
+
+    rerender({ ...baseInitalProps, toState: { currency: { ...ETH } } as any });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(mockedGetExchangeRates).toHaveBeenCalledTimes(1);
+    mockedGetExchangeRates.mockClear();
+
+    rerender({
+      ...baseInitalProps,
+      transaction: { amount: new BigNumber(2) } as any,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(mockedGetExchangeRates).toHaveBeenCalledTimes(1);
+  });
+
+  it("should refetch the rates if refetchRates is called", async () => {
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(mockedGetExchangeRates).toHaveBeenCalledTimes(1);
+    mockedGetExchangeRates.mockClear();
+
+    act(() => {
+      result.current.refetchRates();
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(mockedGetExchangeRates).toHaveBeenCalledTimes(1);
+  });
+
+  it("should filter out errored rates", async () => {
+    const mockedRatesWithSingleError = mockedRates.map((rate, index) =>
+      index === 0
+        ? {
+            ...rate,
+            error: new Error("kaboom"),
+          }
+        : rate
+    );
+    mockedGetExchangeRates.mockResolvedValue(mockedRatesWithSingleError);
+
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.value).toMatchObject([mockedRates[1]]);
+    expect(result.current.rates.status).toBeNull();
+  });
+
+  it("should dispatch an error if all the rates contain an error", async () => {
+    const error = new Error("kaboom");
+    const mockedRatesWithError = mockedRates.map((rate) => ({
+      ...rate,
+      error,
+    }));
+    mockedGetExchangeRates.mockResolvedValue(mockedRatesWithError);
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: baseInitalProps,
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.status).toBe("error");
+    expect(result.current.rates.error).toBe(error);
+    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([]);
+
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: { ...baseInitalProps, onNoRates },
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+    expect(result.current.rates.value).toMatchObject([]);
+    expect(result.current.rates.status).toBeNull();
+    expect(onNoRates).toHaveBeenCalledTimes(1);
+  });
+});