@ledgerhq/live-common 21.36.3 → 22.0.2

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

@@ -1,118 +0,0 @@
-import { log } from "@ledgerhq/logs";
-import { BigNumber } from "bignumber.js";
-import { FeeNotLoaded, InvalidAddress } from "@ledgerhq/errors";
-import type { Account } from "../../types";
-import { isValidRecipient } from "../../libcore/isValidRecipient";
-import { bigNumberToLibcoreAmount } from "../../libcore/buildBigNumber";
-import type { Core, CoreCurrency, CoreAccount } from "../../libcore/types";
-import type { CoreBitcoinLikeTransaction, Transaction } from "./types";
-import { getUTXOStatus } from "./transaction";
-import { promiseAllBatched } from "../../promise";
-import { parseBitcoinUTXO, perCoinLogic } from "./transaction";
-
-async function bitcoinBuildTransaction({
-  account,
-  core,
-  coreAccount,
-  coreCurrency,
-  transaction,
-  isPartial,
-  isCancelled,
-}: {
-  account: Account;
-  core: Core;
-  coreAccount: CoreAccount;
-  coreCurrency: CoreCurrency;
-  transaction: Transaction;
-  isPartial: boolean;
-  isCancelled: () => boolean;
-}): Promise<CoreBitcoinLikeTransaction | null | undefined> {
-  const { currency } = account;
-  const perCoin = perCoinLogic[currency.id];
-  const recipient = perCoin?.asLibcoreTransactionRecipient
-    ? perCoin.asLibcoreTransactionRecipient(transaction.recipient)
-    : transaction.recipient;
-  const bitcoinLikeAccount = await coreAccount.asBitcoinLikeAccount();
-  const isValid = await isValidRecipient({
-    currency,
-    recipient,
-  });
-
-  if (isValid !== null) {
-    throw new InvalidAddress("", {
-      currencyName: currency.name,
-    });
-  }
-
-  const { feePerByte } = transaction;
-  if (!feePerByte) throw new FeeNotLoaded();
-  const fees = await bigNumberToLibcoreAmount(
-    core,
-    coreCurrency,
-    new BigNumber(feePerByte)
-  );
-  if (isCancelled()) return;
-  const transactionBuilder = await bitcoinLikeAccount.buildTransaction(
-    isPartial
-  );
-  if (isCancelled()) return;
-  const { utxoStrategy } = transaction;
-
-  if (transaction.useAllAmount) {
-    await transactionBuilder.wipeToAddress(recipient);
-    if (isCancelled()) return;
-  }
-
-  const count = await bitcoinLikeAccount.getUTXOCount();
-  const objects = await bitcoinLikeAccount.getUTXO(0, count);
-  let utxos = await promiseAllBatched(6, objects, parseBitcoinUTXO);
-
-  if (perCoin) {
-    const { syncReplaceAddress } = perCoin;
-
-    if (syncReplaceAddress) {
-      utxos = utxos.map((u) => ({
-        ...u,
-        address: u.address && syncReplaceAddress(account, u.address),
-      }));
-    }
-  }
-
-  for (const utxo of utxos) {
-    const s = getUTXOStatus(utxo, utxoStrategy);
-
-    if (s.excluded) {
-      log(
-        "bitcoin",
-        `excludeUTXO ${utxo.hash}@${utxo.outputIndex} (${s.reason})`
-      );
-      await transactionBuilder.excludeUtxo(utxo.hash, utxo.outputIndex);
-    }
-  }
-
-  if (!transaction.useAllAmount) {
-    if (!transaction.amount) throw new Error("amount is missing");
-    const amount = await bigNumberToLibcoreAmount(
-      core,
-      coreCurrency,
-      new BigNumber(transaction.amount)
-    );
-    if (isCancelled()) return;
-    await transactionBuilder.sendToAddress(amount, recipient);
-    if (isCancelled()) return;
-  }
-
-  await transactionBuilder.pickInputs(
-    utxoStrategy.strategy,
-    0
-    /* not used, out of int32 range issue. patched in signature time. */
-  );
-  if (isCancelled()) return;
-  await transactionBuilder.setFeesPerByte(fees);
-  if (isCancelled()) return;
-  const builded = await transactionBuilder.build();
-  if (isCancelled()) return;
-  return builded;
-}
-
-export default bitcoinBuildTransaction;

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

