@ledgerhq/live-common 21.5.1-btcjs.0 → 21.7.0

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

@@ -0,0 +1,224 @@
+import BigNumber from "bignumber.js";
+
+import { pickExchangeRate, getAccountTuplesForCurrency } from "./index";
+import { getMockExchangeRate } from "../mock";
+import { genAccount } from "../../../mock/account";
+import type {
+  Account,
+  CryptoCurrency,
+  SubAccount,
+  TokenCurrency,
+} from "../../../types";
+import { getCryptoCurrencyById } from "../../../currencies";
+import { getTokenById } from "@ledgerhq/cryptoassets/lib/tokens";
+
+describe("swap/utils/pickExchangeRate", () => {
+  test("calls the callback function with null when no exchange rates are passed", () => {
+    const setExchangeRate = jest.fn();
+    pickExchangeRate([], undefined, setExchangeRate);
+
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate).toHaveBeenCalledWith(null);
+  });
+
+  test("calls the callback function with null when no exchange rates are passed but there is an exchange rate", () => {
+    const setExchangeRate = jest.fn();
+    const exchangeRate = getMockExchangeRate({ provider: "wyre" });
+    pickExchangeRate([], exchangeRate, setExchangeRate);
+
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate).toHaveBeenCalledWith(null);
+  });
+
+  test("calls the callback function with the first exchange rate when the exchange passed isn't included in the list", () => {
+    const setExchangeRate = jest.fn();
+    const firstExchangeRate = getMockExchangeRate({
+      provider: "changelly",
+      tradeMethod: "fixed",
+    });
+    const exchangeRates = [
+      firstExchangeRate,
+      getMockExchangeRate({ provider: "changelly", tradeMethod: "float" }),
+    ];
+    const exchangeRate = getMockExchangeRate({ provider: "wyre" });
+
+    pickExchangeRate(exchangeRates, exchangeRate, setExchangeRate);
+
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate).toHaveBeenCalledWith(firstExchangeRate);
+  });
+
+  test("calls the callback function with the passed exchange rate when the exchange passed is included in the list", () => {
+    const setExchangeRate = jest.fn();
+    const exchangeRate = getMockExchangeRate({
+      provider: "changelly",
+      tradeMethod: "fixed",
+    });
+    const exchangeRates = [
+      getMockExchangeRate({ provider: "changelly", tradeMethod: "float" }),
+      exchangeRate,
+    ];
+
+    pickExchangeRate(exchangeRates, exchangeRate, setExchangeRate);
+
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate).toHaveBeenCalledWith(exchangeRate);
+  });
+});
+
+/* TODO: Refacto these two function and move them to mock/account.ts if needed */
+function* accountGenerator(currency: CryptoCurrency): Generator<Account> {
+  let id = 0;
+  while (true) {
+    id += 1;
+    yield genAccount(`mocked-account-${id}`, { currency, operationsSize: 0 });
+  }
+}
+const getAccountCreator = (currencyId: string) => {
+  const generator = accountGenerator(getCryptoCurrencyById(currencyId));
+  return () => generator.next().value;
+};
+
+describe("swap/utils/getAccountTuplesForCurrency", () => {
+  const getEthAccount = getAccountCreator("ethereum");
+  const getBtcAccount = getAccountCreator("bitcoin");
+  const getPolkadotAccount = getAccountCreator("polkadot");
+  const getCosmosAccount = getAccountCreator("cosmos");
+
+  describe("CryptoCurrency", () => {
+    test("returns all accounts associated to the CryptoCurrency", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const ethAccounts = [getEthAccount(), getEthAccount()];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        ethCurrency,
+        allAccounts,
+        false
+      );
+
+      expect(results).toHaveLength(2);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect(result.subAccount).toBeNull();
+      });
+    });
+
+    test("returns only associated accounts if they have a balance greater than 0 when the flag is passed", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const richEthAccounts = [
+        { ...getEthAccount(), balance: new BigNumber(10) },
+        { ...getEthAccount(), balance: new BigNumber(10) },
+      ];
+      const poorEthAccounts = { ...getEthAccount(), balance: new BigNumber(0) };
+
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...richEthAccounts,
+        poorEthAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        ethCurrency,
+        allAccounts,
+        true
+      );
+
+      expect(results).toHaveLength(richEthAccounts.length);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(richEthAccounts[index]);
+        expect(result.subAccount).toBeNull();
+      });
+    });
+
+    test("returns an empty array if the CryptoCurrency passed has no associated account", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        ethCurrency,
+        allAccounts,
+        false
+      );
+
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe("TokenCurrency", () => {
+    const aaveToken = Object.freeze(getTokenById("ethereum/erc20/aave"));
+
+    test("returns correct parent accounts including a new subAccount when a TokenCurrency is provided", () => {
+      const ethAccounts = [
+        { ...getEthAccount(), subAccounts: [] },
+        { ...getEthAccount(), subAccounts: [] },
+      ];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        aaveToken,
+        allAccounts,
+        false
+      );
+
+      expect(results).toHaveLength(ethAccounts.length);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect(
+          (result.subAccount as SubAccount & { token: TokenCurrency }).token
+        ).toEqual(aaveToken);
+      });
+    });
+
+    test("returns correct parent accounts including already existing subAccounts when a TokenCurrency is provided", () => {
+      const ethAccounts = [{ ...getEthAccount(), subAccounts: [aaveToken] }];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        aaveToken,
+        allAccounts,
+        false
+      );
+
+      expect(results).toHaveLength(ethAccounts.length);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect(
+          (result.subAccount as SubAccount & { token: TokenCurrency }).token
+        ).toEqual(aaveToken);
+      });
+    });
+
+    test("returns an empty array when a TokenCurrency is provided but the accounts list is empty", () => {
+      const allAccounts: Account[] = [];
+
+      const results = getAccountTuplesForCurrency(
+        aaveToken,
+        allAccounts,
+        false
+      );
+      expect(results).toHaveLength(0);
+    });
+  });
+});

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

