@ledgerhq/live-common 27.2.0 → 27.3.0-next.0

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

@@ -0,0 +1,450 @@
+import axios from "axios";
+import getProviders from "./getProviders";
+import { getEnv, setEnv } from "../../env";
+
+const EXPECTED_RESULT_V4 = [
+  {
+    provider: "changelly",
+    pairs: [
+      {
+        from: "bitcoin",
+        to: "ethereum",
+        tradeMethod: "float",
+      },
+      {
+        from: "bitcoin",
+        to: "zcash",
+        tradeMethod: "float",
+      },
+      {
+        from: "bitcoin",
+        to: "ethereum_classic",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "bitcoin",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "zcash",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "ethereum_classic",
+        tradeMethod: "float",
+      },
+      {
+        from: "bitcoin",
+        to: "ethereum",
+        tradeMethod: "float",
+      },
+      {
+        from: "bitcoin",
+        to: "zcash",
+        tradeMethod: "float",
+      },
+      {
+        from: "bitcoin",
+        to: "ethereum_classic",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "bitcoin",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "zcash",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "ethereum_classic",
+        tradeMethod: "float",
+      },
+      {
+        from: "zcash",
+        to: "bitcoin",
+        tradeMethod: "float",
+      },
+      {
+        from: "zcash",
+        to: "ethereum_classic",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum_classic",
+        to: "bitcoin",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum_classic",
+        to: "ethereum",
+        tradeMethod: "float",
+      },
+      {
+        from: "bitcoin",
+        to: "ethereum",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "bitcoin",
+        to: "zcash",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "bitcoin",
+        to: "ethereum_classic",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "ethereum",
+        to: "bitcoin",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "ethereum",
+        to: "zcash",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "ethereum",
+        to: "ethereum_classic",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "zcash",
+        to: "bitcoin",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "zcash",
+        to: "ethereum_classic",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "ethereum_classic",
+        to: "bitcoin",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "ethereum_classic",
+        to: "ethereum",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "zcash",
+        to: "bitcoin",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "zcash",
+        to: "ethereum_classic",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "ethereum_classic",
+        to: "bitcoin",
+        tradeMethod: "fixed",
+      },
+      {
+        from: "ethereum_classic",
+        to: "ethereum",
+        tradeMethod: "fixed",
+      },
+    ],
+  },
+  {
+    provider: "ftx",
+    pairs: [
+      {
+        from: "bitcoin",
+        to: "ethereum",
+        tradeMethod: "float",
+      },
+      {
+        from: "bitcoin",
+        to: "zcash",
+        tradeMethod: "float",
+      },
+      {
+        from: "bitcoin",
+        to: "ethereum_classic",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "bitcoin",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "zcash",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum",
+        to: "ethereum_classic",
+        tradeMethod: "float",
+      },
+      {
+        from: "zcash",
+        to: "bitcoin",
+        tradeMethod: "float",
+      },
+      {
+        from: "zcash",
+        to: "ethereum",
+        tradeMethod: "float",
+      },
+      {
+        from: "zcash",
+        to: "ethereum_classic",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum_classic",
+        to: "bitcoin",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum_classic",
+        to: "ethereum",
+        tradeMethod: "float",
+      },
+      {
+        from: "ethereum_classic",
+        to: "zcash",
+        tradeMethod: "float",
+      },
+    ],
+  },
+];
+
+jest.mock("axios");
+const mockedAxios = jest.mocked(axios);
+
+describe("swap/getProviders", () => {
+  const DEFAULT_SWAP_API_BASE = getEnv("SWAP_API_BASE");
+
+  afterAll(() => {
+    // Restore DEFAULT_SWAP_API_BASE
+    setEnv("SWAP_API_BASE", DEFAULT_SWAP_API_BASE);
+  });
+
+  describe("version 2", () => {
+    const data = [
+      {
+        provider: "changelly",
+        pairs: [
+          {
+            from: "bitcoin",
+            to: "ethereum",
+            tradeMethod: ["float", "fixed"],
+          },
+          {
+            from: "bitcoin",
+            to: "ethereum_classic",
+            tradeMethod: ["float", "fixed"],
+          },
+        ],
+      },
+    ];
+    const resp = {
+      data,
+      status: 200,
+      statusText: "",
+      headers: {},
+      config: {},
+    };
+
+    beforeAll(() => {
+      // set SWAP_API_BASE
+      setEnv("SWAP_API_BASE", "https://swap.ledger.com/v2");
+    });
+
+    beforeEach(() => {
+      mockedAxios.mockResolvedValue(Promise.resolve(resp));
+    });
+
+    afterEach(() => {
+      mockedAxios.mockClear();
+    });
+
+    test("should not be called with whitelist", async () => {
+      await getProviders();
+
+      expect(mockedAxios).toBeCalledWith(
+        expect.objectContaining({
+          params: undefined,
+        })
+      );
+    });
+  });
+
+  describe("version 3", () => {
+    const data = [
+      {
+        provider: "changelly",
+        pairs: [
+          {
+            from: "bitcoin",
+            to: "ethereum",
+            tradeMethod: ["float", "fixed"],
+          },
+          {
+            from: "bitcoin",
+            to: "ethereum_classic",
+            tradeMethod: ["float", "fixed"],
+          },
+        ],
+      },
+    ];
+    const resp = {
+      data,
+      status: 200,
+      statusText: "",
+      headers: {},
+      config: {},
+    };
+
+    beforeAll(() => {
+      // set SWAP_API_BASE
+      setEnv("SWAP_API_BASE", "https://swap.ledger.com/v3");
+    });
+
+    beforeEach(() => {
+      mockedAxios.mockResolvedValue(Promise.resolve(resp));
+    });
+
+    afterEach(() => {
+      mockedAxios.mockClear();
+    });
+
+    test("should be called with whitelist", async () => {
+      await getProviders();
+
+      expect(mockedAxios).toBeCalledWith(
+        expect.objectContaining({
+          params: expect.objectContaining({
+            whitelist: expect.any(Array),
+          }),
+        })
+      );
+    });
+
+    test("should throw error if no data", async () => {
+      const emptyResp = { ...resp, data: [] };
+
+      mockedAxios.mockResolvedValue(Promise.resolve(emptyResp));
+
+      await expect(getProviders).rejects.toThrow("SwapNoAvailableProviders");
+    });
+
+    test("should return list of providers with pairs", async () => {
+      const res = await getProviders();
+
+      expect(res).toEqual(data);
+    });
+  });
+
+  describe("version 4", () => {
+    const data = {
+      currencies: {
+        "1": "bitcoin",
+        "2": "ethereum",
+        "3": "zcash",
+        "4": "ethereum_classic",
+      },
+      providers: {
+        changelly: [
+          {
+            methods: ["float"],
+            pairs: {
+              "1": [2, 3, 4],
+              "2": [1, 3, 4],
+            },
+          },
+          {
+            methods: ["float", "fixed"],
+            pairs: {
+              "1": [2, 3, 4],
+              "2": [1, 3, 4],
+              "3": [1, 4],
+              "4": [1, 2],
+            },
+          },
+          {
+            methods: ["fixed"],
+            pairs: {
+              "3": [1, 4],
+              "4": [1, 2],
+            },
+          },
+        ],
+        ftx: [
+          {
+            methods: ["float"],
+            pairs: {
+              "1": [2, 3, 4],
+              "2": [1, 3, 4],
+              "3": [1, 2, 4],
+              "4": [1, 2, 3],
+            },
+          },
+        ],
+      },
+    };
+
+    const resp = {
+      data,
+      status: 200,
+      statusText: "",
+      headers: {},
+      config: {},
+    };
+
+    beforeAll(() => {
+      // set SWAP_API_BASE
+      setEnv("SWAP_API_BASE", "https://swap.ledger.com/v4");
+    });
+
+    beforeEach(() => {
+      mockedAxios.mockResolvedValue(Promise.resolve(resp));
+    });
+
+    afterEach(() => {
+      mockedAxios.mockClear();
+    });
+
+    test("should be called with whitelist", async () => {
+      await getProviders();
+
+      expect(mockedAxios).toBeCalledWith(
+        expect.objectContaining({
+          params: expect.objectContaining({
+            whitelist: expect.any(Array),
+          }),
+        })
+      );
+    });
+
+    test("should throw error if no providers", async () => {
+      const emptyResp = { ...resp, data: { ...data, providers: {} } };
+
+      mockedAxios.mockResolvedValue(Promise.resolve(emptyResp));
+
+      await expect(getProviders).rejects.toThrow("SwapNoAvailableProviders");
+    });
+
+    test("should return list of providers with pairs", async () => {
+      const res = await getProviders();
+
+      expect(res).toEqual(EXPECTED_RESULT_V4);
+    });
+  });
+});

