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

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

@@ -1,27 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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;

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

@@ -1,164 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
-import Btc from "@ledgerhq/hw-app-btc";
-import { log } from "@ledgerhq/logs";
-import type { Account, Operation, SignOperationEvent } from "./../../types";
-import { isSegwitDerivationMode } from "./../../derivation";
-import { encodeOperationId } from "./../../operation";
-import { open, close } from "./../../hw";
-import type { Transaction } from "./types";
-import { getNetworkParameters } from "./networks";
-import { buildTransaction } from "./js-buildTransaction";
-import { calculateFees } from "./cache";
-import wallet, { getWalletAccount } from "./wallet";
-import { perCoinLogic } from "./logic";
-
-const signOperation = ({
-  account,
-  deviceId,
-  transaction,
-}: {
-  account: Account;
-  deviceId: any;
-  transaction: Transaction;
-}): Observable<SignOperationEvent> =>
-  Observable.create((o) => {
-    async function main() {
-      const { currency } = account;
-      const transport = await open(deviceId);
-      const hwApp = new Btc(transport);
-      const walletAccount = await getWalletAccount(account);
-
-      try {
-        log("hw", `signTransaction ${currency.id} for account ${account.id}`);
-        const txInfo = await buildTransaction(account, transaction);
-        let senders: string[] = [];
-        let recipients: string[] = [];
-        let fee = new BigNumber(0);
-        // Maybe better not re-calculate these fields here, instead include them
-        // in Transaction type and set them in prepareTransaction?
-        await calculateFees({
-          account,
-          transaction,
-        }).then((res) => {
-          senders = res.txInputs
-            .map((i) => i.address)
-            .filter(Boolean) as string[];
-          recipients = res.txOutputs
-            .map((o) => o.address)
-            .filter(Boolean) as string[];
-          fee = res.fees;
-        });
-
-        // FIXME (legacy)
-        // should be `transaction.getLockTime()` as soon as lock time is
-        // handled by libcore (actually: it always returns a default value
-        // and that caused issue with zcash (see #904))
-        // cf. https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/transaction_builders/BitcoinLikeUtxoPicker.cpp#L156-L159
-        let lockTime;
-
-        // (legacy) Set lockTime for Komodo to enable reward claiming on UTXOs created by
-        // Ledger Live. We should only set this if the currency is Komodo and
-        // lockTime isn't already defined.
-        if (currency.id === "komodo" && lockTime === undefined) {
-          const unixtime = Math.floor(Date.now() / 1000);
-          lockTime = unixtime - 777;
-        }
-
-        const networkParams = getNetworkParameters(currency.id);
-        const sigHashType = networkParams.sigHash;
-        if (isNaN(sigHashType)) {
-          throw new Error("sigHashType should not be NaN");
-        }
-
-        const segwit = isSegwitDerivationMode(account.derivationMode);
-
-        // FIXME Call to explorer needed to set timestamp
-        // cf. https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/transaction_builders/BitcoinLikeUtxoPicker.cpp#L150-L154
-        /*
-        const hasTimestamp = networkParams.usesTimestampedTransaction;
-        const initialTimestamp = hasTimestamp
-          ? transaction.timestamp
-          : undefined;
-        */
-
-        const perCoin = perCoinLogic[currency.id];
-        let additionals = [currency.id];
-
-        if (account.derivationMode === "native_segwit") {
-          additionals.push("bech32");
-        }
-
-        if (perCoin?.getAdditionals) {
-          additionals = additionals.concat(
-            perCoin.getAdditionals({
-              transaction,
-            })
-          );
-        }
-
-        const expiryHeight = perCoin?.hasExpiryHeight
-          ? Buffer.from([0x00, 0x00, 0x00, 0x00])
-          : undefined;
-
-        const signature = await wallet.signAccountTx({
-          btc: hwApp,
-          fromAccount: walletAccount,
-          txInfo,
-          lockTime,
-          sigHashType,
-          segwit,
-          //initialTimestamp,
-          additionals,
-          expiryHeight,
-          onDeviceSignatureGranted: () =>
-            o.next({
-              type: "device-signature-granted",
-            }),
-          onDeviceSignatureRequested: () =>
-            o.next({
-              type: "device-signature-requested",
-            }),
-          onDeviceStreaming: ({ progress, index, total }) =>
-            o.next({
-              type: "device-streaming",
-              progress,
-              index,
-              total,
-            }),
-        });
-        // Build the optimistic operation
-        const operation: Operation = {
-          id: encodeOperationId(account.id, "", "OUT"),
-          hash: "", // Will be resolved in broadcast()
-          type: "OUT",
-          value: new BigNumber(transaction.amount).plus(fee),
-          fee,
-          blockHash: null,
-          blockHeight: null,
-          senders,
-          recipients,
-          accountId: account.id,
-          date: new Date(),
-          extra: {},
-        };
-        o.next({
-          type: "signed",
-          signedOperation: {
-            operation,
-            signature,
-            expirationDate: null,
-          },
-        });
-      } finally {
-        close(transport, deviceId);
-      }
-    }
-
-    main().then(
-      () => o.complete(),
-      (e) => o.error(e)
-    );
-  });
-
-export default signOperation;