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

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

@@ -1,362 +0,0 @@
-import { $Shape } from "utility-types";
-import type {
-  TX,
-  Currency,
-  Input as WalletInput,
-  Output as WalletOutput,
-} from "@ledgerhq/wallet-btc";
-import { DerivationModes as WalletDerivationModes } from "@ledgerhq/wallet-btc";
-import { BigNumber } from "bignumber.js";
-import Btc from "@ledgerhq/hw-app-btc";
-import { log } from "@ledgerhq/logs";
-import type {
-  Account,
-  Operation,
-  OperationType,
-  DerivationMode,
-} from "../../types";
-import type { GetAccountShape } from "../../bridge/jsHelpers";
-import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
-import { findCurrencyExplorer } from "../../api/Ledger";
-import { encodeOperationId } from "../../operation";
-import { BitcoinOutput } from "./types";
-import { perCoinLogic } from "./logic";
-import wallet from "./wallet";
-
-// Map LL's DerivationMode to wallet-btc's
-const toWalletDerivationMode = (
-  mode: DerivationMode
-): WalletDerivationModes => {
-  switch (mode) {
-    case "segwit":
-    case "segwit_on_legacy":
-    case "segwit_unsplit":
-    case "bch_on_bitcoin_segwit":
-    case "vertcoin_128_segwit":
-      return WalletDerivationModes.SEGWIT;
-
-    case "native_segwit":
-      return WalletDerivationModes.NATIVE_SEGWIT;
-
-    default:
-      return WalletDerivationModes.LEGACY;
-  }
-};
-
-// Map LL's currency ID to wallet-btc's Account.params.network
-const toWalletNetwork = (currencyId: string): "testnet" | "mainnet" => {
-  return ["bitcoin_testnet"].includes(currencyId) ? "testnet" : "mainnet";
-};
-
-// Map wallet-btc's Output to LL's BitcoinOutput
-const fromWalletUtxo = (utxo: WalletOutput): BitcoinOutput => {
-  return {
-    hash: utxo.output_hash,
-    outputIndex: utxo.output_index,
-    blockHeight: utxo.block_height,
-    address: utxo.address,
-    value: new BigNumber(utxo.value),
-    rbf: utxo.rbf,
-    isChange: false, // wallet-btc limitation: doesn't provide it
-    path: "",
-  };
-};
-
-// wallet-btc limitation: returns all transactions twice (for each side of the tx)
-// so we need to deduplicate them...
-const deduplicateOperations = (
-  operations: (Operation | undefined)[]
-): Operation[] => {
-  const seen = {};
-  const out: Operation[] = [];
-  let j = 0;
-
-  for (const operation of operations) {
-    if (operation) {
-      if (seen[operation.id] !== 1) {
-        seen[operation.id] = 1;
-        out[j++] = operation;
-      }
-    }
-  }
-
-  return out;
-};
-
-const mapTxToOperations = (
-  tx: TX,
-  currencyId: string,
-  accountId: string,
-  accountAddresses: string[],
-  changeAddresses: string[]
-): $Shape<Operation[]> => {
-  const operations: Operation[] = [];
-  const hash = tx.hash;
-  const fee = new BigNumber(tx.fees);
-  const blockHeight = tx.block?.height;
-  const blockHash = tx.block?.hash;
-  const date = new Date(tx.block?.time || tx.received_at);
-  const senders: string[] = [];
-  const recipients: string[] = [];
-  let type: OperationType = "OUT";
-  let value = new BigNumber(0);
-  const hasFailed = false;
-  const accountInputs: WalletInput[] = [];
-  const accountOutputs: WalletOutput[] = [];
-  const syncReplaceAddress = perCoinLogic[currencyId]?.syncReplaceAddress;
-
-  for (const input of tx.inputs) {
-    if (input.address) {
-      senders.push(
-        syncReplaceAddress ? syncReplaceAddress(input.address) : input.address
-      );
-
-      if (input.value) {
-        if (accountAddresses.includes(input.address)) {
-          // This address is part of the account
-          value = value.plus(input.value);
-          accountInputs.push(input);
-        }
-      }
-    }
-  }
-
-  // All inputs of a same transaction have the same sequence
-  const transactionSequenceNumber =
-    (accountInputs.length > 0 && accountInputs[0].sequence) || undefined;
-  const hasSpentNothing = value.eq(0);
-
-  for (const output of tx.outputs) {
-    if (output.address) {
-      if (accountAddresses.includes(output.address)) {
-        accountOutputs.push(output);
-
-        if (changeAddresses.includes(output.address)) {
-          if (
-            (recipients.length === 0 &&
-              output.output_hash ===
-                tx.outputs[tx.outputs.length - 1].output_hash) || // Is that condition safe?
-            hasSpentNothing
-          ) {
-            recipients.push(
-              syncReplaceAddress
-                ? syncReplaceAddress(output.address)
-                : output.address
-            );
-          }
-        } else {
-          recipients.push(
-            syncReplaceAddress
-              ? syncReplaceAddress(output.address)
-              : output.address
-          );
-        }
-      } else {
-        recipients.push(
-          syncReplaceAddress
-            ? syncReplaceAddress(output.address)
-            : output.address
-        );
-      }
-    }
-  }
-
-  if (accountInputs.length > 0) {
-    // It's a SEND operation
-    for (const output of accountOutputs) {
-      if (changeAddresses.includes(output.address)) {
-        value = value.minus(output.value);
-      }
-    }
-
-    type = "OUT";
-    operations.push({
-      id: encodeOperationId(accountId, hash, type),
-      hash,
-      type,
-      value,
-      fee,
-      senders,
-      recipients,
-      blockHeight,
-      blockHash,
-      transactionSequenceNumber,
-      accountId,
-      date,
-      hasFailed,
-      extra: {},
-    });
-  }
-
-  if (accountOutputs.length > 0) {
-    // It's a RECEIVE operation
-    const filterChangeAddresses = !!accountInputs.length;
-    let accountOutputCount = 0;
-    let finalAmount = new BigNumber(0);
-
-    for (const output of accountOutputs) {
-      if (!filterChangeAddresses || !changeAddresses.includes(output.address)) {
-        finalAmount = finalAmount.plus(output.value);
-        accountOutputCount += 1;
-      }
-    }
-
-    if (accountOutputCount > 0) {
-      value = finalAmount;
-      type = "IN";
-      operations.push({
-        id: encodeOperationId(accountId, hash, type),
-        hash,
-        type,
-        value,
-        fee,
-        senders,
-        recipients,
-        blockHeight,
-        blockHash,
-        transactionSequenceNumber,
-        accountId,
-        date,
-        hasFailed,
-        extra: {},
-      });
-    }
-  }
-
-  return operations;
-};
-
-const getAccountShape: GetAccountShape = async (info) => {
-  const {
-    transport,
-    currency,
-    id: accountId,
-    index,
-    derivationPath,
-    derivationMode,
-    initialAccount,
-  } = info;
-  const paramXpub = initialAccount?.xpub;
-
-  // In case we get a full derivation path, extract the seed identification part
-  // 44'/0'/0'/0/0 --> 44'/0'
-  // FIXME Only the CLI provides a full derivationPath: why?
-  const rootPath = derivationPath.split("/", 2).join("/");
-
-  const walletNetwork = toWalletNetwork(currency.id);
-  const walletDerivationMode = toWalletDerivationMode(derivationMode);
-  const explorer = findCurrencyExplorer(currency);
-  if (!explorer) {
-    throw new Error(`No explorer found for currency ${currency.name}`);
-  }
-  if (explorer.version !== "v2" && explorer.version !== "v3") {
-    throw new Error(`Unsupported explorer version ${explorer.version}`);
-  }
-
-  const walletAccount = initialAccount?.bitcoinResources?.serializedData
-    ? await wallet.importFromSerializedAccount(
-        initialAccount.bitcoinResources.serializedData
-      )
-    : await wallet.generateAccount({
-        btc: (!paramXpub && transport && new Btc(transport)) || undefined,
-        xpub: paramXpub,
-        path: rootPath,
-        index,
-        currency: <Currency>currency.id,
-        network: walletNetwork,
-        derivationMode: walletDerivationMode,
-        explorer: explorer && `ledger${explorer.version}`,
-        explorerURI: `${explorer.endpoint}/blockchain/${explorer.version}/${explorer.id}`,
-        storage: "mock",
-        storageParams: [],
-      });
-  const xpub = paramXpub || walletAccount.xpub.xpub;
-  const oldOperations = initialAccount?.operations || [];
-  await wallet.syncAccount(walletAccount);
-  const balance = await wallet.getAccountBalance(walletAccount);
-  const currentBlock = await walletAccount.xpub.explorer.getCurrentBlock();
-  const blockHeight = currentBlock?.height;
-
-  // @ts-expect-error return from wallet-btc should be typed
-  const { txs: transactions } = await wallet.getAccountTransactions(
-    walletAccount
-  );
-  const accountAddressesWithInfo = await walletAccount.xpub.getXpubAddresses();
-  const accountAddresses = accountAddressesWithInfo
-    ? accountAddressesWithInfo.map((a) => a.address)
-    : [];
-  const changeAddressesWithInfo =
-    await walletAccount.xpub.storage.getUniquesAddresses({
-      account: 1,
-    });
-  const changeAddresses = changeAddressesWithInfo
-    ? changeAddressesWithInfo.map((a) => a.address)
-    : [];
-  const newOperations = transactions
-    ?.map((tx) =>
-      mapTxToOperations(
-        tx,
-        currency.id,
-        accountId,
-        accountAddresses,
-        changeAddresses
-      )
-    )
-    .flat();
-  const newUniqueOperations = deduplicateOperations(newOperations);
-  const operations = mergeOps(oldOperations, newUniqueOperations);
-  const rawUtxos = await wallet.getAccountUnspentUtxos(walletAccount);
-  const utxos = rawUtxos.map(fromWalletUtxo);
-  const serializedData = await wallet.exportToSerializedAccount(walletAccount);
-  return {
-    id: accountId,
-    xpub,
-    balance,
-    spendableBalance: balance,
-    operations,
-    operationsCount: operations.length,
-    blockHeight,
-    bitcoinResources: {
-      utxos,
-      serializedData,
-    },
-  };
-};
-
-const postSync = (initial: Account, synced: Account) => {
-  log("bitcoin/postSync", "bitcoinResources");
-  const perCoin = perCoinLogic[synced.currency.id];
-
-  if (perCoin) {
-    const { postBuildBitcoinResources, syncReplaceAddress } = perCoin;
-
-    if (postBuildBitcoinResources) {
-      synced.bitcoinResources = postBuildBitcoinResources(
-        synced,
-        synced.bitcoinResources
-      );
-    }
-
-    if (syncReplaceAddress) {
-      synced.freshAddress = syncReplaceAddress(synced.freshAddress);
-      synced.freshAddresses = synced.freshAddresses.map((a) => ({
-        ...a,
-        address: syncReplaceAddress(a.address),
-      }));
-      if (synced.bitcoinResources) {
-        synced.bitcoinResources.utxos = synced.bitcoinResources?.utxos.map(
-          (u) => ({
-            ...u,
-            address: u.address && syncReplaceAddress(u.address),
-          })
-        );
-      }
-    }
-  }
-
-  log("bitcoin/postSync", "bitcoinResources DONE");
-  return synced;
-};
-
-export const scanAccounts = makeScanAccounts(getAccountShape);
-export const sync = makeSync(getAccountShape, postSync);