@@ -1,27 +0,0 @@
-import { avoidDups } from "./libcore-getAccountNetworkInfo";
-import { BigNumber } from "bignumber.js";
-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/libcore-getAccountNetworkInfo.ts

@@ -1,50 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { NetworkInfo } from "./types";
-import type { Account } from "../../types";
-import type { CoreAccount } from "../../libcore/types";
-import { promiseAllBatched } from "../../promise";
-import { libcoreBigIntToBigNumber } from "../../libcore/buildBigNumber";
-type Input = {
-  coreAccount: CoreAccount;
-  account: Account;
-};
-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;
-}
-
-async function bitcoin({ coreAccount }: Input): Promise<NetworkInfo> {
-  const bitcoinLikeAccount = await coreAccount.asBitcoinLikeAccount();
-  const bigInts = await bitcoinLikeAccount.getFees();
-  const bigNumbers = await promiseAllBatched(
-    10,
-    bigInts,
-    libcoreBigIntToBigNumber
-  );
-  const normalized = avoidDups(
-    bigNumbers.map((bn) => bn.div(1000).integerValue(BigNumber.ROUND_CEIL))
-  );
-  const feeItems = {
-    items: normalized.map((feePerByte, i) => ({
-      key: String(i),
-      speed: speeds[i],
-      feePerByte,
-    })),
-    defaultFeePerByte:
-      normalized[Math.floor(normalized.length / 2)] || new BigNumber(0),
-  };
-  return {
-    family: "bitcoin",
-    feeItems,
-  };
-}
-
-export default bitcoin;

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

@@ -1,67 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-import buildTransaction from "./libcore-buildTransaction";
-import {
-  parseBitcoinOutput,
-  parseBitcoinInput,
-  perCoinLogic,
-} from "./transaction";
-import { promiseAllBatched } from "../../promise";
-import type { BitcoinInput, BitcoinOutput } from "./types";
-
-async function bitcoin(arg: any): Promise<{
-  estimatedFees: BigNumber;
-  value: BigNumber;
-  txInputs: BitcoinInput[];
-  txOutputs: BitcoinOutput[];
-} | void> {
-  const builded = await buildTransaction(arg);
-  if (!builded) return;
-  const feesAmount = await builded.getFees();
-
-  if (!feesAmount) {
-    throw new Error("getFeesForTransaction: fees should not be undefined");
-  }
-
-  const estimatedFees = await libcoreAmountToBigNumber(feesAmount);
-  // TODO we don't have a getValue on bitcoin
-  const value = new BigNumber(0);
-  const inputs = await builded.getInputs();
-  let txInputs: BitcoinInput[] = await promiseAllBatched(
-    4,
-    inputs,
-    parseBitcoinInput
-  );
-  const outputs = await builded.getOutputs();
-  let txOutputs: BitcoinOutput[] = await promiseAllBatched(
-    4,
-    outputs,
-    parseBitcoinOutput
-  );
-  const { account } = arg;
-  const perCoin = perCoinLogic[account.currency.id];
-
-  if (perCoin) {
-    const { syncReplaceAddress } = perCoin;
-
-    if (syncReplaceAddress) {
-      txInputs = txInputs.map((i) => ({
-        ...i,
-        address: syncReplaceAddress(account, i.address as string),
-      }));
-      txOutputs = txOutputs.map((o) => ({
-        ...o,
-        address: o.address && syncReplaceAddress(account, o.address),
-      }));
-    }
-  }
-
-  return {
-    estimatedFees,
-    value,
-    txInputs,
-    txOutputs,
-  };
-}
-
-export default bitcoin;

package/src/families/bitcoin/libcore-postBuildAccount.ts