package/src/exchange/swap/getProviders.ts

@@ -2,29 +2,52 @@ import qs from "qs";
 import { getEnv } from "../../env";
 import { SwapNoAvailableProviders } from "../../errors";
 import network from "../../network";
-import { getAvailableProviders, getSwapAPIBaseURL } from "./";
+import {
+  getAvailableProviders,
+  getSwapAPIBaseURL,
+  getSwapAPIVersion,
+} from "./";
 import { mockGetProviders } from "./mock";
-import type { GetProviders } from "./types";
+import type { GetProviders, ProvidersResponseV4 } 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 version = getSwapAPIVersion();
 
   const res = await network({
     method: "GET",
     url: `${getSwapAPIBaseURL()}/providers`,
-    params: usesV3 ? { whitelist: getAvailableProviders() } : undefined,
+    params: version >= 3 ? { whitelist: getAvailableProviders() } : undefined,
     paramsSerializer: (params) =>
       qs.stringify(params, { arrayFormat: "comma" }),
   });
 
-  if (!res.data.length) {
-    throw new SwapNoAvailableProviders();
+  if (version < 4) {
+    if (!res.data.length) {
+      throw new SwapNoAvailableProviders();
+    }
+    return res.data;
   }
 
-  return res.data;
+  const responseV4 = res.data as ProvidersResponseV4;
+  if (!responseV4.providers || !Object.keys(responseV4.providers).length) {
+    throw new SwapNoAvailableProviders();
+  }
+  return Object.entries(responseV4.providers).flatMap(([provider, groups]) => ({
+    provider: provider,
+    pairs: groups.flatMap((group) =>
+      group.methods.flatMap((tradeMethod) =>
+        Object.entries(group.pairs).flatMap(([from, toArray]) =>
+          (toArray as number[]).map((to) => ({
+            from: responseV4.currencies[from],
+            to: responseV4.currencies[to.toString()],
+            tradeMethod,
+          }))
+        )
+      )
+    ),
+  }));
 };
 
 export default getProviders;

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

