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

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

@@ -1,18 +1,17 @@
-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 { act, renderHook } from "@testing-library/react-hooks";
 import BigNumber from "bignumber.js";
-import ethBridge from "../../../families/ethereum/bridge/mock";
 import { checkAccountSupported } from "../../../account/support";
+import ethBridge from "../../../families/ethereum/bridge/mock";
+import { genAccount, genTokenAccount } from "../../../mock/account";
+import { useUpdateMaxAmount, ZERO } from "./useUpdateMaxAmount";
 
 // Needs to be mocked since userSupportedCurrencies is initially empty.
 jest.mock("../../../account/support");
-const mockedCheckAccount = mocked(checkAccountSupported);
+const mockedCheckAccount = jest.mocked(checkAccountSupported);
 // Mock to use a custom estimate value and test the result.
 jest.mock("../../../families/ethereum/bridge/mock");
-const mockedEstimateMaxSpendable = mocked(
+const mockedEstimateMaxSpendable = jest.mocked(
   ethBridge.accountBridge.estimateMaxSpendable,
   true
 );
@@ -78,6 +77,33 @@ describe("updateAmountUsingMax", () => {
     expect(setFromAmount.mock.calls[0][0]).toBe(ZERO);
   });
 
+  it("should toggle setIsSendMaxLoading", async () => {
+    const setIsSendMaxLoading = jest.fn();
+
+    const amount = new BigNumber(0.5);
+    mockedEstimateMaxSpendable.mockResolvedValue(amount);
+    const { result } = renderHook(useUpdateMaxAmount, {
+      initialProps: { ...defaultProps, setIsSendMaxLoading },
+    });
+
+    act(() => result.current.toggleMax());
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(true);
+    setIsSendMaxLoading.mockClear();
+
+    // Lest resort solution, since waitFor and other helpers will not work here.
+    await wait();
+
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(false);
+    setIsSendMaxLoading.mockClear();
+
+    act(() => result.current.toggleMax());
+    expect(setIsSendMaxLoading).toBeCalledTimes(1);
+    expect(setIsSendMaxLoading).toBeCalledWith(false);
+    setIsSendMaxLoading.mockClear();
+  });
+
   it("should update the max amount whenever the dependencies change", async () => {
     const { result, rerender } = renderHook(useUpdateMaxAmount, {
       initialProps: defaultProps,

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

@@ -1,13 +1,13 @@
+import BigNumber from "bignumber.js";
 import { useCallback, useEffect, useState } from "react";
 import { getAccountBridge } from "../../../bridge";
-
+import { Transaction } from "../../../generated/types";
 import {
-  SwapTransactionType,
+  SetIsSendMaxLoading,
   SwapDataType,
   SwapSelectorStateType,
+  SwapTransactionType,
 } from "./useSwapTransaction";
-import { Transaction } from "../../../generated/types";
-import BigNumber from "bignumber.js";
 
 export const ZERO = new BigNumber(0);
 
@@ -17,27 +17,31 @@ export const useUpdateMaxAmount = ({
   parentAccount,
   transaction,
   feesStrategy,
+  setIsSendMaxLoading,
 }: {
   setFromAmount: SwapTransactionType["setFromAmount"];
   account: SwapSelectorStateType["account"];
   parentAccount: SwapSelectorStateType["parentAccount"];
   transaction: SwapTransactionType["transaction"];
   feesStrategy: Transaction["feesStrategy"];
+  setIsSendMaxLoading?: SetIsSendMaxLoading;
 }): {
   isMaxEnabled: SwapDataType["isMaxEnabled"];
   toggleMax: SwapTransactionType["toggleMax"];
 } => {
-  const [isMaxEnabled, setMax] = useState<SwapDataType["isMaxEnabled"]>(false);
+  const [isMaxEnabled, setIsMaxEnabled] =
+    useState<SwapDataType["isMaxEnabled"]>(false);
 
   const toggleMax: SwapTransactionType["toggleMax"] = useCallback(
     () =>
-      setMax((previous) => {
+      setIsMaxEnabled((previous) => {
         if (previous) {
           setFromAmount(ZERO);
+          setIsSendMaxLoading?.(false);
         }
         return !previous;
       }),
-    [setFromAmount]
+    [setFromAmount, setIsSendMaxLoading]
   );
 
   /* UPDATE from amount to the estimate max spendable on account
@@ -47,11 +51,13 @@ export const useUpdateMaxAmount = ({
       const updateAmountUsingMax = async () => {
         if (!account) return;
         const bridge = getAccountBridge(account, parentAccount);
+        setIsSendMaxLoading?.(true);
         const amount = await bridge.estimateMaxSpendable({
           account,
           parentAccount,
           transaction,
         });
+        setIsSendMaxLoading?.(false);
         setFromAmount(amount);
       };
 

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

@@ -0,0 +1,36 @@
+import { isSwapOperationPending } from ".";
+
+describe("swap/index", () => {
+  describe("isSwapOperationPending", () => {
+    test("should return false for ok status", () => {
+      const result = isSwapOperationPending("finished");
+
+      expect(result).toBe(false);
+    });
+
+    test("should return false for ko status", () => {
+      const result = isSwapOperationPending("refunded");
+
+      expect(result).toBe(false);
+    });
+
+    test("should return true for other status", () => {
+      const result = isSwapOperationPending("RANDOM_STATUS");
+
+      expect(result).toBe(true);
+    });
+
+    test("should return true if not status provided", () => {
+      /**
+       * Since this TS function can be used in loosly typed JS code, we need
+       * to test the case of the parameter not being provided
+       */
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      const result = isSwapOperationPending();
+
+      expect(result).toBe(true);
+    });
+  });
+});

package/src/exchange/swap/index.ts

@@ -1,45 +1,60 @@
-import type { ExchangeProviderNameAndSignature } from "../";
-import getExchangeRates from "./getExchangeRates";
-import getStatus from "./getStatus";
-import getProviders from "./getProviders";
-import getCompleteSwapHistory from "./getCompleteSwapHistory";
-import getKYCStatus from "./getKYCStatus";
-import submitKYC from "./submitKYC";
-import initSwap from "./initSwap";
+import type { SwapProviderConfig } from "../";
 import { getEnv } from "../../env";
 import {
-  JSONRPCResponseError,
-  JSONDecodeError,
-  NoIPHeaderError,
-  CurrencyNotSupportedError,
-  CurrencyDisabledError,
+  AccessDeniedError,
   CurrencyDisabledAsInputError,
   CurrencyDisabledAsOutputError,
+  CurrencyDisabledError,
   CurrencyNotSupportedByProviderError,
+  CurrencyNotSupportedError,
+  JSONDecodeError,
+  JSONRPCResponseError,
+  NoIPHeaderError,
+  NotImplementedError,
   TradeMethodNotSupportedError,
   UnexpectedError,
-  NotImplementedError,
   ValidationError,
-  AccessDeniedError,
 } from "../../errors";
+import checkQuote from "./checkQuote";
+import getCompleteSwapHistory from "./getCompleteSwapHistory";
+import getExchangeRates from "./getExchangeRates";
+import getKYCStatus from "./getKYCStatus";
+import getProviders from "./getProviders";
+import initSwap from "./initSwap";
+import { postSwapAccepted, postSwapCancelled } from "./postSwapState";
+import submitKYC from "./submitKYC";
 
 export const operationStatusList = {
   finishedOK: ["finished"],
   finishedKO: ["refunded"],
-  pending: ["pending", "onhold", "expired"],
 };
 
+// A swap operation is considered pending if it is not in a finishedOK or finishedKO state
+export const isSwapOperationPending: (status: string) => boolean = (status) =>
+  !operationStatusList.finishedOK.includes(status) &&
+  !operationStatusList.finishedKO.includes(status);
+
 const getSwapAPIBaseURL: () => string = () => getEnv("SWAP_API_BASE");
 
-const swapProviders: Record<
-  string,
-  {
-    nameAndPubkey: Buffer;
-    signature: Buffer;
-    curve: string;
-    needsKYC: boolean;
-  }
-> = {
+const ftx = {
+  nameAndPubkey: Buffer.concat([
+    Buffer.from([3]),
+    Buffer.from("FTX", "ascii"),
+    Buffer.from(
+      "04c89f3e48cde252f6cd6fcccc47c2f6ca6cf05f9f921703d31b7a7dddbf0bd6a690744662fe599f8761612021ba1fc0e8a5a4b7d5910c625b6dd09aa40762e5cd",
+      "hex"
+    ),
+  ]),
+  signature: Buffer.from(
+    "3044022029c0fb80d6e524f811f30cc04a349fa7f8896ce1ba84010da55f7be5eb9d528802202727985361cab969ad9b4f56570f3f6120c1d77d04ba10e5d99366d8eecee8e2",
+    "hex"
+  ),
+  curve: "secp256k1",
+  needsKYC: true,
+  needsBearerToken: true,
+};
+
+const swapProviders: Record<string, SwapProviderConfig> = {
   changelly: {
     nameAndPubkey: Buffer.from(
       "094368616e67656c6c790480d7c0d3a9183597395f58dda05999328da6f18fabd5cda0aff8e8e3fc633436a2dbf48ecb23d40df7c3c7d3e774b77b4b5df0e9f7e08cf1cdf2dba788eb085b",
@@ -51,6 +66,7 @@ const swapProviders: Record<
     ),
     curve: "secpk256k1",
     needsKYC: false,
+    needsBearerToken: false,
   },
   wyre: {
     nameAndPubkey: Buffer.from(
@@ -63,12 +79,13 @@ const swapProviders: Record<
     ),
     curve: "secpk256k1",
     needsKYC: true,
+    needsBearerToken: false,
   },
+  ftx,
+  ftxus: ftx,
 };
 
-const getProviderNameAndSignature = (
-  providerName: string
-): ExchangeProviderNameAndSignature => {
+const getProviderConfig = (providerName: string): SwapProviderConfig => {
   const res = swapProviders[providerName.toLowerCase()];
 
   if (!res) {
@@ -78,6 +95,8 @@ const getProviderNameAndSignature = (
   return res;
 };
 
+export const getAvailableProviders = (): string[] => Object.keys(swapProviders);
+
 const USStates = {
   AL: "Alabama",
   AK: "Alaska",
@@ -160,14 +179,16 @@ export const getSwapAPIError = (errorCode: number, errorMessage?: string) => {
 
 export {
   getSwapAPIBaseURL,
-  getProviderNameAndSignature,
+  getProviderConfig,
   getProviders,
-  getStatus,
   getExchangeRates,
   getCompleteSwapHistory,
+  postSwapAccepted,
+  postSwapCancelled,
   initSwap,
   getKYCStatus,
   submitKYC,
+  checkQuote,
   USStates,
   countries,
 };

package/src/exchange/swap/initSwap.ts

@@ -1,29 +1,30 @@
 import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+import { TransportStatusError, WrongDeviceForAccount } from "@ledgerhq/errors";
 import { log } from "@ledgerhq/logs";
-import { from } from "rxjs";
-import secp256k1 from "secp256k1";
+import { BigNumber } from "bignumber.js";
 import invariant from "invariant";
-import { TransportStatusError, WrongDeviceForAccount } from "@ledgerhq/errors";
-import { delay } from "../../promise";
-import Exchange from "../hw-app-exchange/Exchange";
-import { mockInitSwap } from "./mock";
-import perFamily from "../../generated/exchange";
+import { from, Observable } from "rxjs";
+import secp256k1 from "secp256k1";
+import { getCurrencyExchangeConfig } from "../";
 import {
   getAccountCurrency,
-  getMainAccount,
   getAccountUnit,
+  getMainAccount,
 } from "../../account";
-import network from "../../network";
 import { getAccountBridge } from "../../bridge";
-import { BigNumber } from "bignumber.js";
+import { getEnv } from "../../env";
 import { SwapGenericAPIError, TransactionRefusedOnDevice } from "../../errors";
-import type { SwapRequestEvent, InitSwapInput } from "./types";
-import { Observable } from "rxjs";
+import perFamily from "../../generated/exchange";
 import { withDevice } from "../../hw/deviceAccess";
-import { getProviderNameAndSignature, getSwapAPIBaseURL } from "./";
-import { getCurrencyExchangeConfig } from "../";
-import { getEnv } from "../../env";
-import { RateTypes, ExchangeTypes } from "../hw-app-exchange/Exchange";
+import network from "../../network";
+import { delay } from "../../promise";
+import Exchange, {
+  ExchangeTypes,
+  RateTypes,
+} from "../hw-app-exchange/Exchange";
+import { getProviderConfig, getSwapAPIBaseURL } from "./";
+import { mockInitSwap } from "./mock";
+import type { InitSwapInput, SwapRequestEvent } from "./types";
 
 const withDevicePromise = (deviceId, fn) =>
   withDevice(deviceId)((transport) => from(fn(transport))).toPromise();
@@ -32,14 +33,15 @@ const withDevicePromise = (deviceId, fn) =>
 // throw if TransactionStatus have errors
 // you get at the end a final Transaction to be done (it's not yet signed, nor broadcasted!) and a swapId
 const initSwap = (input: InitSwapInput): Observable<SwapRequestEvent> => {
+  let swapId;
   let { transaction } = input;
   const { exchange, exchangeRate, deviceId, userId } = input;
+
   if (getEnv("MOCK")) return mockInitSwap(exchange, exchangeRate, transaction);
   return new Observable((o) => {
     let unsubscribed = false;
 
     const confirmSwap = async () => {
-      let swapId;
       let ignoreTransportError;
       log("swap", `attempt to connect to ${deviceId}`);
       await withDevicePromise(deviceId, async (transport) => {
@@ -70,34 +72,45 @@ const initSwap = (input: InitSwapInput): Observable<SwapRequestEvent> => {
         // NB Added the try/catch because of the API stability issues.
         let res;
 
+        const swapProviderConfig = getProviderConfig(provider);
+
+        const { needsBearerToken } = swapProviderConfig;
+
+        const headers = {
+          EquipmentId: getEnv("USER_ID"),
+          ...(needsBearerToken ? { Authorization: `Bearer ${userId}` } : {}),
+          ...(userId ? { userId } : {}), // NB: only for Wyre AFAIK
+        };
+
+        const data = {
+          provider,
+          amountFrom: apiAmount.toString(),
+          from: refundCurrency.id,
+          to: payoutCurrency.id,
+          address: payoutAccount.freshAddress,
+          refundAddress: refundAccount.freshAddress,
+          deviceTransactionId,
+          ...(rateId && ratesFlag === RateTypes.Fixed
+            ? {
+                rateId,
+              }
+            : {}), // NB float rates dont need rate ids.
+        };
+
         try {
           res = await network({
             method: "POST",
             url: `${getSwapAPIBaseURL()}/swap`,
-            headers: {
-              EquipmentId: getEnv("USER_ID"),
-              ...(userId ? { userId } : {}),
-            },
-            data: {
-              provider,
-              amountFrom: apiAmount,
-              from: refundCurrency.id,
-              to: payoutCurrency.id,
-              address: payoutAccount.freshAddress,
-              refundAddress: refundAccount.freshAddress,
-              deviceTransactionId,
-              ...(rateId
-                ? {
-                    rateId,
-                  }
-                : {}), // NB float rates dont need rate ids.
-            },
+            headers,
+            data,
           });
+
           if (unsubscribed || !res || !res.data) return;
         } catch (e) {
           o.next({
             type: "init-swap-error",
             error: new SwapGenericAPIError(),
+            swapId,
           });
           o.complete();
           return;
@@ -105,9 +118,7 @@ const initSwap = (input: InitSwapInput): Observable<SwapRequestEvent> => {
 
         const swapResult = res.data;
         swapId = swapResult.swapId;
-        const providerNameAndSignature = getProviderNameAndSignature(
-          swapResult.provider
-        );
+
         const accountBridge = getAccountBridge(refundAccount);
         transaction = accountBridge.updateTransaction(transaction, {
           recipient: swapResult.payinAddress,
@@ -157,10 +168,12 @@ const initSwap = (input: InitSwapInput): Observable<SwapRequestEvent> => {
         }
 
         // Prepare swap app to receive the tx to forward.
-        await swap.setPartnerKey(providerNameAndSignature.nameAndPubkey);
+        await swap.setPartnerKey(swapProviderConfig.nameAndPubkey);
         if (unsubscribed) return;
-        await swap.checkPartner(providerNameAndSignature.signature);
+
+        await swap.checkPartner(swapProviderConfig.signature);
         if (unsubscribed) return;
+
         await swap.processTransaction(
           Buffer.from(swapResult.binaryPayload, "hex"),
           estimatedFees
@@ -304,6 +317,7 @@ const initSwap = (input: InitSwapInput): Observable<SwapRequestEvent> => {
         o.next({
           type: "init-swap-error",
           error: e,
+          swapId,
         });
         o.complete();
         unsubscribed = true;

package/src/exchange/swap/mock.ts

@@ -1,25 +1,29 @@
 import { BigNumber } from "bignumber.js";
+import { Observable, of } from "rxjs";
+import { getAccountUnit } from "../../account";
+import { formatCurrencyUnit } from "../../currencies";
+import { getEnv } from "../../env";
+import {
+  SwapExchangeRateAmountTooHigh,
+  SwapExchangeRateAmountTooLow,
+} from "../../errors";
+import type { CryptoCurrency, TokenCurrency, Transaction } from "../../types";
+import { getSwapAPIBaseURL } from "./";
 import type {
+  CheckQuote,
   Exchange,
   ExchangeRate,
   GetMultipleStatus,
   GetProviders,
   KYCStatus,
+  PostSwapAccepted,
+  PostSwapCancelled,
   SwapRequestEvent,
   ValidKYCStatus,
 } from "./types";
-import { getAccountUnit } from "../../account";
-import type { Transaction, TokenCurrency, CryptoCurrency } from "../../types";
-import { formatCurrencyUnit } from "../../currencies";
-import {
-  SwapExchangeRateAmountTooLow,
-  SwapExchangeRateAmountTooHigh,
-} from "../../errors";
-import { Observable, of } from "rxjs";
-import { getSwapAPIBaseURL } from "./";
 
 export const getMockExchangeRate = ({
-  provider = "changelly",
+  provider = "ftx",
   tradeMethod = "fixed",
 }: {
   provider?: string;
@@ -90,7 +94,7 @@ export const mockGetExchangeRates = async (
       toAmount: amount.times(magnitudeAwareRate),
       magnitudeAwareRate,
       rateId: "mockedRateId",
-      provider: "changelly",
+      provider: "ftx",
       expirationDate: new Date(),
       tradeMethod: "fixed",
     },
@@ -99,7 +103,7 @@ export const mockGetExchangeRates = async (
       toAmount: amount.times(magnitudeAwareRate),
       magnitudeAwareRate,
       rateId: "mockedRateId",
-      provider: "changelly",
+      provider: "ftx",
       expirationDate: new Date(),
       tradeMethod: "float",
     },
@@ -126,7 +130,7 @@ export const mockGetProviders: GetProviders = async () => {
   return usesV3
     ? [
         {
-          provider: "changelly",
+          provider: "ftx",
           pairs: [
             { from: "bitcoin", to: "ethereum", tradeMethod: "float" },
             { from: "bitcoin", to: "ethereum", tradeMethod: "fixed" },
@@ -187,3 +191,114 @@ export const mockGetKYCStatus = async (
   await new Promise((r) => setTimeout(r, 2000));
   return { id, status };
 };
+
+const mockedCheckQuoteStatusCode = getEnv("MOCK_SWAP_CHECK_QUOTE");
+
+export const mockCheckQuote: CheckQuote = async ({
+  provider: _provider,
+  quoteId: _quoteId,
+  bearerToken: _bearerToken,
+}) => {
+  //Fake delay to show the pending state in the UI
+  await new Promise((r) => setTimeout(r, 2000));
+
+  switch (mockedCheckQuoteStatusCode) {
+    case "RATE_VALID":
+      return { codeName: mockedCheckQuoteStatusCode };
+
+    case "KYC_FAILED":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "KYC Failed",
+        description: "The KYC verification failed",
+      };
+
+    case "KYC_PENDING":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "KYC Pending",
+        description: "The KYC is pending",
+      };
+
+    case "KYC_UNDEFINED":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "KYC undifined",
+        description: "The KYC is undifined",
+      };
+
+    case "KYC_UPGRADE_REQUIRED":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "KYC upgrade requierd",
+        description: "Need to upgrade KYC level",
+      };
+
+    case "MFA_REQUIRED":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "MFA requierd",
+        description: "Need to enable MFA",
+      };
+
+    case "OVER_TRADE_LIMIT":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "Trade over the limit",
+        description: "You have reached your trade limit",
+      };
+
+    case "UNKNOW_USER":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "Unknown user",
+        description: "Provided bearerToken does not match any known user",
+      };
+
+    case "RATE_NOT_FOUND":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "Rate not found",
+        description: "Rate not found",
+      };
+
+    case "WITHDRAWALS_BLOCKED":
+      return {
+        codeName: mockedCheckQuoteStatusCode,
+        error: "Withdrawals blocked",
+        description: "Withdrawals blocked",
+      };
+
+    default:
+      return {
+        codeName: "UNKNOWN_ERROR",
+        error: "Unknown error",
+        description: "Something unexpected happened",
+      };
+  }
+};
+
+export const mockPostSwapAccepted: PostSwapAccepted = async ({
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  provider,
+  swapId,
+  transactionId,
+  /* eslint-enable */
+}) => {
+  //Fake delay to simulate network
+  await new Promise((r) => setTimeout(r, 800));
+
+  return null;
+};
+
+export const mockPostSwapCancelled: PostSwapCancelled = async ({
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  provider,
+  swapId,
+  /* eslint-enable */
+}) => {
+  //Fake delay to simulate network
+  await new Promise((r) => setTimeout(r, 800));
+
+  return null;
+};