@@ -1,70 +0,0 @@
-import { log } from "@ledgerhq/logs";
-import type { Account } from "../../types";
-import type { BitcoinResources } from "./types";
-import type { CoreAccount } from "../../libcore/types";
-import { SatStackDescriptorNotImported } from "../../errors";
-import { promiseAllBatched } from "../../promise";
-import { parseBitcoinUTXO, perCoinLogic } from "./transaction";
-import { isSatStackEnabled, checkDescriptorExists } from "./satstack";
-import { inferDescriptorFromAccount } from "./descriptor";
-
-const postBuildAccount = async ({
-  account,
-  coreAccount,
-}: {
-  account: Account;
-  coreAccount: CoreAccount;
-}): Promise<Account> => {
-  if (isSatStackEnabled() && account.currency.id === "bitcoin") {
-    const inferred = inferDescriptorFromAccount(account);
-
-    if (inferred) {
-      const exists = await checkDescriptorExists(inferred.internal);
-
-      if (!exists) {
-        throw new SatStackDescriptorNotImported();
-      }
-    }
-  }
-
-  log("bitcoin/post-buildAccount", "bitcoinResources");
-  const bitcoinLikeAccount = await coreAccount.asBitcoinLikeAccount();
-  const count = await bitcoinLikeAccount.getUTXOCount();
-  const objects = await bitcoinLikeAccount.getUTXO(0, count);
-  const utxos = await promiseAllBatched(6, objects, parseBitcoinUTXO);
-  const perCoin = perCoinLogic[account.currency.id];
-  let bitcoinResources: BitcoinResources = {
-    ...account.bitcoinResources,
-    utxos,
-    walletAccount: undefined,
-  };
-
-  if (perCoin) {
-    if (perCoin.postBuildBitcoinResources) {
-      bitcoinResources = perCoin.postBuildBitcoinResources(
-        account,
-        bitcoinResources
-      );
-    }
-
-    const { syncReplaceAddress } = perCoin;
-
-    if (syncReplaceAddress) {
-      account.freshAddress = syncReplaceAddress(account, account.freshAddress);
-      account.freshAddresses = account.freshAddresses.map((a) => ({
-        ...a,
-        address: syncReplaceAddress(account, a.address),
-      }));
-      bitcoinResources.utxos = bitcoinResources.utxos.map((u) => ({
-        ...u,
-        address: u.address && syncReplaceAddress(account, u.address),
-      }));
-    }
-  }
-
-  account.bitcoinResources = bitcoinResources;
-  log("bitcoin/post-buildAccount", "bitcoinResources DONE");
-  return account;
-};
-
-export default postBuildAccount;

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

