@ledgerhq/live-common 23.1.0 → 24.0.0-next.2

package/src/exchange/swap/postSwapState.ts

@@ -0,0 +1,61 @@
+import { getEnv } from "../../env";
+import network from "../../network";
+import { getSwapAPIBaseURL } from "./";
+import { mockPostSwapAccepted, mockPostSwapCancelled } from "./mock";
+import type { PostSwapAccepted, PostSwapCancelled } from "./types";
+
+export const postSwapAccepted: PostSwapAccepted = async ({
+  provider,
+  swapId = "",
+  transactionId,
+}) => {
+  if (getEnv("MOCK"))
+    return mockPostSwapAccepted({ provider, swapId, transactionId });
+
+  /**
+   * Since swapId is requiered by the endpoit, don't call it if we don't have
+   * this info
+   */
+  if (!swapId) {
+    return null;
+  }
+
+  try {
+    await network({
+      method: "POST",
+      url: `${getSwapAPIBaseURL()}/swap/accepted`,
+      data: { provider, swapId, transactionId },
+    });
+  } catch (error) {
+    console.error(error);
+  }
+
+  return null;
+};
+
+export const postSwapCancelled: PostSwapCancelled = async ({
+  provider,
+  swapId = "",
+}) => {
+  if (getEnv("MOCK")) return mockPostSwapCancelled({ provider, swapId });
+
+  /**
+   * Since swapId is requiered by the endpoit, don't call it if we don't have
+   * this info
+   */
+  if (!swapId) {
+    return null;
+  }
+
+  try {
+    await network({
+      method: "POST",
+      url: `${getSwapAPIBaseURL()}/swap/cancelled`,
+      data: { provider, swapId },
+    });
+  } catch (error) {
+    console.error(error);
+  }
+
+  return null;
+};

package/src/exchange/swap/types.ts

@@ -1,14 +1,14 @@
 import { BigNumber } from "bignumber.js";
-import type { Account, AccountLike } from "../../types/account";
 import type {
-  AccountRawLike,
   AccountRaw,
-  Operation,
-  Transaction,
+  AccountRawLike,
   CryptoCurrency,
+  Operation,
   TokenCurrency,
+  Transaction,
   TransactionRaw,
 } from "../../types";
+import type { Account, AccountLike } from "../../types/account";
 
 /// v3 changes here, move me to another folder soon
 export type ValidKYCStatus = "open" | "pending" | "approved" | "closed";
@@ -81,6 +81,39 @@ export type AvailableProviderV3 = {
   pairs: Array<{ from: string; to: string; tradeMethod: string }>;
 };
 
