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

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;
+};

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,