@ledgerhq/live-common 21.4.0 → 21.4.1-btcjs.6

package/src/families/bitcoin/bridge/js.ts

@@ -0,0 +1,76 @@
+import type { AccountBridge, CurrencyBridge } from "../../../types/bridge";
+import type { Transaction } from "../types";
+import { sync, scanAccounts } from "../js-synchronisation";
+import createTransaction from "../js-createTransaction";
+import prepareTransaction from "../js-prepareTransaction";
+import getTransactionStatus from "../js-getTransactionStatus";
+import estimateMaxSpendable from "../js-estimateMaxSpendable";
+import signOperation from "../js-signOperation";
+import broadcast from "../js-broadcast";
+import { calculateFees } from "./../cache";
+import { perCoinLogic } from "../logic";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+import * as explorerConfigAPI from "../../../api/explorerConfig";
+const receive = makeAccountBridgeReceive({
+  injectGetAddressParams: (account) => {
+    const perCoin = perCoinLogic[account.currency.id];
+
+    if (perCoin && perCoin.injectGetAddressParams) {
+      return perCoin.injectGetAddressParams(account);
+    }
+  },
+});
+
+const updateTransaction = (t, patch) => {
+  const updatedT = { ...t, ...patch };
+
+  if (updatedT.recipient.toLowerCase().indexOf("bc1") === 0) {
+    updatedT.recipient = updatedT.recipient.toLowerCase();
+  }
+
+  return updatedT;
+};
+
+const preload = async () => {
+  const explorerConfig = await explorerConfigAPI.preload();
+  return {
+    explorerConfig,
+  };
+};
+
+const hydrate = (maybeConfig: any) => {
+  if (
+    typeof maybeConfig === "object" &&
+    maybeConfig &&
+    maybeConfig.explorerConfig
+  ) {
+    explorerConfigAPI.hydrate(maybeConfig.explorerConfig);
+  }
+};
+
+const currencyBridge: CurrencyBridge = {
+  scanAccounts,
+  preload,
+  hydrate,
+};
+const accountBridge: AccountBridge<Transaction> = {
+  estimateMaxSpendable,
+  createTransaction,
+  prepareTransaction,
+  updateTransaction,
+  getTransactionStatus,
+  receive,
+  sync,
+  signOperation,
+  broadcast: async ({ account, signedOperation }) => {
+    calculateFees.reset();
+    return broadcast({
+      account,
+      signedOperation,
+    });
+  },
+};
+export default {
+  currencyBridge,
+  accountBridge,
+};

package/src/families/bitcoin/cache.ts

