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

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

@@ -0,0 +1,57 @@
+import { useEffect, useReducer } from "react";
+import { getProviders } from "..";
+import { AvailableProviderV3 } from "../types";
+
+type State = {
+  isLoading: boolean;
+  error: Error | null | undefined;
+  providers: AvailableProviderV3[] | null | undefined;
+};
+
+type ActionType =
+  | { type: "SAVE_DATA"; payload: State["providers"] }
+  | { type: "SAVE_ERROR"; payload: State["error"] };
+
+const reducer = (_state: State, action: ActionType): State => {
+  switch (action.type) {
+    case "SAVE_DATA":
+      return { error: null, providers: action.payload, isLoading: false };
+    case "SAVE_ERROR":
+      return { error: action.payload, providers: null, isLoading: false };
+    default:
+      throw new Error("Uncorrect action type");
+  }
+};
+
+export const initialState = { isLoading: true, error: null, providers: null };
+
+const filterDisabledProviders = (provider: AvailableProviderV3) =>
+  !process.env.SWAP_DISABLED_PROVIDERS?.includes(provider.provider);
+
+export const useSwapProviders = (): State => {
+  const [state, dispatch] = useReducer(reducer, initialState);
+
+  useEffect(() => {
+    let isMounted = true;
+
+    const saveProviders = async () => {
+      try {
+        const allProviders = (await getProviders()) as AvailableProviderV3[];
+        const providers = allProviders.filter(filterDisabledProviders);
+
+        if (isMounted) dispatch({ type: "SAVE_DATA", payload: providers });
+      } catch (error) {
+        if (isMounted && error instanceof Error)
+          dispatch({ type: "SAVE_ERROR", payload: error });
+      }
+    };
+
+    saveProviders();
+
+    return () => {
+      isMounted = false;
+    };
+  }, []);
+
+  return state;
+};

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