@@ -1,227 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import Btc from "@ledgerhq/hw-app-btc";
-import { log } from "@ledgerhq/logs";
-import { isSegwitDerivationMode } from "../../derivation";
-import type {
-  CoreBitcoinLikeTransaction,
-  CoreBitcoinLikeInput,
-  CoreBitcoinLikeOutput,
-  Transaction,
-} from "./types";
-import type { Operation } from "../../types";
-import { promiseAllBatched } from "../../promise";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-import { makeSignOperation } from "../../libcore/signOperation";
-import buildTransaction from "./libcore-buildTransaction";
-import {
-  parseBitcoinOutput,
-  isChangeOutput,
-  perCoinLogic,
-} from "./transaction";
-
-async function signTransaction({
-  account,
-  isCancelled,
-  transport,
-  currency,
-  coreCurrency,
-  transaction,
-  coreTransaction,
-  derivationMode,
-  onDeviceStreaming,
-  onDeviceSignatureRequested,
-  onDeviceSignatureGranted,
-}) {
-  log("hw", `signTransaction ${currency.id} for account ${account.id}`);
-  const perCoin = perCoinLogic[currency.id];
-  const networkParams = await coreCurrency.getBitcoinLikeNetworkParameters();
-  if (isCancelled()) return;
-  const sigHashTypeHex = await networkParams.getSigHash();
-  const sigHashType = parseInt(sigHashTypeHex, 16);
-
-  if (isNaN(sigHashType)) {
-    throw new Error("sigHashType should not be NaN");
-  }
-
-  if (isCancelled()) return;
-  const hasTimestamp = await networkParams.getUsesTimestampedTransaction();
-  if (isCancelled()) return;
-  const hwApp = new Btc(transport);
-  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 hasExtraData = perCoin?.hasExtraData || false;
-  const rawInputs: CoreBitcoinLikeInput[] = await coreTransaction.getInputs();
-  if (isCancelled()) return;
-  const inputs: any[] = await promiseAllBatched(
-    5,
-    rawInputs,
-    async (input, i) => {
-      const hexPreviousTransaction = await input.getPreviousTransaction();
-      log("libcore", "splitTransaction " + String(hexPreviousTransaction));
-      // v1 of XST txs have timestamp but not v2
-      const inputHasTimestamp =
-        (currency.id === "stealthcoin" &&
-          hexPreviousTransaction.slice(0, 2) === "01") ||
-        hasTimestamp;
-      log("hw", `splitTransaction`, {
-        hexPreviousTransaction,
-        supportsSegwit: currency.supportsSegwit,
-        inputHasTimestamp,
-        hasExtraData,
-        additionals,
-      });
-      const previousTransaction = hwApp.splitTransaction(
-        hexPreviousTransaction,
-        currency.supportsSegwit,
-        inputHasTimestamp,
-        hasExtraData,
-        additionals
-      );
-      const outputIndex = await input.getPreviousOutputIndex();
-      // NB libcore's sequence is not used because int32 limit issue
-      const sequence = transaction.rbf ? 0 : 0xffffffff;
-      log("libcore", "inputs[" + i + "]", {
-        previousTransaction: JSON.stringify(previousTransaction),
-        outputIndex,
-        sequence,
-      });
-      return [
-        previousTransaction,
-        outputIndex,
-        undefined, // we don't use that TODO: document
-        sequence,
-      ];
-    }
-  );
-  if (isCancelled()) return;
-  const associatedKeysets = await promiseAllBatched(
-    5,
-    rawInputs,
-    async (input) => {
-      const derivationPaths = await input.getDerivationPath();
-      const [first] = derivationPaths;
-      if (!first) throw new Error("unexpected empty derivationPaths");
-      const r = await first.toString();
-      return r;
-    }
-  );
-  if (isCancelled()) return;
-  const outputs: CoreBitcoinLikeOutput[] = await coreTransaction.getOutputs();
-  if (isCancelled()) return;
-  let changePath;
-
-  for (const o of outputs) {
-    const output = await parseBitcoinOutput(o);
-
-    if (isChangeOutput(output)) {
-      changePath = output.path || undefined;
-    }
-  }
-
-  const outputScriptHex = await coreTransaction.serializeOutputs();
-  if (isCancelled()) return;
-  const initialTimestamp = hasTimestamp
-    ? await coreTransaction.getTimestamp()
-    : undefined;
-  if (isCancelled()) return;
-  // FIXME
-  // 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))
-  let lockTime;
-
-  // 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;
-  }
-
-  log("hw", `createPaymentTransactionNew`, {
-    associatedKeysets,
-    changePath,
-    outputScriptHex,
-    lockTime,
-    sigHashType,
-    segwit: isSegwitDerivationMode(derivationMode),
-    initialTimestamp: initialTimestamp || undefined,
-    additionals,
-    expiryHeight: expiryHeight && expiryHeight.toString("hex"),
-  });
-  const signature = await hwApp.createPaymentTransactionNew({
-    inputs,
-    associatedKeysets,
-    changePath,
-    outputScriptHex,
-    lockTime,
-    sigHashType,
-    segwit: isSegwitDerivationMode(derivationMode),
-    initialTimestamp: initialTimestamp || undefined,
-    additionals,
-    expiryHeight,
-    onDeviceSignatureGranted,
-    onDeviceSignatureRequested,
-    onDeviceStreaming,
-  });
-  const sendersInput = await coreTransaction.getInputs();
-  const senders = (
-    await promiseAllBatched(5, sendersInput, (senderInput: any) =>
-      senderInput.getAddress()
-    )
-  ).filter(Boolean) as string[];
-  const recipientsOutput = await coreTransaction.getOutputs();
-  const recipients = (
-    await promiseAllBatched(5, recipientsOutput, (recipientOutput: any) =>
-      recipientOutput.getAddress()
-    )
-  ).filter(Boolean) as string[];
-  const coreAmountFees = await coreTransaction.getFees();
-
-  if (!coreAmountFees) {
-    throw new Error("signAndBroadcast: fees should not be undefined");
-  }
-
-  const fee = await libcoreAmountToBigNumber(coreAmountFees);
-  const txHash = ""; // will be resolved in broadcast()
-
-  const operation: Operation = {
-    id: `${account.id}-${txHash}-OUT`,
-    hash: txHash,
-    type: "OUT",
-    value: new BigNumber(transaction.amount).plus(fee),
-    fee,
-    blockHash: null,
-    blockHeight: null,
-    senders,
-    recipients,
-    accountId: account.id,
-    date: new Date(),
-    extra: {},
-  };
-  return {
-    operation,
-    expirationDate: null,
-    signature,
-  };
-}
-
-export default makeSignOperation<Transaction, CoreBitcoinLikeTransaction>({
-  buildTransaction,
-  signTransaction,
-});