@@ -0,0 +1,67 @@
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/cryptoassets";
+import { makeEmptyTokenAccount } from "../../../account";
+import { Account, SubAccount } from "../../../types";
+import type { ExchangeRate } from "../types";
+
+export const KYC_STATUS = {
+  pending: "pending",
+  rejected: "closed",
+  approved: "approved",
+};
+
+export type KYCStatus = keyof typeof KYC_STATUS;
+
+export const pickExchangeRate = (
+  exchangeRates: ExchangeRate[],
+  exchangeRate: ExchangeRate | null | undefined,
+  setExchangeRate: (rate?: ExchangeRate | null) => void
+): void => {
+  const hasRates = exchangeRates?.length > 0;
+  // If the user picked an exchange rate before, try to select the new one that matches.
+  // Otherwise pick the first one.
+  const rate =
+    hasRates &&
+    ((exchangeRate &&
+      exchangeRates.find(
+        ({ tradeMethod, provider }) =>
+          tradeMethod === exchangeRate.tradeMethod &&
+          provider === exchangeRate.provider
+      )) ||
+      exchangeRates[0]);
+  setExchangeRate(rate || null);
+};
+
+export type AccountTuple = {
+  account: Account | null | undefined;
+  subAccount: SubAccount | null | undefined;
+};
+
+export function getAccountTuplesForCurrency(
+  currency: CryptoCurrency | TokenCurrency,
+  allAccounts: Account[],
+  hideEmpty?: boolean
+): AccountTuple[] {
+  if (currency.type === "TokenCurrency") {
+    return allAccounts
+      .filter((account) => account.currency.id === currency.parentCurrency.id)
+      .map((account) => ({
+        account,
+        subAccount:
+          (account.subAccounts &&
+            account.subAccounts.find(
+              (subAcc: SubAccount) =>
+                subAcc.type === "TokenAccount" &&
+                subAcc.token.id === currency.id
+            )) ||
+          makeEmptyTokenAccount(account, currency),
+      }))
+      .filter((a) => (hideEmpty ? a.subAccount?.balance.gt(0) : true));
+  }
+  return allAccounts
+    .filter((account) => account.currency.id === currency.id)
+    .map((account) => ({
+      account,
+      subAccount: null,
+    }))
+    .filter((a) => (hideEmpty ? a.account?.balance.gt(0) : true));
+}