@@ -0,0 +1,54 @@
+import { renderHook } from "@testing-library/react-hooks";
+
+import { AmountRequired } from "@ledgerhq/errors";
+import { useFromAmountError } from "./useSwapTransaction";
+
+/**
+ * @DEV: The useSwapTransaction hook is a composition hook. It doesn't own specific
+ * logic, but it's composed of other hooks. That's why only the useFromAmountError
+ * logic is tested here, it's the only logic owned by the useSwapTransaction hook.
+ * All other lines are covered by other hooks tests.
+ */
+describe("useSwapTransaction", () => {
+  test("useFromAmountError - returns nothing when no errors are caught", () => {
+    const { result } = renderHook(() =>
+      useFromAmountError({ gasPrice: undefined, amount: undefined })
+    );
+
+    expect(result.current).toBeUndefined();
+  });
+
+  test("useFromAmountError - returns the first error caught", () => {
+    const gasPriceError = new Error("Gas price is too high");
+    const amountError = new Error("Amount is too low");
+    const tests = [
+      {
+        input: { gasPrice: gasPriceError, amount: undefined },
+        output: gasPriceError,
+      },
+      {
+        input: { gasPrice: undefined, amount: amountError },
+        output: amountError,
+      },
+      {
+        input: { gasPrice: gasPriceError, amount: amountError },
+        output: gasPriceError,
+      },
+    ];
+
+    tests.forEach(({ input, output }) => {
+      const { result } = renderHook(() => useFromAmountError(input));
+      expect(result.current).toEqual(output);
+    });
+  });
+
+  test("useFromAmountError - do not return AmountRequired error", () => {
+    const amountError = new AmountRequired("This error will be filtered");
+
+    const { result } = renderHook(() =>
+      useFromAmountError({ gasPrice: undefined, amount: amountError })
+    );
+
+    expect(result.current).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,170 @@
+import { useMemo } from "react";
+import { BigNumber } from "bignumber.js";
+import useBridgeTransaction, {
+  Result as UseBridgeTransactionReturnType,
+} from "../../../bridge/useBridgeTransaction";
+import type {
+  Account,
+  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";
+
+export type SwapSelectorStateType = {
+  currency: null | undefined | TokenCurrency | CryptoCurrency;
+  account: null | undefined | Account | TokenAccount;
+  parentAccount: null | undefined | Account;
+  amount: null | undefined | BigNumber;
+};
+export type SwapDataType = {
+  from: SwapSelectorStateType;
+  to: SwapSelectorStateType;
+  isMaxEnabled: boolean;
+  isSwapReversable: boolean;
+  rates: RatesReducerState;
+  refetchRates: () => void;
+  targetAccounts?: Account[];
+};
+export const selectorStateDefaultValues = {
+  currency: null,
+  account: null,
+  parentAccount: null,
+  amount: null,
+};
+
+export type SwapTransactionType = UseBridgeTransactionReturnType & {
+  swap: SwapDataType;
+  setFromAccount: (account: SwapSelectorStateType["account"]) => void;
+  setToAccount: (
+    currency: SwapSelectorStateType["currency"],
+    account: SwapSelectorStateType["account"],
+    parentAccount: SwapSelectorStateType["parentAccount"]
+  ) => void;
+  setFromAmount: (amount: BigNumber) => void;
+  setToAmount: (amount: BigNumber) => void;
+  setToCurrency: (currency: SwapSelectorStateType["currency"]) => void;
+  toggleMax: () => void;
+  reverseSwap: () => void;
+  fromAmountError?: Error;
+};
+
+export type OnNoRatesCallback = (arg: {
+  fromState: SwapSelectorStateType;
+  toState: SwapSelectorStateType;
+}) => void;
+export type SetExchangeRateCallback = (
+  exchangeRate?: ExchangeRate | null
+) => void;
+
+export const useFromAmountError = (
+  errors: Record<string, Error | undefined>
+): Error | undefined => {
+  const fromAmountError = useMemo(() => {
+    const [error] = [errors?.gasPrice, errors?.amount]
+      .filter(Boolean)
+      .filter((error) => !(error instanceof AmountRequired));
+
+    return error;
+  }, [errors?.gasPrice, errors?.amount]);
+
+  return fromAmountError;
+};
+
+export const useSwapTransaction = ({
+  accounts,
+  exchangeRate,
+  setExchangeRate,
+  defaultCurrency = selectorStateDefaultValues.currency,
+  defaultAccount = selectorStateDefaultValues.account,
+  defaultParentAccount = selectorStateDefaultValues.parentAccount,
+  onNoRates,
+}: {
+  accounts?: Account[];
+  exchangeRate?: ExchangeRate;
+  setExchangeRate?: SetExchangeRateCallback;
+  defaultCurrency?: SwapSelectorStateType["currency"];
+  defaultAccount?: SwapSelectorStateType["account"];
+  defaultParentAccount?: SwapSelectorStateType["parentAccount"];
+  onNoRates?: OnNoRatesCallback;
+} = {}): SwapTransactionType => {
+  const bridgeTransaction = useBridgeTransaction(() => ({
+    account: defaultAccount,
+    parentAccount: defaultParentAccount,
+  }));
+  const { fromState, setFromAccount, setFromAmount } = useFromState({
+    accounts,
+    defaultCurrency,
+    defaultAccount,
+    defaultParentAccount,
+    bridgeTransaction,
+  });
+  const { toState, setToAccount, setToAmount, setToCurrency, targetAccounts } =
+    useToState({ accounts });
+  const {
+    account: fromAccount,
+    parentAccount: fromParentAccount,
+    currency: fromCurrency,
+  } = fromState;
+  const { account: toAccount } = toState;
+  const transaction = bridgeTransaction?.transaction;
+
+  const fromAmountError = useFromAmountError(bridgeTransaction.status.errors);
+
+  const { isSwapReversable, reverseSwap } = useReverseAccounts({
+    accounts,
+    fromAccount,
+    toAccount,
+    fromParentAccount,
+    fromCurrency,
+    setFromAccount,
+    setToAccount,
+  });
+
+  const { isMaxEnabled, toggleMax } = useUpdateMaxAmount({
+    setFromAmount,
+    account: fromAccount,
+    parentAccount: fromParentAccount,
+    transaction,
+    feesStrategy: transaction?.feesStrategy,
+  });
+
+  const { rates, refetchRates } = useProviderRates({
+    fromState,
+    toState,
+    exchangeRate,
+    transaction,
+    onNoRates,
+    setExchangeRate,
+  });
+
+  return {
+    ...bridgeTransaction,
+    swap: {
+      to: toState,
+      from: fromState,
+      isMaxEnabled,
+      isSwapReversable,
+      rates,
+      refetchRates,
+      targetAccounts,
+    },
+    setFromAmount,
+    toggleMax,
+    fromAmountError,
+    setToAccount,
+    setToCurrency,
+    setFromAccount,
+    setToAmount,
+    reverseSwap,
+  };
+};

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

@@ -0,0 +1,53 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import { selectorStateDefaultValues, useToState } from ".";
+import { genAccount, genTokenAccount } from "../../../mock/account";
+import { Account } from "../../../types";
+import BigNumber from "bignumber.js";
+
+const BTC = getCryptoCurrencyById("bitcoin");
+const ETH = getCryptoCurrencyById("ethereum");
+const USDT = getTokenById("ethereum/erc20/usd_tether__erc20_");
+
+const accounts: Account[] = [
+  genAccount("mocked-account-1", { currency: BTC }),
+  genAccount("mocked-account-2", { currency: ETH }),
+];
+const subAccount = genTokenAccount(1, accounts[1], USDT);
+
+describe("useToState", () => {
+  const defaultProps = { accounts };
+
+  it("should initialize a blank state", () => {
+    const { result } = renderHook(useToState, { initialProps: defaultProps });
+    expect(result.current.toState).toMatchObject(selectorStateDefaultValues);
+  });
+
+  it("should set the account", async () => {
+    const [currency, account, parentAccount] = [USDT, subAccount, accounts[1]];
+    const { result } = renderHook(useToState, { initialProps: defaultProps });
+    act(() => result.current.setToAccount(currency, account, parentAccount));
+    expect(result.current.toState).toMatchObject({
+      account,
+      parentAccount,
+      currency,
+    });
+  });
+
+  it("should set the amount", () => {
+    const amount = new BigNumber(10);
+    const { result } = renderHook(useToState, { initialProps: defaultProps });
+    act(() => result.current.setToAmount(amount));
+    expect(result.current.toState.amount).toBe(amount);
+  });
+
+  it("should set the currency", () => {
+    const { result } = renderHook(useToState, { initialProps: defaultProps });
+    act(() => result.current.setToCurrency(BTC));
+    expect(result.current.toState).toMatchObject({
+      account: accounts[0],
+      parentAccount: null,
+      currency: BTC,
+    });
+  });
+});

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

@@ -0,0 +1,86 @@
+import { useCallback, useMemo, useState } from "react";
+import {
+  selectorStateDefaultValues,
+  SwapDataType,
+  SwapSelectorStateType,
+  SwapTransactionType,
+} from ".";
+import { Account } from "../../../types";
+import { getAccountTuplesForCurrency } from "../utils";
+
+export const useToState = ({
+  accounts,
+}: {
+  accounts: Account[] | undefined;
+}): {
+  toState: SwapSelectorStateType;
+  setToAccount: SwapTransactionType["setToAccount"];
+  setToAmount: SwapTransactionType["setToAmount"];
+  setToCurrency: SwapTransactionType["setToCurrency"];
+  targetAccounts: SwapDataType["targetAccounts"];
+} => {
+  const [toState, setToState] = useState<SwapSelectorStateType>(
+    selectorStateDefaultValues
+  );
+
+  /* UPDATE to accounts */
+  const setToAccount: SwapTransactionType["setToAccount"] = useCallback(
+    (currency, account, parentAccount) =>
+      setToState({
+        ...selectorStateDefaultValues,
+        currency,
+        account,
+        parentAccount,
+      }),
+    []
+  );
+
+  /* Get the list of possible target accounts given the target currency. */
+  const getTargetAccountsPairs = useCallback(
+    (currency) =>
+      currency &&
+      accounts &&
+      getAccountTuplesForCurrency(currency, accounts, false),
+    [accounts]
+  );
+  const targetAccounts = useMemo(
+    () =>
+      getTargetAccountsPairs(toState.currency)?.map(
+        ({ account, subAccount }) => subAccount || account
+      ),
+    [toState.currency, getTargetAccountsPairs]
+  );
+
+  const setToCurrency: SwapTransactionType["setToCurrency"] = useCallback(
+    (currency) => {
+      const targetAccountsPairs = getTargetAccountsPairs(currency);
+      const accountPair = targetAccountsPairs && targetAccountsPairs[0];
+      const account =
+        accountPair && (accountPair.subAccount || accountPair.account);
+      const parentAccount =
+        accountPair && accountPair.subAccount && accountPair.account;
+
+      setToState({
+        ...selectorStateDefaultValues,
+        currency,
+        account,
+        parentAccount,
+      });
+    },
+    [getTargetAccountsPairs]
+  );
+
+  const setToAmount: SwapTransactionType["setToAmount"] = useCallback(
+    (amount) =>
+      setToState((previousState) => ({ ...previousState, amount: amount })),
+    []
+  );
+
+  return {
+    toState,
+    setToAccount,
+    setToAmount,
+    setToCurrency,
+    targetAccounts,
+  };
+};

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

@@ -0,0 +1,132 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
+import { mocked } from "ts-jest/utils";
+import { useUpdateMaxAmount, ZERO } from "./useUpdateMaxAmount";
+import { genAccount, genTokenAccount } from "../../../mock/account";
+import BigNumber from "bignumber.js";
+import ethBridge from "../../../families/ethereum/bridge/mock";
+import { checkAccountSupported } from "../../../account/support";
+
+// Needs to be mocked since userSupportedCurrencies is initially empty.
+jest.mock("../../../account/support");
+const mockedCheckAccount = mocked(checkAccountSupported);
+// Mock to use a custom estimate value and test the result.
+jest.mock("../../../families/ethereum/bridge/mock");
+const mockedEstimateMaxSpendable = mocked(
+  ethBridge.accountBridge.estimateMaxSpendable,
+  true
+);
+
+const ETH = getCryptoCurrencyById("ethereum");
+const USDT = getTokenById("ethereum/erc20/usd_tether__erc20_");
+
+const parentAccount = genAccount("parent-account", {
+  currency: ETH,
+});
+const account = genTokenAccount(1, parentAccount, USDT);
+
+describe("updateAmountUsingMax", () => {
+  const setFromAmount = jest.fn();
+
+  const defaultProps = {
+    setFromAmount,
+    account,
+    parentAccount,
+    transaction: { amount: new BigNumber(1) } as any,
+    feesStrategy: "slow" as any,
+  };
+
+  beforeAll(() => {
+    mockedCheckAccount.mockImplementation(() => null);
+  });
+
+  afterAll(() => {
+    mockedCheckAccount.mockReset();
+  });
+
+  beforeEach(() => {
+    setFromAmount.mockClear();
+  });
+
+  const wait = () => new Promise((resolve) => setTimeout(resolve, 500));
+
+  it("should toggle the amount", async () => {
+    const amount = new BigNumber(0.5);
+    mockedEstimateMaxSpendable.mockResolvedValue(amount);
+    const { result } = renderHook(useUpdateMaxAmount, {
+      initialProps: defaultProps,
+    });
+
+    expect(result.current.isMaxEnabled).toBe(false);
+    expect(setFromAmount).toBeCalledTimes(0);
+    act(() => result.current.toggleMax());
+    expect(result.current.isMaxEnabled).toBe(true);
+
+    // Lest resort solution, since waitFor and other helpers will not work here.
+    await wait();
+
+    expect(setFromAmount).toBeCalledTimes(1);
+    expect(setFromAmount.mock.calls[0][0]).toBe(amount);
+    setFromAmount.mockClear();
+
+    act(() => result.current.toggleMax());
+    expect(result.current.isMaxEnabled).toBe(false);
+
+    await wait();
+
+    expect(setFromAmount).toBeCalledTimes(1);
+    expect(setFromAmount.mock.calls[0][0]).toBe(ZERO);
+  });
+
+  it("should update the max amount whenever the dependencies change", async () => {
+    const { result, rerender } = renderHook(useUpdateMaxAmount, {
+      initialProps: defaultProps,
+    });
+
+    const feesGenerator = (function* feesGenerator() {
+      const feesArray = ["medium", "fast", "custom", "slow"];
+      let index = 0;
+      while (true) {
+        yield feesArray[index];
+        index = (index + 1) % feesArray.length;
+      }
+    })();
+
+    // setFromAmount, account, parentAccount, feesStrategy
+    const propsVariants = [
+      {
+        ...defaultProps,
+        account: { ...account },
+      },
+      {
+        ...defaultProps,
+        parentAccount: { ...parentAccount },
+      },
+      {
+        ...defaultProps,
+        feesStrategy: feesGenerator.next().value,
+      },
+    ];
+
+    // Updating dependencies when the toggle is off should not do anything.
+    propsVariants.forEach(rerender);
+    expect(setFromAmount).toBeCalledTimes(0);
+
+    mockedEstimateMaxSpendable.mockResolvedValue(new BigNumber(0));
+    act(() => result.current.toggleMax());
+    await wait();
+
+    // Checking that updating dependencies update the max amount when the toggle is on.
+    let idx = 1;
+    for await (const props of propsVariants) {
+      const amount = new BigNumber(idx);
+      setFromAmount.mockReset();
+      mockedEstimateMaxSpendable.mockResolvedValue(amount);
+      rerender(props);
+      await wait();
+      expect(setFromAmount).toBeCalledTimes(1);
+      expect(setFromAmount.mock.calls[0][0]).toBe(amount);
+      idx += 1;
+    }
+  });
+});

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

@@ -0,0 +1,67 @@
+import { useCallback, useEffect, useState } from "react";
+import { getAccountBridge } from "../../../bridge";
+
+import {
+  SwapTransactionType,
+  SwapDataType,
+  SwapSelectorStateType,
+} from "./useSwapTransaction";
+import { Transaction } from "../../../generated/types";
+import BigNumber from "bignumber.js";
+
+export const ZERO = new BigNumber(0);
+
+export const useUpdateMaxAmount = ({
+  setFromAmount,
+  account,
+  parentAccount,
+  transaction,
+  feesStrategy,
+}: {
+  setFromAmount: SwapTransactionType["setFromAmount"];
+  account: SwapSelectorStateType["account"];
+  parentAccount: SwapSelectorStateType["parentAccount"];
+  transaction: SwapTransactionType["transaction"];
+  feesStrategy: Transaction["feesStrategy"];
+}): {
+  isMaxEnabled: SwapDataType["isMaxEnabled"];
+  toggleMax: SwapTransactionType["toggleMax"];
+} => {
+  const [isMaxEnabled, setMax] = useState<SwapDataType["isMaxEnabled"]>(false);
+
+  const toggleMax: SwapTransactionType["toggleMax"] = useCallback(
+    () =>
+      setMax((previous) => {
+        if (previous) {
+          setFromAmount(ZERO);
+        }
+        return !previous;
+      }),
+    [setFromAmount]
+  );
+
+  /* UPDATE from amount to the estimate max spendable on account
+     change when the amount feature is enabled */
+  useEffect(
+    () => {
+      const updateAmountUsingMax = async () => {
+        if (!account) return;
+        const bridge = getAccountBridge(account, parentAccount);
+        const amount = await bridge.estimateMaxSpendable({
+          account,
+          parentAccount,
+          transaction,
+        });
+        setFromAmount(amount);
+      };
+
+      if (isMaxEnabled) {
+        updateAmountUsingMax();
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [setFromAmount, isMaxEnabled, account, parentAccount, feesStrategy]
+  );
+
+  return { isMaxEnabled, toggleMax };
+};

package/src/exchange/swap/mock.ts

@@ -7,7 +7,7 @@ import type {
   SwapRequestEvent,
 } from "./types";
 import { getAccountUnit } from "../../account";
-import type { Transaction } from "../../types";
+import type { Transaction, TokenCurrency, CryptoCurrency } from "../../types";
 import { formatCurrencyUnit } from "../../currencies";
 import {
   SwapExchangeRateAmountTooLow,
@@ -16,14 +16,33 @@ import {
 import { Observable, of } from "rxjs";
 import { getSwapAPIBaseURL } from "./";
 
+export const getMockExchangeRate = ({
+  provider = "changelly",
+  tradeMethod = "fixed",
+}: {
+  provider?: string;
+  tradeMethod?: "fixed" | "float";
+} = {}): ExchangeRate => ({
+  rate: new BigNumber("1"),
+  toAmount: new BigNumber("12"),
+  magnitudeAwareRate: new BigNumber(1)
+    .div(new BigNumber(10).pow(18))
+    .times(new BigNumber(10).pow(8)),
+  rateId: "mockedRateId",
+  provider,
+  tradeMethod,
+});
+
 export const mockGetExchangeRates = async (
   exchange: Exchange,
-  transaction: Transaction
+  transaction: Transaction,
+  currencyTo?: TokenCurrency | CryptoCurrency | undefined | null
 ): Promise<(ExchangeRate & { expirationDate?: Date })[]> => {
   const { fromAccount, toAccount } = exchange;
   const amount = transaction.amount;
   const unitFrom = getAccountUnit(fromAccount);
-  const unitTo = getAccountUnit(toAccount);
+  const unitTo =
+    (currencyTo && currencyTo.units[0]) ?? getAccountUnit(toAccount);
   const tenPowMagnitude = new BigNumber(10).pow(unitFrom.magnitude);
   const amountFrom = amount.div(tenPowMagnitude);
   const minAmountFrom = new BigNumber(0.0001);

package/src/exchange/swap/types.ts

@@ -85,7 +85,8 @@ export type AvailableProvider = AvailableProviderV2 | AvailableProviderV3;
 export type GetExchangeRates = (
   arg0: Exchange,
   arg1: Transaction,
-  wyreUserId?: string
+  wyreUserId?: string,
+  currencyTo?: TokenCurrency | CryptoCurrency | undefined | null
 ) => Promise<ExchangeRate[]>;
 export type GetProviders = () => Promise<AvailableProvider[]>;
 export type InitSwapResult = {