package/src/families/bitcoin/logic.ts

@@ -1,253 +0,0 @@
-import cashaddr from "cashaddrjs";
-import bchaddr from "bchaddrjs";
-import { isValidAddress } from "@ledgerhq/wallet-btc";
-import { RecipientRequired, InvalidAddress } from "@ledgerhq/errors";
-import type { Account, CryptoCurrency, CryptoCurrencyIds } from "./../../types";
-import type {
-  BitcoinOutput,
-  BitcoinResources,
-  Transaction,
-  NetworkInfo,
-  UtxoStrategy,
-  CoreBitcoinLikeOutput,
-  CoreBitcoinLikeInput,
-  BitcoinInput,
-} from "./types";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-
-// correspond ~ to min relay fees but determined empirically for a tx to be accepted by network
-const minFees = {
-  bitcoin: 1000,
-  bitcoin_gold: 1000,
-  pivx: 2000,
-  stakenet: 1000,
-  stealthcoin: 2000,
-  qtum: 4000,
-  stratis: 2000,
-  vertcoin: 2000,
-  viacoin: 2000,
-  peercoin: 2000,
-};
-export const getMinRelayFee = (currency: CryptoCurrency): number =>
-  minFees[currency.id] || 0;
-export const inferFeePerByte = (t: Transaction, networkInfo: NetworkInfo) => {
-  if (t.feesStrategy) {
-    const speed = networkInfo.feeItems.items.find(
-      (item) => t.feesStrategy === item.speed
-    );
-
-    if (!speed) {
-      return networkInfo.feeItems.defaultFeePerByte;
-    }
-
-    return speed.feePerByte;
-  }
-
-  return t.feePerByte || networkInfo.feeItems.defaultFeePerByte;
-};
-export const isValidRecipient = async (params: {
-  currency: CryptoCurrency;
-  recipient: string;
-}): Promise<Error | null | undefined> => {
-  if (!params.recipient) {
-    return Promise.reject(new RecipientRequired(""));
-  }
-
-  let valid: boolean;
-  try {
-    // Optimistically assume params.currency.id is an actual Currency
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore halp
-    valid = isValidAddress(params.recipient, params.currency.id);
-  } catch (e: any) {
-    // isValidAddress() will throw Error if c is not an actual Currency
-    return Promise.reject(new InvalidAddress(e.message));
-  }
-  if (!valid) {
-    return Promise.reject(
-      new InvalidAddress("Invalid address for currency " + params.currency.name)
-    );
-  }
-  return Promise.resolve(null);
-};
-export function isChangeOutput(output: BitcoinOutput): boolean {
-  if (!output.path) return false;
-  const p = output.path.split("/");
-  return p[p.length - 2] === "1";
-}
-
-type UTXOStatus =
-  | {
-      excluded: true;
-      reason: "pickUnconfirmedRBF" | "userExclusion";
-    }
-  | {
-      excluded: false;
-    };
-export const getUTXOStatus = (
-  utxo: BitcoinOutput,
-  utxoStrategy: UtxoStrategy
-): UTXOStatus => {
-  if (!utxoStrategy.pickUnconfirmedRBF && utxo.rbf && !utxo.blockHeight) {
-    return {
-      excluded: true,
-      reason: "pickUnconfirmedRBF",
-    };
-  }
-
-  if (
-    utxoStrategy.excludeUTXOs.some(
-      (u) => u.hash === utxo.hash && u.outputIndex === utxo.outputIndex
-    )
-  ) {
-    return {
-      excluded: true,
-      reason: "userExclusion",
-    };
-  }
-
-  return {
-    excluded: false,
-  };
-};
-
-const bchExplicit = (str: string): string => {
-  const explicit = str.includes(":") ? str : "bitcoincash:" + str;
-
-  try {
-    const { type } = cashaddr.decode(explicit);
-    if (type === "P2PKH") return explicit;
-  } catch (e) {
-    // ignore errors
-  }
-
-  return str;
-};
-
-type CoinLogic = {
-  hasExtraData?: boolean;
-  hasExpiryHeight?: boolean;
-  getAdditionals?: (arg0: { transaction: Transaction }) => string[];
-  asExplicitTransactionRecipient?: (arg0: string) => string;
-  onScreenTransactionRecipient?: (arg0: string) => string;
-  postBuildBitcoinResources?: (
-    arg0: Account,
-    arg1?: BitcoinResources
-  ) => BitcoinResources;
-  syncReplaceAddress?: (addr: string) => string;
-  injectGetAddressParams?: (arg0: Account) => any;
-};
-
-const bchToCashaddrAddressWithoutPrefix = (recipient) =>
-  recipient ? bchaddr.toCashAddress(recipient).split(":")[1] : recipient;
-
-export const perCoinLogic: Record<
-  CryptoCurrencyIds,
-  CoinLogic | null | undefined
-> = {
-  zencash: {
-    hasExtraData: true, // FIXME (legacy) investigate why we need this here and drop
-  },
-  zcash: {
-    hasExtraData: true,
-    hasExpiryHeight: true,
-    getAdditionals: () => ["sapling"], // FIXME (legacy) drop in ledgerjs. we always use sapling now for zcash & kmd
-  },
-  komodo: {
-    hasExtraData: true,
-    hasExpiryHeight: true,
-    getAdditionals: () => ["sapling"], // FIXME (legacy) drop in ledgerjs. we always use sapling now for zcash & kmd
-  },
-  decred: {
-    hasExpiryHeight: true,
-  },
-  bitcoin_gold: {
-    getAdditionals: () => ["bip143"],
-  },
-  bitcoin_cash: {
-    getAdditionals: ({ transaction }) => {
-      const additionals = ["bip143"];
-
-      if (bchExplicit(transaction.recipient).startsWith("bitcoincash:")) {
-        additionals.push("cashaddr");
-      }
-
-      return additionals;
-    },
-    // Due to minimal support, we need to return the explicit format of bitcoincash:.. if it's a P2PKH
-    asExplicitTransactionRecipient: bchExplicit,
-    // to represent what happens on the device, which do not display the bitcoincash: prefix
-    onScreenTransactionRecipient: (str: string): string => {
-      const prefix = "bitcoincash:";
-      return str.startsWith(prefix) ? str.slice(prefix.length) : str;
-    },
-    syncReplaceAddress: (addr) => bchToCashaddrAddressWithoutPrefix(addr),
-    injectGetAddressParams: () => ({
-      forceFormat: "cashaddr",
-    }),
-  },
-};
-
-// TODO vvvvv DEPRECATED, TO BE REMOVED vvvvv
-
-export async function parseBitcoinInput(
-  input: CoreBitcoinLikeInput
-): Promise<BitcoinInput> {
-  const address = await input.getAddress();
-  const rawValue = await input.getValue();
-  const value = rawValue ? await libcoreAmountToBigNumber(rawValue) : null;
-  const previousTxHash = await input.getPreviousTxHash();
-  const previousOutputIndex = await input.getPreviousOutputIndex();
-  return {
-    address,
-    value,
-    previousTxHash,
-    previousOutputIndex,
-  };
-}
-
-export async function parseBitcoinOutput(
-  output: CoreBitcoinLikeOutput
-): Promise<BitcoinOutput> {
-  let blockHeight = await output.getBlockHeight();
-
-  if (!blockHeight || blockHeight < 0) {
-    blockHeight = undefined;
-  }
-
-  const hash = await output.getTransactionHash();
-  const outputIndex = await output.getOutputIndex();
-  const address = await output.getAddress();
-  const derivationPath = await output.getDerivationPath();
-  let path;
-
-  if (derivationPath) {
-    const isDerivationPathNull = await derivationPath.isNull();
-
-    if (!isDerivationPathNull) {
-      path = await derivationPath.toString();
-    }
-  }
-
-  const value = await libcoreAmountToBigNumber(await output.getValue());
-  const rbf = false; // this is unsafe to generically call this at the moment. libcore segfault.
-
-  return {
-    hash,
-    outputIndex,
-    blockHeight,
-    address,
-    isChange: false,
-    path,
-    value,
-    rbf,
-  };
-}
-
-export async function parseBitcoinUTXO(
-  output: CoreBitcoinLikeOutput
-): Promise<BitcoinOutput> {
-  const utxo = await parseBitcoinOutput(output);
-  utxo.rbf = await output.isReplaceable();
-  return utxo;
-}