+type CheckQuoteOkStatus = {
+  codeName: "RATE_VALID";
+};
+
+type ValidCheckQuoteErrorCodes =
+  | "UNKNOW_USER"
+  | "KYC_UNDEFINED"
+  | "KYC_PENDING"
+  | "KYC_FAILED"
+  | "KYC_UPGRADE_REQUIRED"
+  | "OVER_TRADE_LIMIT"
+  | "UNKNOWN_ERROR"
+  | "WITHDRAWALS_BLOCKED"
+  | "MFA_REQUIRED"
+  | "RATE_NOT_FOUND";
+
+type CheckQuoteErrorStatus = {
+  codeName: ValidCheckQuoteErrorCodes;
+  error: string;
+  description: string;
+};
+
+export type CheckQuoteStatus = CheckQuoteOkStatus | CheckQuoteErrorStatus;
+
+export type CheckQuote = ({
+  provider,
+  quoteId,
+  bearerToken,
+}: {
+  provider: string;
+  quoteId: string;
+  bearerToken: string;
+}) => Promise<CheckQuoteStatus>;
 export type AvailableProvider = AvailableProviderV2 | AvailableProviderV3;
 export type GetExchangeRates = (
   arg0: Exchange,
@@ -93,6 +126,7 @@ export type InitSwapResult = {
   transaction: Transaction;
   swapId: string;
 };
+
 type ValidSwapStatus =
   | "pending"
   | "onhold"
@@ -108,7 +142,31 @@ export type SwapStatus = {
   swapId: string;
   status: ValidSwapStatus;
 };
-export type GetStatus = (arg0: SwapStatusRequest) => Promise<SwapStatus>;
+
+// -----
+// Related to Swap state API call (accepted or cancelled)
+
+type SwapStateRequest = {
+  provider: string;
+  swapId: string;
+};
+
+export type SwapStateAcceptedRequest = SwapStateRequest & {
+  transactionId: string;
+};
+
+export type SwapStateCancelledRequest = SwapStateRequest;
+
+export type PostSwapAccepted = (
+  arg0: SwapStateAcceptedRequest
+) => Promise<null>;
+
+export type PostSwapCancelled = (
+  arg0: SwapStateCancelledRequest
+) => Promise<null>;
+
+// -----
+
 export type UpdateAccountSwapStatus = (
   arg0: Account
 ) => Promise<Account | null | undefined>;
@@ -125,6 +183,7 @@ export type SwapRequestEvent =
   | {
       type: "init-swap-error";
       error: Error;
+      swapId: string;
     }
   | {
       type: "init-swap-result";
@@ -203,3 +262,7 @@ export type InitSwapInputRaw = {
   deviceId: string;
   userId?: string;
 };
+
+export interface CustomMinOrMaxError extends Error {
+  amount: BigNumber;
+}

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/families/algorand/{test-dataset.ts → bridge.integration.test.ts}

@@ -1,4 +1,6 @@
 import { BigNumber } from "bignumber.js";
+import "../../__tests__/test-helpers/setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
 import type { DatasetTest } from "../../types";
 import {
   InvalidAddressBecauseDestinationIsAlsoSource,
@@ -9,10 +11,10 @@ import { AlgorandASANotOptInInRecipient } from "../../errors";
 import type { AlgorandTransaction } from "./types";
 // const notCreatedAlgorandAddress =
 //   "ZBILW5BPM7AQU54YQZICSGS4J7KJ2XV6OC3DFUQ7BB4DVLYKKUEVWDDBGM";
+
 const dataset: DatasetTest<AlgorandTransaction> = {
-  implementations: ["libcore"],
-  // test disabled. FIXME ctx LL-5485
-  currencies: {} || {
+  implementations: ["js"],
+  currencies: {
     algorand: {
       FIXME_ignoreAccountFields: [
         "algorandResources.rewards", // We cant keep track of this since it's always moving
@@ -43,7 +45,7 @@ const dataset: DatasetTest<AlgorandTransaction> = {
           FIXME_tests: ["balance is sum of ops"],
           // Rewards issues
           raw: {
-            id: "libcore:1:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:",
+            id: "js:1:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:",
             seedIdentifier:
               "c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4",
             name: "Algorand 1",
@@ -165,7 +167,7 @@ const dataset: DatasetTest<AlgorandTransaction> = {
               transaction: (t) => ({
                 ...t,
                 subAccountId:
-                  "libcore:1:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:+312769",
+                  "js:1:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:+312769",
                 amount: new BigNumber("1000"),
                 recipient:
                   "ZQVVJ2S4XWS542KXBBVIINOEHIDOEZKZWK725PWFNN2I5RNCUBI53RT2EY",
@@ -182,7 +184,7 @@ const dataset: DatasetTest<AlgorandTransaction> = {
               transaction: (t) => ({
                 ...t,
                 subAccountId:
-                  "libcore:1:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:+312769",
+                  "js:1:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:+312769",
                 amount: new BigNumber("1000"),
                 recipient:
                   "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
@@ -198,7 +200,7 @@ const dataset: DatasetTest<AlgorandTransaction> = {
               transaction: (t) => ({
                 ...t,
                 subAccountId:
-                  "libcore:1:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:+312769",
+                  "js:1:algorand:c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4:+312769",
                 amount: new BigNumber("100000000000"),
                 recipient:
                   "MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI",
@@ -214,7 +216,7 @@ const dataset: DatasetTest<AlgorandTransaction> = {
         },
         {
           raw: {
-            id: "libcore:1:algorand:6104eb314f51f4db5733976bd8c066297019ebaa6adcf39b4aa318d553c571cc:",
+            id: "js:1:algorand:6104eb314f51f4db5733976bd8c066297019ebaa6adcf39b4aa318d553c571cc:",
             seedIdentifier:
               "c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4",
             xpub: "6104eb314f51f4db5733976bd8c066297019ebaa6adcf39b4aa318d553c571cc",
@@ -276,7 +278,7 @@ const dataset: DatasetTest<AlgorandTransaction> = {
               transaction: (t) => ({
                 ...t,
                 subAccountId:
-                  "libcore:1:algorand:fef9cf3252121f000324dd819b2c1d76910413924acaf6779b30e1fa1874d7af:+312769",
+                  "js:1:algorand:fef9cf3252121f000324dd819b2c1d76910413924acaf6779b30e1fa1874d7af:+312769",
                 amount: new BigNumber("1000"),
                 recipient:
                   "YWZPDCL5XQPCPGBXKB7KAG7YF2QGCGEX37YTSM55CPEPHKNE2ZSKRAXNQ4",
@@ -294,4 +296,5 @@ const dataset: DatasetTest<AlgorandTransaction> = {
     },
   },
 };
-export default dataset;
+
+testBridge(dataset);