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

package/src/exchange/swap/updateAccountSwapStatus.ts

@@ -1,11 +1,11 @@
+import type { Account, SubAccount } from "../../types";
+import { isSwapOperationPending } from "./";
 import { getMultipleStatus } from "./getStatus";
-import type { SubAccount, Account } from "../../types";
 import type {
-  UpdateAccountSwapStatus,
   SwapOperation,
   SwapStatusRequest,
+  UpdateAccountSwapStatus,
 } from "./types";
-import { operationStatusList } from "./";
 
 const maybeGetUpdatedSwapHistory = async (
   swapHistory: SwapOperation[] | null | undefined
@@ -16,7 +16,7 @@ const maybeGetUpdatedSwapHistory = async (
 
   if (swapHistory) {
     for (const { provider, swapId, status } of swapHistory) {
-      if (operationStatusList.pending.includes(status)) {
+      if (isSwapOperationPending(status)) {
         pendingSwapIds.push({
           provider,
           swapId,

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

@@ -1,11 +1,6 @@
+import { getTokenById } from "@ledgerhq/cryptoassets/lib/tokens";
 import BigNumber from "bignumber.js";
-
-import {
-  pickExchangeRate,
-  getAccountTuplesForCurrency,
-  getAvailableAccountsById,
-} from "./index";
-import { getMockExchangeRate } from "../mock";
+import { getCryptoCurrencyById } from "../../../currencies";
 import { genAccount } from "../../../mock/account";
 import type {
   Account,
@@ -13,62 +8,14 @@ import type {
   SubAccount,
   TokenCurrency,
 } from "../../../types";
-import { getCryptoCurrencyById } from "../../../currencies";
-import { getTokenById } from "@ledgerhq/cryptoassets/lib/tokens";
-
-describe("swap/utils/pickExchangeRate", () => {
-  test("calls the callback function with null when no exchange rates are passed", () => {
-    const setExchangeRate = jest.fn();
-    pickExchangeRate([], undefined, setExchangeRate);
-
-    expect(setExchangeRate).toHaveBeenCalledTimes(1);
-    expect(setExchangeRate).toHaveBeenCalledWith(null);
-  });
-
-  test("calls the callback function with null when no exchange rates are passed but there is an exchange rate", () => {
-    const setExchangeRate = jest.fn();
-    const exchangeRate = getMockExchangeRate({ provider: "wyre" });
-    pickExchangeRate([], exchangeRate, setExchangeRate);
-
-    expect(setExchangeRate).toHaveBeenCalledTimes(1);
-    expect(setExchangeRate).toHaveBeenCalledWith(null);
-  });
-
-  test("calls the callback function with the first exchange rate when the exchange passed isn't included in the list", () => {
-    const setExchangeRate = jest.fn();
-    const firstExchangeRate = getMockExchangeRate({
-      provider: "changelly",
-      tradeMethod: "fixed",
-    });
-    const exchangeRates = [
-      firstExchangeRate,
-      getMockExchangeRate({ provider: "changelly", tradeMethod: "float" }),
-    ];
-    const exchangeRate = getMockExchangeRate({ provider: "wyre" });
-
-    pickExchangeRate(exchangeRates, exchangeRate, setExchangeRate);
-
-    expect(setExchangeRate).toHaveBeenCalledTimes(1);
-    expect(setExchangeRate).toHaveBeenCalledWith(firstExchangeRate);
-  });
-
-  test("calls the callback function with the passed exchange rate when the exchange passed is included in the list", () => {
-    const setExchangeRate = jest.fn();
-    const exchangeRate = getMockExchangeRate({
-      provider: "changelly",
-      tradeMethod: "fixed",
-    });
-    const exchangeRates = [
-      getMockExchangeRate({ provider: "changelly", tradeMethod: "float" }),
-      exchangeRate,
-    ];
-
-    pickExchangeRate(exchangeRates, exchangeRate, setExchangeRate);
-
-    expect(setExchangeRate).toHaveBeenCalledTimes(1);
-    expect(setExchangeRate).toHaveBeenCalledWith(exchangeRate);
-  });
-});
+import {
+  getAccountTuplesForCurrency,
+  getAvailableAccountsById,
+  getProviderName,
+  KYCStatus,
+  shouldShowKYCBanner,
+  shouldShowLoginBanner,
+} from "./index";
 
 /* TODO: Refacto these two function and move them to mock/account.ts if needed */
 function* accountGenerator(currency: CryptoCurrency): Generator<Account> {
@@ -265,3 +212,120 @@ describe("swap/utils/getAvailableAccountsById", () => {
     );
   });
 });
+
+describe("swap/utils/shouldShowLoginBanner", () => {
+  test("should not display Login banner if no provider is specified", () => {
+    const result = shouldShowLoginBanner({
+      provider: undefined,
+      token: "token",
+    });
+
+    expect(result).toBe(false);
+  });
+
+  ["changelly", "wyre"].forEach((provider) => {
+    test(`should not display Login banner for ${provider}`, () => {
+      const result = shouldShowLoginBanner({
+        provider,
+        token: "token",
+      });
+
+      expect(result).toBe(false);
+    });
+  });
+
+  ["ftx", "ftxus"].forEach((provider) => {
+    describe(`${provider.toUpperCase()}`, () => {
+      test("should display Login banner if no token is provided", () => {
+        const result = shouldShowLoginBanner({
+          provider: provider,
+          token: undefined,
+        });
+
+        expect(result).toBe(true);
+      });
+
+      test("should display Login banner if token is expired", () => {
+        /**
+         * TODO: add test by mocking `isJwtExpired`
+         */
+      });
+
+      test("should not display Login banner if token is not expired", () => {
+        /**
+         * TODO: add test by mocking `isJwtExpired`
+         */
+      });
+    });
+  });
+});
+
+describe("swap/utils/shouldShowKYCBanner", () => {
+  test("should not display KYC banner if no provider is specified", () => {
+    const result = shouldShowKYCBanner({
+      provider: undefined,
+      kycStatus: "rejected",
+    });
+
+    expect(result).toBe(false);
+  });
+
+  test("should not display KYC banner if provider does not require KYC", () => {
+    const result = shouldShowKYCBanner({
+      provider: "changelly",
+      kycStatus: "rejected",
+    });
+
+    expect(result).toBe(false);
+  });
+
+  ["ftx", "ftxus", "wyre"].forEach((provider) => {
+    describe(`${provider.toUpperCase()}`, () => {
+      ["pending", "upgradeRequired", "rejected"].forEach((status) => {
+        test(`should display KYC banner if kycStatus is ${status}`, () => {
+          const result = shouldShowKYCBanner({
+            provider,
+            kycStatus: status as KYCStatus,
+          });
+
+          expect(result).toBe(true);
+        });
+      });
+
+      test("should not display KYC banner if kycStatus is approved", () => {
+        const result = shouldShowKYCBanner({
+          provider,
+          kycStatus: "approved",
+        });
+
+        expect(result).toBe(false);
+      });
+    });
+  });
+});
+
+describe("swap/utils/getProviderName", () => {
+  test("should return uppercase provider name for ftx", () => {
+    const expectedResult = "FTX";
+
+    const result = getProviderName("ftx");
+
+    expect(result).toBe(expectedResult);
+  });
+
+  test("should return uppercase provider name for ftxus", () => {
+    const expectedResult = "FTXUS";
+
+    const result = getProviderName("ftxus");
+
+    expect(result).toBe(expectedResult);
+  });
+
+  test("should return capitalized provider name for other provider", () => {
+    const expectedResult = "Changelly";
+
+    const result = getProviderName("changelly");
+
+    expect(result).toBe(expectedResult);
+  });
+});

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

@@ -1,37 +1,21 @@
 import { CryptoCurrency, TokenCurrency } from "@ledgerhq/cryptoassets";
-import { makeEmptyTokenAccount } from "../../../account";
+import jwtDecode from "jwt-decode";
+import { getProviderConfig } from "../";
+import { getAccountCurrency, makeEmptyTokenAccount } from "../../../account";
+import { getEnv } from "../../../env";
 import { Account, SubAccount, TokenAccount } from "../../../types";
-import type { ExchangeRate } from "../types";
-import { getAccountCurrency } from "../../../account";
+import type { CheckQuoteStatus } from "../types";
 
+// Note: looks like we can't use an enum because this is used in LLD js code
 export const KYC_STATUS = {
   pending: "pending",
   rejected: "closed",
   approved: "approved",
+  upgradeRequired: "upgradeRequired",
 };
 
 export type KYCStatus = keyof typeof KYC_STATUS;
 
-export const pickExchangeRate = (
-  exchangeRates: ExchangeRate[],
-  exchangeRate: ExchangeRate | null | undefined,
-  setExchangeRate: (rate?: ExchangeRate | null) => void
-): void => {
-  const hasRates = exchangeRates?.length > 0;
-  // If the user picked an exchange rate before, try to select the new one that matches.
-  // Otherwise pick the first one.
-  const rate =
-    hasRates &&
-    ((exchangeRate &&
-      exchangeRates.find(
-        ({ tradeMethod, provider }) =>
-          tradeMethod === exchangeRate.tradeMethod &&
-          provider === exchangeRate.provider
-      )) ||
-      exchangeRates[0]);
-  setExchangeRate(rate || null);
-};
-
 export type AccountTuple = {
   account: Account | null | undefined;
   subAccount: SubAccount | null | undefined;
@@ -76,3 +60,124 @@ export const getAvailableAccountsById = (
   accounts
     .filter((acc) => getAccountCurrency(acc)?.id === id && !acc.disabled)
     .sort((a, b) => b.balance.minus(a.balance).toNumber());
+
+// Note: used in UI (LLD / LLM)
+export const isJwtExpired = (jwtToken: string): boolean => {
+  /**
+   * Note:
+   * The JWT token should have at least an exp property (the expiration date of the token)
+   */
+  const { exp } = jwtDecode<{ exp: number }>(jwtToken);
+
+  const currentTime = new Date().getTime() / 1000;
+
+  return currentTime > exp;
+};
+
+// Note: used in UI (LLD / LLM)
+export const getKYCStatusFromCheckQuoteStatus = (
+  checkQuoteStatus: CheckQuoteStatus
+): KYCStatus | null => {
+  switch (checkQuoteStatus.codeName) {
+    case "KYC_PENDING":
+      return KYC_STATUS.pending as KYCStatus;
+
+    case "KYC_FAILED":
+      return KYC_STATUS.rejected as KYCStatus;
+
+    case "KYC_UNDEFINED":
+    case "KYC_UPGRADE_REQUIRED":
+      return KYC_STATUS.upgradeRequired as KYCStatus;
+
+    case "RATE_VALID":
+      return KYC_STATUS.approved as KYCStatus;
+
+    // FIXME: should handle all other non KYC related error cases somewhere
+    default:
+      return null;
+  }
+};
+
+// Note: used in UI (LLD / LLM)
+export type WidgetTypes = "login" | "kyc" | "mfa";
+export type FTXProviders = "ftx" | "ftxus";
+export const getFTXURL = ({
+  type,
+  provider,
+}: {
+  type: WidgetTypes;
+  provider: FTXProviders;
+}): string => {
+  const baseUrl =
+    getEnv("MOCK_SWAP_WIDGET_BASE_URL") ||
+    (() => {
+      switch (provider) {
+        case "ftx":
+          return "https://ftx.com";
+
+        case "ftxus":
+          return "https://ftx.us";
+
+        default:
+          break;
+      }
+    })();
+
+  if (!baseUrl) {
+    throw new Error(`Could not find domain for ${provider}`);
+  }
+
+  return `${baseUrl}/${type}?hideFrame=true&ledgerLive=true`;
+};
+
+// Note: used in UI (LLD / LLM)
+export const shouldShowLoginBanner = ({
+  provider,
+  token,
+}: {
+  provider?: string;
+  token?: string;
+}): boolean => {
+  if (!provider) {
+    return false;
+  }
+
+  const providerConfig = getProviderConfig(provider);
+
+  if (!providerConfig.needsBearerToken) {
+    return false;
+  }
+
+  return !token || isJwtExpired(token);
+};
+
+// Note: used in UI (LLD / LLM)
+export const shouldShowKYCBanner = ({
+  provider,
+  kycStatus,
+}: {
+  provider?: string;
+  kycStatus: KYCStatus;
+}): boolean => {
+  if (!provider) {
+    return false;
+  }
+
+  const providerConfig = getProviderConfig(provider);
+
+  if (!providerConfig.needsKYC) {
+    return false;
+  }
+
+  return kycStatus !== KYC_STATUS.approved;
+};
+
+export const getProviderName = (provider: string): string => {
+  switch (provider) {
+    case "ftx":
+    case "ftxus":
+      return provider.toUpperCase();
+    default:
+      return provider.charAt(0).toUpperCase() + provider.slice(1);
+  }
+};

package/src/hw/actions/initSwap.ts

@@ -1,24 +1,26 @@
-import { Observable, of, concat } from "rxjs";
-import { scan, tap, catchError } from "rxjs/operators";
+import { log } from "@ledgerhq/logs";
 import { useEffect, useState } from "react";
+import { concat, Observable, of } from "rxjs";
+import { catchError, scan, tap } from "rxjs/operators";
 import { getMainAccount } from "../../account";
-import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
-import type { InitSwapInput, SwapTransaction } from "../../exchange/swap/types";
-import type { Action, Device } from "./types";
-import type { AppState } from "./app";
-import { log } from "@ledgerhq/logs";
-import { createAction as createAppAction } from "./app";
 import type {
   Exchange,
   ExchangeRate,
+  InitSwapInput,
   InitSwapResult,
   SwapRequestEvent,
+  SwapTransaction,
 } from "../../exchange/swap/types";
+import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
+import type { AppState } from "./app";
+import { createAction as createAppAction } from "./app";
+import type { Action, Device } from "./types";
 
 type State = {
   initSwapResult: InitSwapResult | null | undefined;
   initSwapRequested: boolean;
   initSwapError: Error | null | undefined;
+  swapId?: string;
   error?: Error;
   isLoading: boolean;
   freezeReduxDevice: boolean;
@@ -40,6 +42,7 @@ type Result =
     }
   | {
       initSwapError: Error;
+      swapId?: string;
     };
 
 type InitSwapAction = Action<InitSwapRequest, InitSwapState, Result>;
@@ -47,6 +50,7 @@ type InitSwapAction = Action<InitSwapRequest, InitSwapState, Result>;
 const mapResult = ({
   initSwapResult,
   initSwapError,
+  swapId,
 }: InitSwapState): Result | null | undefined =>
   initSwapResult
     ? {
@@ -55,12 +59,14 @@ const mapResult = ({
     : initSwapError
     ? {
         initSwapError,
+        swapId,
       }
     : null;
 
 const initialState: State = {
   initSwapResult: null,
   initSwapError: null,
+  swapId: undefined,
   initSwapRequested: false,
   isLoading: true,
   freezeReduxDevice: false,
@@ -72,7 +78,12 @@ const reducer = (state: State, e: SwapRequestEvent) => {
       return { ...state, freezeReduxDevice: true };
 
     case "init-swap-error":
-      return { ...state, initSwapError: e.error, isLoading: false };
+      return {
+        ...state,
+        initSwapError: e.error,
+        swapId: e.swapId,
+        isLoading: false,
+      };
 
     case "init-swap-requested":
       return {