@@ -0,0 +1,76 @@
+import { RecipientRequired } from "@ledgerhq/errors";
+import { makeLRUCache } from "./../../cache";
+import type { Account, CryptoCurrency } from "./../../types";
+import type { Transaction } from "./types";
+import getFeesForTransaction from "./js-getFeesForTransaction";
+import { isValidRecipient } from "./logic";
+
+const getCacheKeyForCalculateFees = ({
+  a,
+  t,
+}: {
+  a: Account;
+  t: Transaction;
+}) =>
+  `${a.id}_${a.blockHeight || 0}_${t.amount.toString()}_${String(
+    t.useAllAmount
+  )}_${t.recipient}_${t.feePerByte ? t.feePerByte.toString() : ""}_${
+    t.utxoStrategy.pickUnconfirmedRBF ? 1 : 0
+  }_${t.utxoStrategy.strategy}_${String(t.rbf)}_${t.utxoStrategy.excludeUTXOs
+    .map(({ hash, outputIndex }) => `${hash}@${outputIndex}`)
+    .join("+")}`;
+
+export const calculateFees = makeLRUCache(
+  async ({
+    account,
+    transaction,
+  }: {
+    account: Account;
+    transaction: Transaction;
+  }) =>
+    getFeesForTransaction({
+      account,
+      transaction,
+    }),
+  ({ account, transaction }) =>
+    getCacheKeyForCalculateFees({
+      a: account,
+      t: transaction,
+    }),
+  {
+    maxAge: 5 * 60 * 1000, // 5 minutes
+  }
+);
+export const validateRecipient: (
+  arg0: CryptoCurrency,
+  arg1: string | null | undefined
+) => Promise<{
+  recipientError: Error | null | undefined;
+  recipientWarning: Error | null | undefined;
+}> = makeLRUCache(
+  async (currency, recipient) => {
+    if (!recipient) {
+      return {
+        recipientError: new RecipientRequired(""),
+        recipientWarning: null,
+      };
+    }
+
+    try {
+      const recipientWarning = await isValidRecipient({
+        currency,
+        recipient,
+      });
+      return {
+        recipientError: null,
+        recipientWarning,
+      };
+    } catch (recipientError) {
+      return {
+        recipientError,
+        recipientWarning: null,
+      };
+    }
+  },
+  (currency, recipient) => `${currency.id}_${recipient || ""}`
+);

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: BigNumber("250"),
-            // totalSpent: BigNumber("1249"),
+            // estimatedFees: new BigNumber("250"),
+            // totalSpent: new 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: BigNumber("250"),
-            // totalSpent: BigNumber("1248"),
+            // estimatedFees: new BigNumber("250"),
+            // totalSpent: new 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: BigNumber("250"),
-            // totalSpent: BigNumber("1247"),
+            // estimatedFees: new BigNumber("250"),
+            // totalSpent: new 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: BigNumber("5694"),
-            amount: new BigNumber("200000"), //  totalSpent: BigNumber("205694")
+            //  estimatedFees: new BigNumber("5694"),
+            amount: new BigNumber("200000"), //  totalSpent: new BigNumber("205694")
           },
         },
         {
@@ -73,8 +73,8 @@ const dataset: CurrenciesData<Transaction> = {
           expectedStatus: {
             errors: {},
             warnings: {},
-            //  estimatedFees: BigNumber("5694"),
-            amount: new BigNumber("147200"), //  totalSpent: BigNumber("152894")
+            //  estimatedFees: new BigNumber("5694"),
+            amount: new BigNumber("147200"), //  totalSpent: new BigNumber("152894")
           },
         },
         {
@@ -96,8 +96,8 @@ const dataset: CurrenciesData<Transaction> = {
           expectedStatus: {
             errors: {},
             warnings: {},
-            //  estimatedFees: BigNumber("5694"),
-            amount: new BigNumber("205273"), //  totalSpent: BigNumber("210967")
+            //  estimatedFees: new BigNumber("5694"),
+            amount: new BigNumber("205273"), //  totalSpent: new BigNumber("210967")
           },
         },
       ],

package/src/families/bitcoin/getAccountNetworkInfo.test.ts

@@ -0,0 +1,27 @@
+import { BigNumber } from "bignumber.js";
+import { avoidDups } from "./getAccountNetworkInfo";
+test("avoidFeeDupsInFeePerByte [3,2,2] => [4,3,2]", async () => {
+  expect(
+    avoidDups([new BigNumber(3), new BigNumber(3), new BigNumber(2)])
+  ).toEqual([new BigNumber(4), new BigNumber(3), new BigNumber(2)]);
+});
+test("avoidFeeDupsInFeePerByte [2,2,1] => [3,2,1]", async () => {
+  expect(
+    avoidDups([new BigNumber(2), new BigNumber(2), new BigNumber(1)])
+  ).toEqual([new BigNumber(3), new BigNumber(2), new BigNumber(1)]);
+});
+test("avoidFeeDupsInFeePerByte [3,3,3] => [5,4,3]", async () => {
+  expect(
+    avoidDups([new BigNumber(3), new BigNumber(3), new BigNumber(3)])
+  ).toEqual([new BigNumber(5), new BigNumber(4), new BigNumber(3)]);
+});
+test("avoidFeeDupsInFeePerByte [3,2,1] => [3,2,1]", async () => {
+  expect(
+    avoidDups([new BigNumber(3), new BigNumber(2), new BigNumber(1)])
+  ).toEqual([new BigNumber(3), new BigNumber(2), new BigNumber(1)]);
+});
+test("avoidFeeDupsInFeePerByte [100,100,1] => [101,100,1]", async () => {
+  expect(
+    avoidDups([new BigNumber(100), new BigNumber(100), new BigNumber(1)])
+  ).toEqual([new BigNumber(101), new BigNumber(100), new BigNumber(1)]);
+});

package/src/families/bitcoin/getAccountNetworkInfo.ts

@@ -0,0 +1,61 @@
+import flow from "lodash/flow";
+import { BigNumber } from "bignumber.js";
+import type { Account } from "../../types";
+import type { NetworkInfo } from "./types";
+import { getWalletAccount } from "./wallet";
+const speeds = ["fast", "medium", "slow"];
+export function avoidDups(nums: Array<BigNumber>): Array<BigNumber> {
+  nums = nums.slice(0);
+
+  for (let i = nums.length - 2; i >= 0; i--) {
+    if (nums[i + 1].gte(nums[i])) {
+      nums[i] = nums[i + 1].plus(1);
+    }
+  }
+
+  return nums;
+}
+export async function getAccountNetworkInfo(
+  account: Account
+): Promise<NetworkInfo> {
+  const walletAccount = await getWalletAccount(account);
+  const rawFees = await walletAccount.xpub.explorer.getFees();
+  // Convoluted logic to convert from:
+  // { "2": 2435, "3": 1241, "6": 1009, "last_updated": 1627973170 }
+  // to:
+  // { 2435, 1241, 1009 }
+  const feesPerByte = flow([
+    // Remove the 'last_updated' key
+    Object.entries,
+    (entries) => entries.filter(([key]) => !isNaN(key)),
+    // Reconstruct the array with only the values
+    Object.fromEntries,
+    Object.values,
+    // Safety against invalid data
+    (f) => f.filter((f) => f != null && typeof f === "number"),
+    // Normalize values
+    (f) =>
+      f.map((f) =>
+        new BigNumber(f).div(1000).integerValue(BigNumber.ROUND_CEIL)
+      ),
+    avoidDups,
+  ])(rawFees);
+
+  if (feesPerByte.length !== 3) {
+    throw new Error("cardinality of feesPerByte should be exactly 3");
+  }
+
+  const feeItems = {
+    items: feesPerByte.map((feePerByte, i) => ({
+      key: String(i),
+      speed: speeds[i],
+      feePerByte,
+    })),
+    defaultFeePerByte:
+      feesPerByte[Math.floor(feesPerByte.length / 2)] || new BigNumber(0),
+  };
+  return {
+    family: "bitcoin",
+    feeItems,
+  };
+}

package/src/families/bitcoin/js-broadcast.ts

@@ -0,0 +1,30 @@
+import { patchOperationWithHash } from "./../../operation";
+import type { Account, Operation, SignedOperation } from "./../../types";
+import wallet from "./wallet";
+
+/**
+ * Broadcast a signed transaction
+ * @param {signature: string, operation: string} signedOperation
+ */
+const broadcast = async ({
+  account,
+  signedOperation,
+}: {
+  account: Account;
+  signedOperation: SignedOperation;
+}): Promise<Operation> => {
+  const { signature, operation } = signedOperation;
+  const walletData = account.bitcoinResources?.serializedData;
+  if (!walletData) {
+    throw new Error("bitcoin wallet account expected");
+  }
+  const walletAccount = await wallet.importFromSerializedAccount(walletData);
+  try {
+    const hash = await wallet.broadcastTx(walletAccount, signature);
+    return patchOperationWithHash(operation, hash);
+  } catch (error: any) {
+    throw new Error(error); // TODO Improve error message for broadcast failure cases
+  }
+};
+
+export default broadcast;

package/src/families/bitcoin/js-buildTransaction.ts

@@ -0,0 +1,57 @@
+import type { Account as WalletAccount } from "@ledgerhq/wallet-btc";
+import { CoinSelect, DeepFirst, Merge } from "@ledgerhq/wallet-btc";
+import type { TransactionInfo as WalletTxInfo } from "@ledgerhq/wallet-btc";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+
+import type { Account } from "../../types";
+import type { Transaction, UtxoStrategy } from "./types";
+import { bitcoinPickingStrategy } from "./types";
+import wallet, { getWalletAccount } from "./wallet";
+
+const selectUtxoPickingStrategy = (
+  walletAccount: WalletAccount,
+  utxoStrategy: UtxoStrategy
+) => {
+  const handler = {
+    [bitcoinPickingStrategy.MERGE_OUTPUTS]: Merge,
+    [bitcoinPickingStrategy.DEEP_OUTPUTS_FIRST]: DeepFirst,
+    [bitcoinPickingStrategy.OPTIMIZE_SIZE]: CoinSelect,
+  }[utxoStrategy.strategy];
+  if (!handler) throw new Error("Unsupported Bitcoin UTXO picking strategy");
+
+  return new handler(
+    walletAccount.xpub.crypto,
+    walletAccount.xpub.derivationMode,
+    utxoStrategy.excludeUTXOs
+  );
+};
+
+export const buildTransaction = async (
+  account: Account,
+  transaction: Transaction
+): Promise<WalletTxInfo> => {
+  if (!transaction.feePerByte) {
+    throw new FeeNotLoaded();
+  }
+  const walletAccount = await getWalletAccount(account);
+  const utxoPickingStrategy = selectUtxoPickingStrategy(
+    walletAccount,
+    transaction.utxoStrategy
+  );
+
+  const maxSpendable = await wallet.estimateAccountMaxSpendable(
+    walletAccount,
+    transaction.feePerByte.toNumber() //!\ wallet-btc handles fees as JS number
+  );
+
+  const txInfo = await wallet.buildAccountTx({
+    fromAccount: walletAccount,
+    dest: transaction.recipient,
+    amount: transaction.useAllAmount ? maxSpendable : transaction.amount,
+    feePerByte: transaction.feePerByte.toNumber(), //!\ wallet-btc handles fees as JS number
+    utxoPickingStrategy,
+    // Definition of replaceable, per the standard: https://github.com/bitcoin/bips/blob/61ccc84930051e5b4a99926510d0db4a8475a4e6/bip-0125.mediawiki#summary
+    sequence: transaction.rbf ? 0 : 0xffffffff,
+  });
+  return txInfo;
+};

package/src/families/bitcoin/js-createTransaction.ts

@@ -0,0 +1,27 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+const createTransaction = (): Transaction => {
+  return {
+    family: "bitcoin",
+    amount: new BigNumber(0),
+    utxoStrategy: {
+      strategy: 0,
+      pickUnconfirmedRBF: false,
+      excludeUTXOs: [],
+    },
+    recipient: "",
+    rbf: false,
+    feePerByte: null,
+    networkInfo: null,
+    useAllAmount: false,
+    feesStrategy: "medium",
+  };
+};
+
+export default createTransaction;

package/src/families/bitcoin/js-estimateMaxSpendable.ts

@@ -0,0 +1,36 @@
+import { BigNumber } from "bignumber.js";
+import type { AccountLike, Account } from "../../types";
+import type { Transaction } from "./types";
+import { getMainAccount } from "../../account";
+import wallet, { getWalletAccount } from "./wallet";
+import { getAccountNetworkInfo } from "./getAccountNetworkInfo";
+
+/**
+ * Returns the maximum possible amount for transaction
+ *
+ * @param {Object} param - the account, parentAccount and transaction
+ */
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction | null | undefined;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const walletAccount = await getWalletAccount(mainAccount);
+  let feePerByte = transaction?.feePerByte;
+  if (!feePerByte) {
+    const networkInfo = await getAccountNetworkInfo(mainAccount);
+    feePerByte = networkInfo.feeItems.defaultFeePerByte;
+  }
+  const maxSpendable = await wallet.estimateAccountMaxSpendable(
+    walletAccount,
+    feePerByte.toNumber() //!\ wallet-btc handles fees as JS number
+  );
+  return maxSpendable.lt(0) ? new BigNumber(0) : maxSpendable;
+};
+
+export default estimateMaxSpendable;