package/src/families/bitcoin/account.ts

@@ -2,7 +2,7 @@ import type { Account } from "../../types";
 import type { BitcoinOutput, BitcoinInput } from "./types";
 import { formatCurrencyUnit } from "../../currencies";
 import { getEnv } from "../../env";
-import { perCoinLogic } from "./logic";
+import { perCoinLogic } from "./transaction";
 
 const sortUTXO = (a, b) => b.value.minus(a.value).toNumber();
 
@@ -31,7 +31,6 @@ export function formatOutput(account: Account, o: BitcoinOutput): string {
     }).padEnd(12),
     o.address,
     o.path,
-    o.isChange ? "(change)" : "",
     o.rbf ? "rbf" : "",
     o.hash,
     `@${o.outputIndex} (${

package/src/families/bitcoin/datasets/bitcoin.ts

@@ -50,8 +50,8 @@ const dataset: CurrenciesData<Transaction> = {
           expectedStatus: {
             amount: new BigNumber("999"),
             // FIXME fee are reloaded?
-            // estimatedFees: new BigNumber("250"),
-            // totalSpent: new BigNumber("1249"),
+            // estimatedFees: BigNumber("250"),
+            // totalSpent: BigNumber("1249"),
             errors: {},
             warnings: {
               // feeTooHigh: new FeeTooHigh()
@@ -76,8 +76,8 @@ const dataset: CurrenciesData<Transaction> = {
           expectedStatus: {
             amount: new BigNumber("998"),
             // FIXME fee are reloaded?
-            // estimatedFees: new BigNumber("250"),
-            // totalSpent: new BigNumber("1248"),
+            // estimatedFees: BigNumber("250"),
+            // totalSpent: BigNumber("1248"),
             errors: {},
             warnings: {
               // feeTooHigh: new FeeTooHigh()
@@ -102,8 +102,8 @@ const dataset: CurrenciesData<Transaction> = {
           expectedStatus: {
             amount: new BigNumber("997"),
             // FIXME fee are reloaded?
-            // estimatedFees: new BigNumber("250"),
-            // totalSpent: new BigNumber("1247"),
+            // estimatedFees: BigNumber("250"),
+            // totalSpent: BigNumber("1247"),
             errors: {},
             warnings: {
               // feeTooHigh: new FeeTooHigh(),

package/src/families/bitcoin/datasets/litecoin.ts

@@ -50,8 +50,8 @@ const dataset: CurrenciesData<Transaction> = {
           expectedStatus: {
             errors: {},
             warnings: {},
-            //  estimatedFees: new BigNumber("5694"),
-            amount: new BigNumber("200000"), //  totalSpent: new BigNumber("205694")
+            //  estimatedFees: BigNumber("5694"),
+            amount: new BigNumber("200000"), //  totalSpent: BigNumber("205694")
           },
         },
         {
@@ -73,8 +73,8 @@ const dataset: CurrenciesData<Transaction> = {
           expectedStatus: {
             errors: {},
             warnings: {},
-            //  estimatedFees: new BigNumber("5694"),
-            amount: new BigNumber("147200"), //  totalSpent: new BigNumber("152894")
+            //  estimatedFees: BigNumber("5694"),
+            amount: new BigNumber("147200"), //  totalSpent: BigNumber("152894")
           },
         },
         {
@@ -96,8 +96,8 @@ const dataset: CurrenciesData<Transaction> = {
           expectedStatus: {
             errors: {},
             warnings: {},
-            //  estimatedFees: new BigNumber("5694"),
-            amount: new BigNumber("205273"), //  totalSpent: new BigNumber("210967")
+            //  estimatedFees: BigNumber("5694"),
+            amount: new BigNumber("205273"), //  totalSpent: BigNumber("210967")
           },
         },
       ],

package/src/families/bitcoin/serialization.ts

@@ -38,7 +38,6 @@ export function toBitcoinOutputRaw({
   outputIndex,
   blockHeight,
   address,
-  isChange,
   path,
   value,
   rbf,
@@ -48,7 +47,6 @@ export function toBitcoinOutputRaw({
     outputIndex,
     blockHeight,
     address,
-    isChange ? 1 : 0,
     path,
     value.toString(),
     rbf ? 1 : 0,
@@ -59,7 +57,6 @@ export function fromBitcoinOutputRaw([
   outputIndex,
   blockHeight,
   address,
-  isChange,
   path,
   value,
   rbf,
@@ -69,7 +66,6 @@ export function fromBitcoinOutputRaw([
     outputIndex,
     blockHeight: blockHeight || undefined,
     address: address || undefined,
-    isChange: !!isChange,
     path: path || undefined,
     value: new BigNumber(value),
     rbf: !!rbf,
@@ -80,7 +76,6 @@ export function toBitcoinResourcesRaw(
 ): BitcoinResourcesRaw {
   return {
     utxos: r.utxos.map(toBitcoinOutputRaw),
-    serializedData: r.serializedData,
   };
 }
 export function fromBitcoinResourcesRaw(
@@ -88,6 +83,5 @@ export function fromBitcoinResourcesRaw(
 ): BitcoinResources {
   return {
     utxos: r.utxos.map(fromBitcoinOutputRaw),
-    serializedData: r.serializedData,
   };
 }

package/src/families/bitcoin/specs.ts

@@ -10,7 +10,8 @@ import { pickSiblings } from "../../bot/specs";
 import { bitcoinPickingStrategy } from "./types";
 import type { MutationSpec, AppSpec } from "../../bot/types";
 import { LowerThanMinimumRelayFee } from "../../errors";
-import { getMinRelayFee, getUTXOStatus, isChangeOutput } from "./logic";
+import { getMinRelayFee } from "./fees";
+import { isChangeOutput, getUTXOStatus } from "./transaction";
 import { DeviceModelId } from "@ledgerhq/devices";
 type Arg = Partial<{
   minimalAmount: BigNumber;
@@ -80,11 +81,7 @@ const genericTest = ({
         ? operation.senders
         : txInputs.map((t) => t.address).filter(Boolean),
       recipients: txOutputs
-        // TODO REPLACE >>>>>>>>>>>>>>>>>>
         .filter((o) => !isChangeOutput(o))
-        /*/ WITH <<<<<<<<<<<<<<<<<<<<<<<<<
-        .filter((o) => !o.isChange)
-        //*/
         .map((t) => t.address)
         .filter(Boolean),
     })
@@ -372,6 +369,17 @@ const stakenet: AppSpec<Transaction> = {
   test: genericTest,
   mutations: bitcoinLikeMutations(),
 };
+const stratis: AppSpec<Transaction> = {
+  name: "Stratis",
+  currency: getCryptoCurrencyById("stratis"),
+  dependency: "Bitcoin",
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Stratis",
+  },
+  test: genericTest,
+  mutations: bitcoinLikeMutations(),
+};
 const vertcoin: AppSpec<Transaction> = {
   name: "Vertcoin",
   currency: getCryptoCurrencyById("vertcoin"),
@@ -541,6 +549,7 @@ export default {
   qtum,
   stakenet,
   stealthcoin,
+  stratis,
   vertcoin,
   viacoin,
   zcash,

package/src/families/bitcoin/speculos-deviceActions.ts

@@ -2,7 +2,7 @@ import type { DeviceAction } from "../../bot/types";
 import type { Transaction } from "./types";
 import { formatCurrencyUnit } from "../../currencies";
 import { deviceActionFlow } from "../../bot/specs";
-import { perCoinLogic } from "./logic";
+import { perCoinLogic } from "./transaction";
 const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
   steps: [
     {

package/src/families/bitcoin/test-dataset.ts

@@ -19,7 +19,7 @@ import vertcoin from "./datasets/vertcoin";
 import viacoin from "./datasets/viacoin";
 import zcash from "./datasets/zcash";
 const dataset: DatasetTest<Transaction> = {
-  implementations: ["js", "mock"],
+  implementations: ["libcore", "mock"],
   currencies: {
     bitcoin_cash,
     bitcoin_gold,

package/src/families/bitcoin/transaction.ts

@@ -25,102 +25,6 @@ import { formatCurrencyUnit } from "../../currencies";
 import type { CryptoCurrencyIds } from "../../types";
 import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
 
-const fromFeeItemsRaw = (fir: FeeItemsRaw): FeeItems => ({
-  items: fir.items.map((fi) => ({
-    key: fi.key,
-    speed: fi.speed,
-    feePerByte: new BigNumber(fi.feePerByte),
-  })),
-  defaultFeePerByte: new BigNumber(fir.defaultFeePerByte),
-});
-
-const toFeeItemsRaw = (fir: FeeItems): FeeItemsRaw => ({
-  items: fir.items.map((fi) => ({
-    key: fi.key,
-    speed: fi.speed,
-    feePerByte: fi.feePerByte.toString(),
-  })),
-  defaultFeePerByte: fir.defaultFeePerByte.toString(),
-});
-
-export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
-  const common = fromTransactionCommonRaw(tr);
-  return {
-    ...common,
-    rbf: tr.rbf,
-    utxoStrategy: tr.utxoStrategy,
-    family: tr.family,
-    feePerByte: tr.feePerByte ? new BigNumber(tr.feePerByte) : null,
-    networkInfo: tr.networkInfo && {
-      family: tr.networkInfo.family,
-      feeItems: fromFeeItemsRaw(tr.networkInfo.feeItems),
-    },
-    feesStrategy: tr.feesStrategy,
-  };
-};
-export const toTransactionRaw = (t: Transaction): TransactionRaw => {
-  const common = toTransactionCommonRaw(t);
-  return {
-    ...common,
-    rbf: t.rbf,
-    utxoStrategy: t.utxoStrategy,
-    family: t.family,
-    feePerByte: t.feePerByte ? t.feePerByte.toString() : null,
-    networkInfo: t.networkInfo && {
-      family: t.networkInfo.family,
-      feeItems: toFeeItemsRaw(t.networkInfo.feeItems),
-    },
-    feesStrategy: t.feesStrategy,
-  };
-};
-
-const formatNetworkInfo = (
-  networkInfo:
-    | {
-        feeItems: FeeItems;
-      }
-    | null
-    | undefined
-) => {
-  if (!networkInfo) return "network info not loaded";
-  return `network fees: ${networkInfo.feeItems.items
-    .map((i) => i.key + "=" + i.feePerByte.toString())
-    .join(", ")}`;
-};
-
-export const formatTransaction = (t: Transaction, account: Account): string => {
-  const n = getEnv("DEBUG_UTXO_DISPLAY");
-  const { excludeUTXOs, strategy, pickUnconfirmedRBF } = t.utxoStrategy;
-  const displayAll = excludeUTXOs.length <= n;
-  return `
-SEND ${
-    t.useAllAmount
-      ? "MAX"
-      : formatCurrencyUnit(getAccountUnit(account), t.amount, {
-          showCode: true,
-          disableRounding: true,
-        })
-  }
-TO ${t.recipient}
-with feePerByte=${
-    t.feePerByte ? t.feePerByte.toString() : "?"
-  } (${formatNetworkInfo(t.networkInfo)})
-${[
-  Object.keys(bitcoinPickingStrategy).find(
-    (k) => bitcoinPickingStrategy[k] === strategy
-  ),
-  pickUnconfirmedRBF && "pick-unconfirmed",
-  t.rbf && "RBF-enabled",
-]
-  .filter(Boolean)
-  .join(" ")}${excludeUTXOs
-    .slice(0, displayAll ? excludeUTXOs.length : n)
-    .map((utxo) => `\nexclude ${utxo.hash} @${utxo.outputIndex}`)
-    .join("")}`;
-};
-
-// TODO vvvvv DEPRECATED, TO BE REMOVED vvvvv
-
 function bchExplicit(str: string): string {
   const explicit = str.includes(":") ? str : "bitcoincash:" + str;
 
@@ -254,7 +158,6 @@ export async function parseBitcoinOutput(
     outputIndex,
     blockHeight,
     address,
-    isChange: false,
     path,
     value,
     rbf,
@@ -298,8 +201,100 @@ export function isChangeOutput(output: BitcoinOutput): boolean {
   const p = output.path.split("/");
   return p[p.length - 2] === "1";
 }
-// ==============================================================================
 
+const fromFeeItemsRaw = (fir: FeeItemsRaw): FeeItems => ({
+  items: fir.items.map((fi) => ({
+    key: fi.key,
+    speed: fi.speed,
+    feePerByte: new BigNumber(fi.feePerByte),
+  })),
+  defaultFeePerByte: new BigNumber(fir.defaultFeePerByte),
+});
+
+const toFeeItemsRaw = (fir: FeeItems): FeeItemsRaw => ({
+  items: fir.items.map((fi) => ({
+    key: fi.key,
+    speed: fi.speed,
+    feePerByte: fi.feePerByte.toString(),
+  })),
+  defaultFeePerByte: fir.defaultFeePerByte.toString(),
+});
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    rbf: tr.rbf,
+    utxoStrategy: tr.utxoStrategy,
+    family: tr.family,
+    feePerByte: tr.feePerByte ? new BigNumber(tr.feePerByte) : null,
+    networkInfo: tr.networkInfo && {
+      family: tr.networkInfo.family,
+      feeItems: fromFeeItemsRaw(tr.networkInfo.feeItems),
+    },
+    feesStrategy: tr.feesStrategy,
+  };
+};
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    rbf: t.rbf,
+    utxoStrategy: t.utxoStrategy,
+    family: t.family,
+    feePerByte: t.feePerByte ? t.feePerByte.toString() : null,
+    networkInfo: t.networkInfo && {
+      family: t.networkInfo.family,
+      feeItems: toFeeItemsRaw(t.networkInfo.feeItems),
+    },
+    feesStrategy: t.feesStrategy,
+  };
+};
+
+const formatNetworkInfo = (
+  networkInfo:
+    | {
+        feeItems: FeeItems;
+      }
+    | null
+    | undefined
+) => {
+  if (!networkInfo) return "network info not loaded";
+  return `network fees: ${networkInfo.feeItems.items
+    .map((i) => i.key + "=" + i.feePerByte.toString())
+    .join(", ")}`;
+};
+
+export const formatTransaction = (t: Transaction, account: Account): string => {
+  const n = getEnv("DEBUG_UTXO_DISPLAY");
+  const { excludeUTXOs, strategy, pickUnconfirmedRBF } = t.utxoStrategy;
+  const displayAll = excludeUTXOs.length <= n;
+  return `
+SEND ${
+    t.useAllAmount
+      ? "MAX"
+      : formatCurrencyUnit(getAccountUnit(account), t.amount, {
+          showCode: true,
+          disableRounding: true,
+        })
+  }
+TO ${t.recipient}
+with feePerByte=${
+    t.feePerByte ? t.feePerByte.toString() : "?"
+  } (${formatNetworkInfo(t.networkInfo)})
+${[
+  Object.keys(bitcoinPickingStrategy).find(
+    (k) => bitcoinPickingStrategy[k] === strategy
+  ),
+  pickUnconfirmedRBF && "pick-unconfirmed",
+  t.rbf && "RBF-enabled",
+]
+  .filter(Boolean)
+  .join(" ")}${excludeUTXOs
+    .slice(0, displayAll ? excludeUTXOs.length : n)
+    .map((utxo) => `\nexclude ${utxo.hash} @${utxo.outputIndex}`)
+    .join("")}`;
+};
 export default {
   fromTransactionRaw,
   toTransactionRaw,