@ledgerhq/live-common 34.54.0 → 34.54.1

package/src/wallet-api/Exchange/server.ts

@@ -53,6 +53,12 @@ import { getSwapStepFromError } from "../../exchange/error";
 import { postSwapCancelled } from "../../exchange/swap";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 import { setBroadcastTransaction } from "../../exchange/swap/setBroadcastTransaction";
+import { Transaction as EvmTransaction } from "@ledgerhq/coin-evm/types/index";
+import { padHexString } from "@ledgerhq/hw-app-eth";
+import { createStepError, StepError, toError } from "./parser";
+import { handleErrors } from "./handleSwapErrors";
+import get from "lodash/get";
+import { SwapError } from "./SwapError";
 
 export { ExchangeType };
 
@@ -374,237 +380,288 @@ export const handlers = ({
       );
     }),
     "custom.exchange.swap": customWrapper<ExchangeSwapParams, SwapResult>(async params => {
-      if (!params) {
-        tracking.startExchangeNoParams(manifest);
-        throw new ServerError(createUnknownError({ message: "params is undefined" }));
-      }
+      try {
+        if (!params) {
+          tracking.startExchangeNoParams(manifest);
+          throw new ServerError(createUnknownError({ message: "params is undefined" }));
+        }
 
-      const {
-        provider,
-        fromAmount,
-        fromAmountAtomic,
-        quoteId,
-        toNewTokenId,
-        customFeeConfig,
-        swapAppVersion,
-        sponsored,
-      } = params;
-
-      const trackingParams = {
-        provider: params.provider,
-        exchangeType: params.exchangeType,
-      };
-
-      tracking.startExchangeRequested(trackingParams);
-
-      const exchangeStartParams: ExchangeStartParamsUiRequest = (await extractSwapStartParam(
-        params,
-        accounts,
-      )) as SwapStartParamsUiRequest;
-
-      const {
-        fromCurrency,
-        fromAccount,
-        fromParentAccount,
-        toCurrency,
-        toAccount,
-        toParentAccount,
-      } = exchangeStartParams.exchange;
-
-      if (!fromAccount || !fromCurrency) {
-        throw new ServerError(createAccountNotFound(params.fromAccountId));
-      }
+        const {
+          provider,
+          fromAmount,
+          fromAmountAtomic,
+          quoteId,
+          toNewTokenId,
+          customFeeConfig,
+          swapAppVersion,
+          sponsored,
+          isEmbedded,
+        } = params;
 
-      const fromAccountAddress = fromParentAccount
-        ? fromParentAccount.freshAddress
-        : (fromAccount as Account).freshAddress;
-
-      const toAccountAddress = toParentAccount
-        ? toParentAccount.freshAddress
-        : (toAccount as Account).freshAddress;
-
-      // Step 1: Open the drawer and open exchange app
-      const startExchange = async () => {
-        return new Promise<{ transactionId: string; device?: ExchangeStartResult["device"] }>(
-          (resolve, reject) => {
-            uiExchangeStart({
-              exchangeParams: exchangeStartParams,
-              onSuccess: (nonce, device) => {
-                tracking.startExchangeSuccess(trackingParams);
-                resolve({ transactionId: nonce, device });
-              },
-              onCancel: error => {
-                tracking.startExchangeFail(trackingParams);
-                reject(error);
-              },
-            });
-          },
-        );
-      };
-
-      const { transactionId, device: deviceInfo } = await startExchange();
-
-      const {
-        binaryPayload,
-        signature,
-        payinAddress,
-        swapId,
-        payinExtraId,
-        extraTransactionParameters,
-      } = await retrieveSwapPayload({
-        provider,
-        deviceTransactionId: transactionId,
-        fromAccountAddress,
-        toAccountAddress,
-        fromAccountCurrency: fromCurrency!.id,
-        toAccountCurrency: toCurrency!.id,
-        amount: fromAmount,
-        amountInAtomicUnit: fromAmountAtomic,
-        quoteId,
-        toNewTokenId,
-      }).catch((error: Error) => {
-        throw error;
-      });
-
-      // Complete Swap
-      const trackingCompleteParams = {
-        provider: params.provider,
-        exchangeType: params.exchangeType,
-      };
-      tracking.completeExchangeRequested(trackingCompleteParams);
-
-      const strategyData = {
-        recipient: payinAddress,
-        amount: fromAmountAtomic,
-        currency: fromCurrency as CryptoOrTokenCurrency,
-        customFeeConfig: customFeeConfig ?? {},
-        payinExtraId,
-        extraTransactionParameters,
-        sponsored,
-      };
-
-      const transaction: Transaction = await getStrategy(strategyData, "swap").catch(
-        async error => {
-          throw error;
-        },
-      );
+        const trackingParams = {
+          provider: params.provider,
+          exchangeType: params.exchangeType,
+          isEmbeddedSwap: isEmbedded,
+        };
 
-      const mainFromAccount = getMainAccount(fromAccount, fromParentAccount);
+        tracking.startExchangeRequested(trackingParams);
 
-      if (transaction.family !== mainFromAccount.currency.family) {
-        return Promise.reject(
-          new Error(
-            `Account and transaction must be from the same family. Account family: ${mainFromAccount.currency.family}, Transaction family: ${transaction.family}`,
-          ),
-        );
-      }
+        const exchangeStartParams: ExchangeStartParamsUiRequest = (await extractSwapStartParam(
+          params,
+          accounts,
+        )) as SwapStartParamsUiRequest;
+
+        const {
+          fromCurrency,
+          fromAccount,
+          fromParentAccount,
+          toCurrency,
+          toAccount,
+          toParentAccount,
+        } = exchangeStartParams.exchange;
+
+        if (!fromAccount || !fromCurrency) {
+          throw new ServerError(createAccountNotFound(params.fromAccountId));
+        }
 
-      const accountBridge = getAccountBridge(fromAccount, fromParentAccount);
-
-      /**
-       * 'subAccountId' is used for ETH and it's ERC-20 tokens.
-       * This field is ignored for BTC
-       */
-      const subAccountId =
-        fromParentAccount && fromParentAccount.id !== fromAccount.id ? fromAccount.id : undefined;
-
-      const bridgeTx = accountBridge.createTransaction(fromAccount);
-      /**
-       * We append the `recipient` to the tx created from `createTransaction`
-       * to avoid having userGasLimit reset to null for ETH txs
-       * cf. libs/ledger-live-common/src/families/ethereum/updateTransaction.ts
-       */
-      const tx = accountBridge.updateTransaction(
-        {
-          ...bridgeTx,
-          recipient: transaction.recipient,
-        },
-        {
-          ...transaction,
-          feesStrategy: params.feeStrategy.toLowerCase(),
-          subAccountId,
-        },
-      );
+        const fromAccountAddress = fromParentAccount
+          ? fromParentAccount.freshAddress
+          : (fromAccount as Account).freshAddress;
+
+        const toAccountAddress = toParentAccount
+          ? toParentAccount.freshAddress
+          : (toAccount as Account).freshAddress;
+
+        // Step 1: Open the drawer and open exchange app
+        const startExchange = async () => {
+          return new Promise<{ transactionId: string; device?: ExchangeStartResult["device"] }>(
+            (resolve, reject) => {
+              uiExchangeStart({
+                exchangeParams: exchangeStartParams,
+                onSuccess: (nonce, device) => {
+                  tracking.startExchangeSuccess(trackingParams);
+                  resolve({ transactionId: nonce, device });
+                },
+                onCancel: error => {
+                  tracking.startExchangeFail(trackingParams);
+                  reject(error);
+                },
+              });
+            },
+          );
+        };
 
-      // Get amountExpectedTo and magnitudeAwareRate from binary payload
-      const decodePayload = await decodeSwapPayload(binaryPayload);
-      const amountExpectedTo = new BigNumber(decodePayload.amountToWallet.toString());
-      const magnitudeAwareRate = tx.amount && amountExpectedTo.dividedBy(tx.amount);
-      const refundAddress = decodePayload.refundAddress;
-      const payoutAddress = decodePayload.payoutAddress;
+        let transactionId: string;
+        let deviceInfo: ExchangeStartResult["device"];
+
+        try {
+          const result = await startExchange();
+          transactionId = result.transactionId;
+          deviceInfo = result.device;
+        } catch (error) {
+          const rawError = get(error, "response.data.error", error);
+          const wrappedError = createStepError({
+            error: toError(rawError),
+            step: StepError.NONCE,
+          });
+          throw wrappedError;
+        }
 
-      // tx.amount should be BigNumber
-      tx.amount = new BigNumber(tx.amount);
+        const {
+          binaryPayload,
+          signature,
+          payinAddress,
+          swapId,
+          payinExtraId,
+          extraTransactionParameters,
+        } = await retrieveSwapPayload({
+          provider,
+          deviceTransactionId: transactionId,
+          fromAccountAddress,
+          toAccountAddress,
+          fromAccountCurrency: fromCurrency!.id,
+          toAccountCurrency: toCurrency!.id,
+          amount: fromAmount,
+          amountInAtomicUnit: fromAmountAtomic,
+          quoteId,
+          toNewTokenId,
+        }).catch((error: Error) => {
+          const wrappedError = createStepError({
+            error: get(error, "response.data.error", error),
+            step: StepError.PAYLOAD,
+          });
+
+          throw wrappedError;
+        });
 
-      return new Promise((resolve, reject) =>
-        uiSwap({
-          exchangeParams: {
-            exchangeType: ExchangeType.SWAP,
-            provider: params.provider,
-            transaction: tx,
-            signature: signature,
-            binaryPayload: binaryPayload,
-            exchange: {
-              fromAccount,
-              fromParentAccount,
-              toAccount,
-              toParentAccount,
-              fromCurrency: fromCurrency!,
-              toCurrency: toCurrency!,
-            },
-            feesStrategy: params.feeStrategy,
-            swapId: swapId,
-            amountExpectedTo: amountExpectedTo.toNumber(),
-            magnitudeAwareRate,
-            refundAddress,
-            payoutAddress,
-            sponsored,
-          },
-          onSuccess: ({ operationHash, swapId }: { operationHash: string; swapId: string }) => {
-            tracking.completeExchangeSuccess({
-              ...trackingParams,
-              currency: transaction.family,
-            });
+        // Complete Swap
+        const trackingCompleteParams = {
+          provider: params.provider,
+          exchangeType: params.exchangeType,
+          isEmbeddedSwap: isEmbedded,
+        };
+        tracking.completeExchangeRequested(trackingCompleteParams);
+
+        const strategyData = {
+          recipient: payinAddress,
+          amount: fromAmountAtomic,
+          currency: fromCurrency as CryptoOrTokenCurrency,
+          customFeeConfig: customFeeConfig ?? {},
+          payinExtraId,
+          extraTransactionParameters,
+          sponsored,
+        };
 
-            setBroadcastTransaction({
-              provider,
-              result: { operation: operationHash, swapId },
-              sourceCurrencyId: fromCurrency.id,
-              targetCurrencyId: toCurrency?.id,
-              hardwareWalletType: deviceInfo?.modelId as DeviceModelId,
-              swapAppVersion,
-              fromAccountAddress,
-              toAccountAddress,
-              fromAmount,
-            });
+        const transaction: Transaction = await getStrategy(strategyData, "swap");
+
+        const mainFromAccount = getMainAccount(fromAccount, fromParentAccount);
+
+        if (transaction.family !== mainFromAccount.currency.family) {
+          return Promise.reject(
+            new Error(
+              `Account and transaction must be from the same family. Account family: ${mainFromAccount.currency.family}, Transaction family: ${transaction.family}`,
+            ),
+          );
+        }
+
+        const accountBridge = getAccountBridge(fromAccount, fromParentAccount);
+
+        /**
+         * 'subAccountId' is used for ETH and it's ERC-20 tokens.
+         * This field is ignored for BTC
+         */
+        const subAccountId =
+          fromParentAccount && fromParentAccount.id !== fromAccount.id ? fromAccount.id : undefined;
 
-            resolve({ operationHash, swapId });
+        const bridgeTx = accountBridge.createTransaction(fromAccount);
+        /**
+         * We append the `recipient` to the tx created from `createTransaction`
+         * to avoid having userGasLimit reset to null for ETH txs
+         * cf. libs/ledger-live-common/src/families/ethereum/updateTransaction.ts
+         */
+        const tx = accountBridge.updateTransaction(
+          {
+            ...bridgeTx,
+            recipient: transaction.recipient,
           },
-          onCancel: error => {
-            postSwapCancelled({
-              provider: provider,
+          {
+            ...transaction,
+            feesStrategy: params.feeStrategy.toLowerCase(),
+            subAccountId,
+          },
+        );
+
+        // Get amountExpectedTo and magnitudeAwareRate from binary payload
+        const decodePayload = await decodeSwapPayload(binaryPayload);
+        const amountExpectedTo = new BigNumber(decodePayload.amountToWallet.toString());
+        const magnitudeAwareRate = tx.amount && amountExpectedTo.dividedBy(tx.amount);
+        const refundAddress = decodePayload.refundAddress;
+        const payoutAddress = decodePayload.payoutAddress;
+
+        // tx.amount should be BigNumber
+        tx.amount = new BigNumber(tx.amount);
+
+        return new Promise((resolve, reject) =>
+          uiSwap({
+            exchangeParams: {
+              exchangeType: ExchangeType.SWAP,
+              provider: params.provider,
+              transaction: tx,
+              signature: signature,
+              binaryPayload: binaryPayload,
+              exchange: {
+                fromAccount,
+                fromParentAccount,
+                toAccount,
+                toParentAccount,
+                fromCurrency: fromCurrency!,
+                toCurrency: toCurrency!,
+              },
+              feesStrategy: params.feeStrategy,
               swapId: swapId,
-              swapStep: getSwapStepFromError(error),
-              statusCode: error.name,
-              errorMessage: error.message,
-              sourceCurrencyId: fromCurrency.id,
-              targetCurrencyId: toCurrency?.id,
-              hardwareWalletType: deviceInfo?.modelId as DeviceModelId,
-              swapType: quoteId ? "fixed" : "float",
-              swapAppVersion,
-              fromAccountAddress,
-              toAccountAddress,
+              amountExpectedTo: amountExpectedTo.toNumber(),
+              magnitudeAwareRate,
               refundAddress,
               payoutAddress,
-              fromAmount,
-              seedIdFrom: mainFromAccount.seedIdentifier,
-              seedIdTo: toParentAccount?.seedIdentifier || (toAccount as Account)?.seedIdentifier,
+              sponsored,
+            },
+            onSuccess: ({ operationHash, swapId }: { operationHash: string; swapId: string }) => {
+              tracking.completeExchangeSuccess({
+                ...trackingParams,
+                currency: transaction.family,
+              });
+
+              setBroadcastTransaction({
+                provider,
+                result: { operation: operationHash, swapId },
+                sourceCurrencyId: fromCurrency.id,
+                targetCurrencyId: toCurrency?.id,
+                hardwareWalletType: deviceInfo?.modelId as DeviceModelId,
+                swapAppVersion,
+                fromAccountAddress,
+                toAccountAddress,
+                fromAmount,
+              });
+
+              resolve({ operationHash, swapId });
+            },
+            onCancel: error => {
+              postSwapCancelled({
+                provider: provider,
+                swapId: swapId,
+                swapStep: getSwapStepFromError(error),
+                statusCode: error.name,
+                errorMessage: error.message,
+                sourceCurrencyId: fromCurrency.id,
+                targetCurrencyId: toCurrency?.id,
+                hardwareWalletType: deviceInfo?.modelId as DeviceModelId,
+                swapType: quoteId ? "fixed" : "float",
+                swapAppVersion,
+                fromAccountAddress,
+                toAccountAddress,
+                refundAddress,
+                payoutAddress,
+                fromAmount,
+                seedIdFrom: mainFromAccount.seedIdentifier,
+                seedIdTo: toParentAccount?.seedIdentifier || (toAccount as Account)?.seedIdentifier,
+                data: (transaction as EvmTransaction).data
+                  ? `0x${padHexString((transaction as EvmTransaction).data?.toString("hex") || "")}`
+                  : "0x",
+              });
+
+              reject(createStepError({ error, step: StepError.SIGNATURE }));
+            },
+          }),
+        );
+      } catch (error) {
+        // Skip DrawerClosedError
+        // do not redirect to the error screen
+        if (isDrawerClosedError(error)) {
+          throw error;
+        }
+
+        // Global catch for any errors during the swap process
+        // moved out as sonarcloud suggested to avoid 4 level nested functions
+        const createErrorRejector = (error: SwapError, reject: (error: SwapError) => void) => {
+          return () => reject(error);
+        };
+
+        const displayError = (error: SwapError): Promise<void> =>
+          new Promise((resolve, reject) => {
+            const rejectWithError = createErrorRejector(error, reject);
+            uiError({
+              error,
+              onSuccess: rejectWithError,
+              onCancel: rejectWithError,
             });
+          });
 
-            reject(error);
-          },
-        }),
-      );
+        await handleErrors(error, {
+          onDisplayError: displayError,
+        });
+
+        throw error;
+      }
     }),
 
     "custom.isReady": customWrapper<void, void>(async () => {
@@ -826,21 +883,21 @@ async function getStrategy(
     }
   }
 
-  try {
-    return await strategy({
-      family,
-      amount: new BigNumber(amount),
-      recipient,
-      customFeeConfig: convertedCustomFeeConfig,
-      payinExtraId,
-      extraTransactionParameters,
-      customErrorType,
-      sponsored,
-    });
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to execute transaction strategy for family: ${family}. Reason: ${errorMessage}`,
-    );
-  }
+  return strategy({
+    family,
+    amount: new BigNumber(amount),
+    recipient,
+    customFeeConfig: convertedCustomFeeConfig,
+    payinExtraId,
+    extraTransactionParameters,
+    customErrorType,
+    sponsored,
+  });
+}
+
+function isDrawerClosedError(error: unknown) {
+  if (!error || typeof error !== "object") return false;
+  return (
+    get(error, "name") === "DrawerClosedError" || get(error, "cause.name") === "DrawerClosedError"
+  );
 }

package/src/wallet-api/Exchange/tracking.ts

@@ -14,8 +14,15 @@ type TrackExchange = (
 interface TrackEventPayload {
   exchangeType: "SELL" | "FUND" | "SWAP";
   provider: string;
+  isEmbeddedSwap?: boolean;
 }
 
+/**
+ * Converts isEmbeddedSwap boolean to string for analytics consistency
+ */
+const formatIsEmbeddedSwap = (isEmbeddedSwap?: boolean): string | undefined =>
+  isEmbeddedSwap !== undefined ? String(isEmbeddedSwap) : undefined;
+
 function getEventData(manifest: AppManifest) {
   return { walletAPI: manifest.name };
 }
@@ -29,24 +36,46 @@ function getEventData(manifest: AppManifest) {
 // in order to get the exact type matching the tracking wrapper API
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export default function trackingWrapper(trackCall: TrackExchange) {
-  const track = (event: string, properties: Record<string, string> | null) => {
-    return trackCall(event, properties, null);
+  const track = (event: string, properties: Record<string, string | undefined> | null) => {
+    // Filter out undefined values before passing to trackCall
+    if (!properties) {
+      return trackCall(event, null, null);
+    }
+    const filteredProperties: Record<string, string> = {};
+    for (const [key, value] of Object.entries(properties)) {
+      if (value !== undefined) {
+        filteredProperties[key] = value;
+      }
+    }
+    return trackCall(event, filteredProperties, null);
   };
 
   return {
     // Generate Exchange nonce modal open
-    startExchangeRequested: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Starts Exchange ${exchangeType} Nonce request`, { provider, exchangeType });
+    startExchangeRequested: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Starts Exchange ${exchangeType} Nonce request`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // Successfully generated an Exchange app nonce
-    startExchangeSuccess: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Starts Exchange ${exchangeType} Nonce success`, { provider, exchangeType });
+    startExchangeSuccess: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Starts Exchange ${exchangeType} Nonce success`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // Failed to generate an Exchange app nonce
-    startExchangeFail: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Starts Exchange ${exchangeType} Nonce fail`, { provider, exchangeType });
+    startExchangeFail: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Starts Exchange ${exchangeType} Nonce fail`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // No Params to generate an Exchange app nonce
@@ -54,8 +83,12 @@ export default function trackingWrapper(trackCall: TrackExchange) {
       track("Starts Exchange no params", getEventData(manifest));
     },
 
-    completeExchangeRequested: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Completes Exchange ${exchangeType} requested`, { provider, exchangeType });
+    completeExchangeRequested: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Completes Exchange ${exchangeType} requested`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // Successfully completed an Exchange
@@ -63,13 +96,23 @@ export default function trackingWrapper(trackCall: TrackExchange) {
       provider,
       exchangeType,
       currency,
+      isEmbeddedSwap,
     }: TrackEventPayload & { currency: string }) => {
-      track(`Completes Exchange ${exchangeType} success`, { provider, exchangeType, currency });
+      track(`Completes Exchange ${exchangeType} success`, {
+        provider,
+        exchangeType,
+        currency,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // Failed to complete an Exchange
-    completeExchangeFail: ({ provider, exchangeType }: TrackEventPayload) => {
-      track(`Completes Exchange ${exchangeType} Nonce fail`, { provider, exchangeType });
+    completeExchangeFail: ({ provider, exchangeType, isEmbeddedSwap }: TrackEventPayload) => {
+      track(`Completes Exchange ${exchangeType} Nonce fail`, {
+        provider,
+        exchangeType,
+        isEmbeddedSwap: formatIsEmbeddedSwap(isEmbeddedSwap),
+      });
     },
 
     // No Params to complete an Exchange