@ledgerhq/live-common 34.40.0-nightly.1 → 34.40.0-nightly.2

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

@@ -1,48 +1,58 @@
 /* eslint-disable no-console */
-import { RPCHandler, customWrapper } from "@ledgerhq/wallet-api-server";
+import {
+  getMainAccount,
+  getParentAccount,
+  makeEmptyTokenAccount,
+} from "@ledgerhq/coin-framework/account/index";
+import { findTokenById, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
+import { decodeSwapPayload } from "@ledgerhq/hw-app-exchange";
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { Account, AccountLike, getCurrencyForAccount, TokenAccount } from "@ledgerhq/types-live";
 import {
   createAccountNotFound,
   createCurrencyNotFound,
+  createUnknownError,
   deserializeTransaction,
   ServerError,
 } from "@ledgerhq/wallet-api-core";
-import {
-  getParentAccount,
-  getMainAccount,
-  makeEmptyTokenAccount,
-} from "@ledgerhq/coin-framework/account/index";
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { AccountLike, getCurrencyForAccount, TokenAccount } from "@ledgerhq/types-live";
-import { findTokenById, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
 import {
   ExchangeCompleteParams,
   ExchangeCompleteResult,
   ExchangeStartParams,
-  ExchangeStartSwapParams,
   ExchangeStartResult,
-  ExchangeType,
   ExchangeStartSellParams,
+  ExchangeStartSwapParams,
+  ExchangeSwapParams,
+  ExchangeType,
   SwapLiveError,
+  SwapResult,
 } from "@ledgerhq/wallet-api-exchange-module";
-import { decodeSwapPayload } from "@ledgerhq/hw-app-exchange";
-import { TrackingAPI } from "./tracking";
-import { AppManifest } from "../types";
+import { customWrapper, RPCHandler } from "@ledgerhq/wallet-api-server";
+import { BigNumber } from "bignumber.js";
+import { getAccountBridge } from "../../bridge";
+import { retrieveSwapPayload } from "../../exchange/swap/api/v5/actions";
+import { transactionStrategy } from "../../exchange/swap/transactionStrategies";
+import { ExchangeSwap } from "../../exchange/swap/types";
+import { Exchange } from "../../exchange/types";
+import { Transaction } from "../../generated/types";
 import {
   getAccountIdFromWalletAccountId,
   getWalletAPITransactionSignFlowInfos,
 } from "../converters";
-import { getAccountBridge } from "../../bridge";
-import { Exchange } from "../../exchange/types";
-import { Transaction } from "../../generated/types";
+import { AppManifest } from "../types";
 import {
-  ExchangeError,
   createAccounIdNotFound,
   createWrongSellParams,
   createWrongSwapParams,
+  ExchangeError,
 } from "./error";
+import { TrackingAPI } from "./tracking";
+import { getSwapStepFromError } from "../../exchange/error";
+import { postSwapCancelled } from "../../exchange/swap";
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import { setBroadcastTransaction } from "../../exchange/swap/setBroadcastTransaction";
 
 export { ExchangeType };
-import { BigNumber } from "bignumber.js";
 
 type Handlers = {
   "custom.exchange.start": RPCHandler<
@@ -52,6 +62,7 @@ type Handlers = {
   "custom.exchange.complete": RPCHandler<ExchangeCompleteResult, ExchangeCompleteParams>;
   "custom.exchange.error": RPCHandler<void, SwapLiveError>;
   "custom.isReady": RPCHandler<void, void>;
+  "custom.exchange.swap": RPCHandler<SwapResult, ExchangeSwapParams>;
 };
 
 export type CompleteExchangeUiRequest = {
@@ -68,21 +79,33 @@ export type CompleteExchangeUiRequest = {
   refundAddress?: string;
   payoutAddress?: string;
 };
+type FundStartParamsUiRequest = {
+  exchangeType: "FUND";
+};
+
+type SellStartParamsUiRequest = {
+  exchangeType: "SELL";
+  provider: string;
+  exchange: Partial<Exchange> | undefined;
+};
+
+type SwapStartParamsUiRequest = {
+  exchangeType: "SWAP";
+  provider: string;
+  exchange: Partial<ExchangeSwap>;
+};
 
 type ExchangeStartParamsUiRequest =
-  | {
-      exchangeType: "FUND";
-    }
-  | {
-      exchangeType: "SELL";
-      provider: string;
-      exchange: Partial<Exchange> | undefined;
-    }
-  | {
-      exchangeType: "SWAP";
-      provider: string;
-      exchange: Partial<Exchange>;
-    };
+  | FundStartParamsUiRequest
+  | SellStartParamsUiRequest
+  | SwapStartParamsUiRequest;
+
+export type SwapUiRequest = CompleteExchangeUiRequest & {
+  provider?: string;
+  fromAccountId?: string;
+  toAccountId?: string;
+  tokenCurrency?: string;
+};
 
 type ExchangeUiHooks = {
   "custom.exchange.start": (params: {
@@ -101,6 +124,11 @@ type ExchangeUiHooks = {
     onCancel: () => void;
   }) => void;
   "custom.isReady": (params: { onSuccess: () => void; onCancel: () => void }) => void;
+  "custom.exchange.swap": (params: {
+    exchangeParams: SwapUiRequest;
+    onSuccess: ({ operationHash, swapId }: { operationHash: string; swapId: string }) => void;
+    onCancel: (error: Error) => void;
+  }) => void;
 };
 
 export const handlers = ({
@@ -112,6 +140,7 @@ export const handlers = ({
     "custom.exchange.complete": uiExchangeComplete,
     "custom.exchange.error": uiError,
     "custom.isReady": uiIsReady,
+    "custom.exchange.swap": uiSwap,
   },
 }: {
   accounts: AccountLike[];
@@ -343,6 +372,219 @@ export const handlers = ({
         }),
       );
     }),
+    "custom.exchange.swap": customWrapper<ExchangeSwapParams, SwapResult>(async params => {
+      if (!params) {
+        tracking.startExchangeNoParams(manifest);
+        throw new ServerError(createUnknownError({ message: "params is undefined" }));
+      }
+
+      const { provider, fromAmount, fromAmountAtomic, quoteId, toNewTokenId, customFeeConfig } =
+        params;
+
+      const trackingParams = {
+        provider: params.provider,
+        exchangeType: params.exchangeType,
+      };
+
+      tracking.startExchangeRequested(trackingParams);
+
+      const exchangeStartParams: ExchangeStartParamsUiRequest = extractSwapStartParam(
+        params,
+        accounts,
+      ) as SwapStartParamsUiRequest;
+
+      const {
+        fromCurrency,
+        fromAccount,
+        fromParentAccount,
+        toCurrency,
+        toAccount,
+        toParentAccount,
+      } = exchangeStartParams.exchange;
+
+      if (!fromAccount || !fromCurrency) {
+        throw new ServerError(createAccountNotFound(params.fromAccountId));
+      }
+
+      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 () => {
+        console.log("LLD   custom.exchange.swap uiExchangeStart", exchangeStartParams);
+
+        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,
+      };
+
+      const transaction = await getStrategy(strategyData, "swap").catch(async error => {
+        throw error;
+      });
+
+      const mainFromAccount = getMainAccount(fromAccount, fromParentAccount);
+      const mainFromAccountFamily = mainFromAccount.currency.family;
+
+      if (transaction.family !== mainFromAccountFamily) {
+        return Promise.reject(
+          new Error(
+            `Account and transaction must be from the same family. Account family: ${mainFromAccountFamily}, 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;
+
+      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,
+        },
+      );
+
+      // 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,
+            amountExpectedTo: amountExpectedTo.toNumber(),
+            magnitudeAwareRate,
+            refundAddress,
+            payoutAddress,
+          },
+          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,
+            });
+
+            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",
+            });
+
+            reject(error);
+          },
+        }),
+      );
+    }),
+
     "custom.isReady": customWrapper<void, void>(async () => {
       return new Promise((resolve, reject) =>
         uiIsReady({
@@ -402,8 +644,10 @@ function extractSwapStartParam(
     exchange: {
       fromAccount,
       fromParentAccount,
+      fromCurrency: getCurrencyForAccount(fromAccount),
       toAccount: newTokenAccount ? newTokenAccount : toAccount,
       toParentAccount: newTokenAccount ? toAccount : toParentAccount,
+      toCurrency: getCurrencyForAccount(toAccount),
     },
   };
 }
@@ -468,3 +712,62 @@ async function getToCurrency(
 
   return newTokenAccount?.token ?? getCurrencyForAccount(toAccount);
 }
+
+interface StrategyParams {
+  recipient: string;
+  amount: BigNumber | number | string;
+  currency: CryptoOrTokenCurrency;
+  customFeeConfig?: Record<string, unknown>;
+  payinExtraId?: string;
+  extraTransactionParameters?: string;
+}
+
+async function getStrategy(
+  {
+    recipient,
+    amount,
+    currency,
+    customFeeConfig,
+    payinExtraId,
+    extraTransactionParameters,
+  }: StrategyParams,
+  customErrorType?: any,
+): Promise<Transaction> {
+  const family =
+    currency.type === "TokenCurrency"
+      ? (currency.parentCurrency?.family as Transaction["family"])
+      : (currency.family as Transaction["family"]);
+
+  if (!family) {
+    throw new Error(`TokenCurrency missing parentCurrency family: ${currency.id}`);
+  }
+
+  // Remove unsupported utxoStrategy for now
+  if (customFeeConfig?.utxoStrategy) {
+    delete customFeeConfig.utxoStrategy;
+  }
+
+  // Normalize family key for strategy lookup
+  const familyKey = family === "evm" ? "ethereum" : family;
+  const strategy = transactionStrategy?.[familyKey];
+
+  if (!strategy) {
+    throw new Error(`No transaction strategy found for family: ${familyKey}`);
+  }
+
+  try {
+    return await strategy({
+      family,
+      amount,
+      recipient,
+      customFeeConfig: customFeeConfig || {},
+      payinExtraId,
+      extraTransactionParameters,
+      customErrorType,
+    });
+  } catch (error) {
+    throw new Error(
+      `Failed to execute transaction strategy for family: ${familyKey}. Reason: ${(error as Error).message}`,
+    );
+  }
+}