package/src/families/bitcoin/js-getFeesForTransaction.ts

@@ -0,0 +1,59 @@
+import { BigNumber } from "bignumber.js";
+import type { Account } from "./../../types";
+import type { Transaction } from "./types";
+import { buildTransaction } from "./js-buildTransaction";
+import { perCoinLogic } from "./logic";
+
+const getFeesForTransaction = async ({
+  account,
+  transaction,
+}: {
+  account: Account;
+  transaction: Transaction;
+}) => {
+  const walletTx = await buildTransaction(account, transaction);
+  const fees = new BigNumber(walletTx.fee).integerValue();
+  let txInputs = walletTx.inputs.map((i) => {
+    return {
+      address: i.address,
+      value: new BigNumber(i.value),
+      previousTxHash: i.output_hash,
+      previousOutputIndex: i.output_index,
+    };
+  });
+  let txOutputs = walletTx.outputs.map((o) => {
+    return {
+      outputIndex: walletTx.outputs.indexOf(o),
+      address: o.address,
+      isChange: o.isChange,
+      value: new BigNumber(o.value),
+      hash: undefined,
+      blockHeight: undefined,
+      rbf: transaction.rbf,
+    };
+  });
+  const perCoin = perCoinLogic[account.currency.id];
+
+  if (perCoin) {
+    const { syncReplaceAddress } = perCoin;
+
+    if (syncReplaceAddress) {
+      txInputs = txInputs.map((i) => ({
+        ...i,
+        address: i.address && syncReplaceAddress(i.address),
+      }));
+      txOutputs = txOutputs.map((o) => ({
+        ...o,
+        address: o.address && syncReplaceAddress(o.address),
+      }));
+    }
+  }
+
+  return {
+    fees,
+    txInputs,
+    txOutputs,
+  };
+};
+
+export default getFeesForTransaction;