@@ -137,6 +137,49 @@ describe("useProviderRates", () => {
     expect(mockedGetExchangeRates).toHaveBeenCalledTimes(1);
   });
 
+  it("should refetch with the corrected selected rate", async () => {
+    const setExchangeRate = jest.fn();
+
+    mockedGetExchangeRates.mockResolvedValue(mockedRatesPromise);
+
+    const { result, waitForNextUpdate } = renderHook(useProviderRates, {
+      initialProps: { ...baseInitalProps, setExchangeRate },
+    });
+
+    mockedGetExchangeRates.mockClear();
+
+    act(() => {
+      result.current.refetchRates();
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+
+    expect(setExchangeRate).toBeCalledWith(
+      expect.objectContaining({
+        provider: "ftx",
+        tradeMethod: "fixed",
+      })
+    );
+
+    act(() => {
+      result.current.updateSelectedRate({
+        rate: new BigNumber(1),
+        toAmount: new BigNumber(1),
+        magnitudeAwareRate: new BigNumber(1),
+        provider: "ftx",
+        tradeMethod: "float",
+      });
+      result.current.refetchRates();
+    });
+    await waitForNextUpdate({ timeout: 1000 });
+
+    expect(setExchangeRate).toBeCalledWith(
+      expect.objectContaining({
+        provider: "ftx",
+        tradeMethod: "float",
+      })
+    );
+  });
+
   it("should refetch the rates if refetchRates is called", async () => {
     const { result, waitForNextUpdate } = renderHook(useProviderRates, {
       initialProps: baseInitalProps,

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

@@ -45,6 +45,7 @@ export const useProviderRates = ({
 }): {
   rates: RatesReducerState;
   refetchRates: () => void;
+  updateSelectedRate: (selected?: ExchangeRate) => void;
 } => {
   const { account: fromAccount } = fromState;
   const { currency: toCurrency } = toState;
@@ -55,8 +56,15 @@ export const useProviderRates = ({
   const [getRatesDependency, setGetRatesDependency] = useState<unknown | null>(
     null
   );
+  const [getSelectedRate, setGetSelectedRate] = useState<ExchangeRate | {}>({});
+
   const refetchRates = useCallback(() => setGetRatesDependency({}), []);
 
+  const updateSelectedRate = useCallback(
+    (selected = {}) => setGetSelectedRate(selected),
+    []
+  );
+
   useEffect(
     () => {
       let abort = false;
@@ -141,12 +149,22 @@ export const useProviderRates = ({
             dispatchRates({ type: "set", payload: rates });
 
             /**
-             * Select the first rate returned by the API. Should be the prefered
+             * By default 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);
+            const getRate = () => {
+              if (!(rates?.length > 0)) {
+                return null;
+              }
+              const { provider, tradeMethod } = getSelectedRate as ExchangeRate;
+              const rate = rates.find(
+                (rate) =>
+                  rate.provider === provider && rate.tradeMethod === tradeMethod
+              );
+              return rate ? rate : rates[0];
+            };
+            setExchangeRate && setExchangeRate(getRate());
           }
         } catch (error) {
           !abort && dispatchRates({ type: "error", payload: error });
@@ -174,5 +192,6 @@ export const useProviderRates = ({
   return {
     rates,
     refetchRates,
+    updateSelectedRate,
   };
 };

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

@@ -32,6 +32,7 @@ export type SwapDataType = {
   isSwapReversable: boolean;
   rates: RatesReducerState;
   refetchRates: () => void;
+  updateSelectedRate: (selected?: ExchangeRate) => void;
   targetAccounts?: Account[];
 };
 export const selectorStateDefaultValues = {
@@ -139,7 +140,7 @@ export const useSwapTransaction = ({
     setIsSendMaxLoading,
   });
 
-  const { rates, refetchRates } = useProviderRates({
+  const { rates, refetchRates, updateSelectedRate } = useProviderRates({
     fromState,
     toState,
     transaction,
@@ -156,6 +157,7 @@ export const useSwapTransaction = ({
       isSwapReversable,
       rates,
       refetchRates,
+      updateSelectedRate,
       targetAccounts,
     },
     setFromAmount,

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

@@ -1,4 +1,6 @@
-import { isSwapOperationPending } from ".";
+import { isSwapOperationPending, getSwapAPIVersion } from ".";
+
+import { getEnv, setEnv } from "../../env";
 
 describe("swap/index", () => {
   describe("isSwapOperationPending", () => {
@@ -33,4 +35,37 @@ describe("swap/index", () => {
       expect(result).toBe(true);
     });
   });
+
+  describe("getSwapAPIVersion", () => {
+    const DEFAULT_SWAP_API_BASE = getEnv("SWAP_API_BASE");
+
+    afterEach(() => {
+      // Restore DEFAULT_SWAP_API_BASE
+      setEnv("SWAP_API_BASE", DEFAULT_SWAP_API_BASE);
+    });
+
+    test("should return version when SWAP_API_BASE contains one", () => {
+      const result = getSwapAPIVersion();
+
+      expect(result).toBe(4);
+    });
+
+    test("should throw an error if no version in SWAP_API_BASE", () => {
+      setEnv("SWAP_API_BASE", "https://swap.ledger.com");
+
+      expect(getSwapAPIVersion).toThrow(Error);
+      expect(getSwapAPIVersion).toThrow(
+        "Configured swap API base URL is invalid, should end with /v<number>"
+      );
+    });
+
+    test("should throw an error if version is NaN", () => {
+      setEnv("SWAP_API_BASE", "https://swap.ledger.com/vtest");
+
+      expect(getSwapAPIVersion).toThrow(Error);
+      expect(getSwapAPIVersion).toThrow(
+        "Configured swap API base URL is invalid, should end with /v<number>"
+      );
+    });
+  });
 });