@ledgerhq/live-common 34.54.0 → 34.55.0-nightly.20251210100832

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

@@ -0,0 +1,119 @@
+/**
+ * Error Parser
+ * Routes errors to appropriate error classes based on step and context
+ */
+
+import {
+  IgnoredSignatureStepError,
+  ListAccountError,
+  ListCurrencyError,
+  NonceStepError,
+  NotEnoughFunds,
+  PayinExtraIdError,
+  PayloadStepError,
+  SignatureStepError,
+  UnknownAccountError,
+} from "./SwapError";
+
+/**
+ * Transaction step where error occurred
+ */
+export enum StepError {
+  NONCE = "NonceStepError",
+  PAYLOAD = "PayloadStepError",
+  SIGNATURE = "SignatureStepError",
+  IGNORED_SIGNATURE = "IgnoredSignatureStepError",
+  CHECK_FUNDS = "CheckFundsStepError",
+  LIST_ACCOUNT = "ListAccountStepError",
+  LIST_CURRENCY = "ListCurrencyStepError",
+  UNKNOWN_ACCOUNT = "UnknownAccountStepError",
+  PAYIN_EXTRA_ID = "PayinExtraIdStepError",
+}
+
+/**
+ * Input for error parsing
+ */
+export enum CustomErrorType {
+  SWAP = "swap",
+}
+
+export type ParseError = {
+  error: Error;
+  step?: StepError;
+  customErrorType?: CustomErrorType;
+};
+
+/**
+ * Maps step errors to error constructors
+ */
+const ErrorMap: Record<StepError, new (err?: Error) => Error> = {
+  [StepError.NONCE]: NonceStepError,
+  [StepError.PAYLOAD]: PayloadStepError,
+  [StepError.SIGNATURE]: SignatureStepError,
+  [StepError.IGNORED_SIGNATURE]: IgnoredSignatureStepError,
+  [StepError.CHECK_FUNDS]: NotEnoughFunds,
+  [StepError.LIST_ACCOUNT]: ListAccountError,
+  [StepError.LIST_CURRENCY]: ListCurrencyError,
+  [StepError.UNKNOWN_ACCOUNT]: UnknownAccountError,
+  [StepError.PAYIN_EXTRA_ID]: PayinExtraIdError,
+};
+
+/**
+ * Creates a step-specific error by wrapping the original error
+ *
+ * @param error - Original error that occurred
+ * @param step - Step where error occurred (optional)
+ * @returns Wrapped error or original error if no step specified
+ */
+export function createStepError({ error, step }: ParseError): Error {
+  // If no step specified, return original error
+  if (!step) {
+    return error;
+  }
+
+  // Get error constructor for this step
+  const ErrorConstructor = ErrorMap[step];
+
+  if (!ErrorConstructor) {
+    return error;
+  }
+
+  // Wrap original error in step-specific error class
+  return new ErrorConstructor(error);
+}
+
+/**
+ * Parses an error to determine the correct error class to return based on the context.
+ */
+export function parseError({ error, step, customErrorType }: ParseError): Error {
+  if (!step || customErrorType !== CustomErrorType.SWAP) {
+    return error;
+  }
+
+  return createStepError({ error, step });
+}
+
+export const hasMessage = (value: unknown): value is { message?: unknown } =>
+  Boolean(value && typeof value === "object" && "message" in value);
+
+export const toError = (value: unknown): Error => {
+  if (value instanceof Error) {
+    return value;
+  }
+
+  if (hasMessage(value) && typeof value.message === "string") {
+    return new Error(value.message);
+  }
+
+  return new Error(
+    typeof value === "string"
+      ? value
+      : (() => {
+          try {
+            return JSON.stringify(value);
+          } catch {
+            return String(value);
+          }
+        })(),
+  );
+};

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