package/src/families/bitcoin/js-getTransactionStatus.ts

@@ -0,0 +1,118 @@
+import { BigNumber } from "bignumber.js";
+import { log } from "@ledgerhq/logs";
+import {
+  AmountRequired,
+  NotEnoughBalance,
+  FeeNotLoaded,
+  FeeTooHigh,
+  FeeRequired,
+} from "@ledgerhq/errors";
+import { LowerThanMinimumRelayFee } from "./../../errors";
+import type { Account, TransactionStatus } from "./../../types";
+import type { Transaction } from "./types";
+import { calculateFees, validateRecipient } from "./cache";
+import { getMinRelayFee } from "./logic";
+
+const getTransactionStatus = async (
+  a: Account,
+  t: Transaction
+): Promise<TransactionStatus> => {
+  const errors: any = {};
+  const warnings: any = {};
+  const useAllAmount = !!t.useAllAmount;
+  const { recipientError, recipientWarning } = await validateRecipient(
+    a.currency,
+    t.recipient
+  );
+
+  if (recipientError) {
+    errors.recipient = recipientError;
+  }
+
+  if (recipientWarning) {
+    warnings.recipient = recipientWarning;
+  }
+
+  let txInputs;
+  let txOutputs;
+  let estimatedFees = new BigNumber(0);
+
+  if (!t.feePerByte) {
+    errors.feePerByte = new FeeNotLoaded();
+  } else if (t.feePerByte.eq(0)) {
+    errors.feePerByte = new FeeRequired();
+  } else if (t.recipient && !errors.recipient) {
+    await calculateFees({
+      account: a,
+      transaction: t,
+    }).then(
+      (res) => {
+        txInputs = res.txInputs;
+        txOutputs = res.txOutputs;
+        estimatedFees = res.fees;
+      },
+      (error) => {
+        if (error.name === "NotEnoughBalance") {
+          errors.amount = error;
+        } else {
+          throw error;
+        }
+      }
+    );
+  }
+
+  const sumOfInputs = (txInputs || []).reduce(
+    (sum, input) => sum.plus(input.value),
+    new BigNumber(0)
+  );
+  const sumOfChanges = (txOutputs || [])
+    .filter((o) => o.isChange)
+    .reduce((sum, output) => sum.plus(output.value), new BigNumber(0));
+
+  if (txInputs) {
+    log("bitcoin", `${txInputs.length} inputs, sum: ${sumOfInputs.toString()}`);
+  }
+
+  if (txOutputs) {
+    log(
+      "bitcoin",
+      `${txOutputs.length} outputs, sum of changes: ${sumOfChanges.toString()}`
+    );
+  }
+
+  const totalSpent = sumOfInputs.minus(sumOfChanges);
+  const amount = useAllAmount ? totalSpent.minus(estimatedFees) : t.amount;
+  log(
+    "bitcoin",
+    `totalSpent ${totalSpent.toString()} amount ${amount.toString()}`
+  );
+
+  if (!errors.amount && !amount.gt(0)) {
+    errors.amount = useAllAmount
+      ? new NotEnoughBalance()
+      : new AmountRequired();
+  }
+
+  if (
+    process.env.EXPERIMENTAL_MIN_RELAY_FEE &&
+    estimatedFees &&
+    estimatedFees.gt(0) &&
+    estimatedFees.lt(getMinRelayFee(a.currency))
+  ) {
+    warnings.feePerByte = new LowerThanMinimumRelayFee();
+  } else if (amount.gt(0) && estimatedFees.times(10).gt(amount)) {
+    warnings.feeTooHigh = new FeeTooHigh();
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+    txInputs,
+    txOutputs,
+  });
+};
+
+export default getTransactionStatus;

package/src/families/bitcoin/js-prepareTransaction.ts

@@ -0,0 +1,35 @@
+import invariant from "invariant";
+import type { Account } from "../../types";
+import type { Transaction } from "./types";
+import { getAccountNetworkInfo } from "./getAccountNetworkInfo";
+import { inferFeePerByte } from "./logic";
+
+const prepareTransaction = async (
+  a: Account,
+  t: Transaction
+): Promise<Transaction> => {
+  let networkInfo = t.networkInfo;
+
+  if (!networkInfo) {
+    networkInfo = await getAccountNetworkInfo(a);
+    invariant(networkInfo.family === "bitcoin", "bitcoin networkInfo expected");
+  }
+
+  const feePerByte = inferFeePerByte(t, networkInfo);
+
+  if (
+    t.networkInfo === networkInfo &&
+    (feePerByte === t.feePerByte || feePerByte.eq(t.feePerByte || 0))
+  ) {
+    // nothing changed
+    return t;
+  }
+
+  return {
+    ...t,
+    networkInfo,
+    feePerByte,
+  };
+};
+
+export default prepareTransaction;