@ledgerhq/coin-bitcoin 0.4.0-next.0

package/src/js-synchronisation.ts

@@ -0,0 +1,256 @@
+import type { Currency, Output as WalletOutput } from "./wallet-btc";
+import { DerivationModes as WalletDerivationModes } from "./wallet-btc";
+import { BigNumber } from "bignumber.js";
+import { log } from "@ledgerhq/logs";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import {
+  isSegwitDerivationMode,
+  isNativeSegwitDerivationMode,
+  isTaprootDerivationMode,
+} from "@ledgerhq/coin-framework/derivation";
+import { BitcoinAccount, BitcoinOutput } from "./types";
+import { perCoinLogic } from "./logic";
+import wallet from "./wallet-btc";
+import { mapTxToOperations } from "./logic";
+import { Account, DerivationMode, Operation } from "@ledgerhq/types-live";
+import { decodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { BitcoinXPub, SignerContext } from "./signer";
+
+// Map LL's DerivationMode to wallet-btc's
+const toWalletDerivationMode = (mode: DerivationMode): WalletDerivationModes => {
+  if (isTaprootDerivationMode(mode)) {
+    return WalletDerivationModes.TAPROOT;
+  }
+  if (isNativeSegwitDerivationMode(mode)) {
+    return WalletDerivationModes.NATIVE_SEGWIT;
+  }
+  if (isSegwitDerivationMode(mode)) {
+    return WalletDerivationModes.SEGWIT;
+  }
+  return WalletDerivationModes.LEGACY;
+};
+
+// Map LL's currency ID to wallet-btc's Account.params.network
+const toWalletNetwork = (currencyId: string): "testnet" | "mainnet" => {
+  return getCryptoCurrencyById(currencyId).isTestnetFor ? "testnet" : "mainnet";
+};
+
+// Map wallet-btc's Output to LL's BitcoinOutput
+const fromWalletUtxo = (utxo: WalletOutput, changeAddresses: Set<string>): 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: changeAddresses.has(utxo.address),
+  };
+};
+
+// 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 = new Set();
+  const out: Operation[] = [];
+  let j = 0;
+
+  for (const operation of operations) {
+    if (operation) {
+      if (!seen.has(operation.id)) {
+        seen.add(operation.id);
+        out[j++] = operation;
+      }
+    }
+  }
+
+  return out;
+};
+
+// For performance monitoring
+export type StartSpan = (
+  op: string,
+  description?: string,
+  rest?: {
+    tags?: any;
+    data?: any;
+  },
+) => {
+  finish: () => void;
+};
+export function makeGetAccountShape(
+  signerContext: SignerContext,
+  startSpan: StartSpan,
+): GetAccountShape {
+  return async info => {
+    let span;
+    const { currency, index, derivationPath, derivationMode, initialAccount, deviceId } = info;
+    // 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 accountPath = `${rootPath}/${index}'`;
+
+    const paramXpub = initialAccount ? decodeAccountId(initialAccount.id).xpubOrAddress : undefined;
+
+    const xpub = await generateXpubIfNeeded(paramXpub, {
+      deviceId,
+      currency,
+      signerContext,
+      accountPath,
+    });
+
+    const accountId = encodeAccountId({
+      type: "js",
+      version: "2",
+      currencyId: currency.id,
+      xpubOrAddress: xpub,
+      derivationMode,
+    });
+
+    const walletNetwork = toWalletNetwork(currency.id);
+    const walletDerivationMode = toWalletDerivationMode(derivationMode as DerivationMode);
+
+    span = startSpan("sync", "generateAccount");
+    const walletAccount =
+      (initialAccount as BitcoinAccount)?.bitcoinResources?.walletAccount ||
+      (await wallet.generateAccount(
+        {
+          xpub,
+          path: rootPath,
+          index,
+          currency: <Currency>currency.id,
+          network: walletNetwork,
+          derivationMode: walletDerivationMode,
+        },
+        currency,
+      ));
+    span.finish();
+
+    const oldOperations = initialAccount?.operations || [];
+    const currentBlock = await walletAccount.xpub.explorer.getCurrentBlock();
+
+    const blockHeight = currentBlock?.height;
+    await wallet.syncAccount(walletAccount, blockHeight);
+
+    const balance = await wallet.getAccountBalance(walletAccount);
+    span = startSpan("sync", "getAccountTransactions");
+    const { txs: transactions } = await wallet.getAccountTransactions(walletAccount);
+    span.finish();
+
+    span = startSpan("sync", "getXpubAddresses");
+    const accountAddresses: Set<string> = new Set<string>();
+    const accountAddressesWithInfo = await walletAccount.xpub.getXpubAddresses();
+    accountAddressesWithInfo.forEach(a => accountAddresses.add(a.address));
+    span.finish();
+
+    span = startSpan("sync", "getUniquesAddresses");
+    const changeAddresses: Set<string> = new Set<string>();
+    const changeAddressesWithInfo = await walletAccount.xpub.storage.getUniquesAddresses({
+      account: 1,
+    });
+    changeAddressesWithInfo.forEach(a => changeAddresses.add(a.address));
+    span.finish();
+
+    span = startSpan("sync", "mapTxToOperations");
+    const newOperations = transactions
+      ?.map(tx => mapTxToOperations(tx, currency.id, accountId, accountAddresses, changeAddresses))
+      .flat();
+    span.finish();
+
+    span = startSpan("sync", "unify operations");
+    const newUniqueOperations = deduplicateOperations(newOperations);
+    const operations = mergeOps(oldOperations, newUniqueOperations);
+    span.finish();
+
+    span = startSpan("sync", "gather utxos");
+    const rawUtxos = await wallet.getAccountUnspentUtxos(walletAccount);
+    const utxos = rawUtxos.map(utxo => fromWalletUtxo(utxo, changeAddresses));
+    span.finish();
+
+    return {
+      id: accountId,
+      xpub,
+      balance,
+      spendableBalance: balance,
+      operations,
+      operationsCount: operations.length,
+      freshAddress: walletAccount.xpub.freshAddress,
+      freshAddressPath: `${accountPath}/0/${walletAccount.xpub.freshAddressIndex}`,
+      blockHeight,
+      bitcoinResources: {
+        utxos,
+        walletAccount,
+      },
+    };
+  };
+}
+
+type XpubGenerateParameter = {
+  deviceId?: string;
+  currency: CryptoCurrency;
+  signerContext: SignerContext;
+  accountPath: string;
+};
+async function generateXpubIfNeeded(
+  providedXpub: string | undefined,
+  params: XpubGenerateParameter,
+): Promise<BitcoinXPub> {
+  if (providedXpub) {
+    return Promise.resolve(providedXpub);
+  }
+
+  // Xpub not provided, generate it using the hwapp
+
+  const { deviceId, currency, signerContext, accountPath } = params;
+  if (deviceId === undefined || deviceId === null) {
+    throw new Error("deviceId required to generate the xpub");
+  }
+  const { bitcoinLikeInfo } = currency;
+  const { XPUBVersion: xpubVersion } = bitcoinLikeInfo as {
+    // FIXME It's supposed to be optional
+    //XPUBVersion?: number;
+    XPUBVersion: number;
+  };
+
+  return signerContext(deviceId, currency, signer =>
+    signer.getWalletXpub({
+      path: accountPath,
+      xpubVersion,
+    }),
+  );
+}
+
+export const postSync = (initial: Account, synced: Account) => {
+  log("bitcoin/postSync", "bitcoinResources");
+  const perCoin = perCoinLogic[synced.currency.id];
+  const syncedBtc = synced as BitcoinAccount;
+  if (perCoin) {
+    const { postBuildBitcoinResources, syncReplaceAddress } = perCoin;
+
+    if (postBuildBitcoinResources) {
+      syncedBtc.bitcoinResources = postBuildBitcoinResources(syncedBtc, syncedBtc.bitcoinResources);
+    }
+
+    if (syncReplaceAddress) {
+      syncedBtc.freshAddress = syncReplaceAddress(syncedBtc.freshAddress);
+      syncedBtc.freshAddresses = syncedBtc.freshAddresses.map(a => ({
+        ...a,
+        address: syncReplaceAddress(a.address),
+      }));
+      if (syncedBtc.bitcoinResources) {
+        syncedBtc.bitcoinResources.utxos = syncedBtc.bitcoinResources?.utxos.map(u => ({
+          ...u,
+          address: u.address && syncReplaceAddress(u.address),
+        }));
+      }
+    }
+  }
+
+  log("bitcoin/postSync", "bitcoinResources DONE");
+  return syncedBtc;
+};

package/src/logic.ts

@@ -0,0 +1,318 @@
+import cashaddr from "cashaddrjs";
+import { Currency, isValidAddress } from "./wallet-btc";
+import { RecipientRequired, InvalidAddress } from "@ledgerhq/errors";
+import type {
+  BitcoinOutput,
+  BitcoinResources,
+  Transaction,
+  NetworkInfo,
+  UtxoStrategy,
+} from "./types";
+import { $Shape } from "utility-types";
+import type { TX, Input as WalletInput, Output as WalletOutput } from "./wallet-btc";
+import { BigNumber } from "bignumber.js";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import type { CryptoCurrency, CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
+import type { Account, Operation, OperationType } from "@ledgerhq/types-live";
+
+// correspond ~ to min relay fees but determined empirically for a tx to be accepted by network
+const minFees: Partial<Record<CryptoCurrencyId | "LBRY" | "groestcoin" | "osmo", number>> = {
+  bitcoin: 1000,
+  bitcoin_gold: 1000,
+  pivx: 2000,
+  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): BigNumber => {
+  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
+    valid = isValidAddress(params.recipient, <Currency>params.currency.id);
+  } catch (e: any) {
+    // isValidAddress() will throw Error if c is not an actual Currency
+    valid = false;
+  }
+  if (!valid) {
+    return Promise.reject(
+      new InvalidAddress("", {
+        currencyName: params.currency.name,
+      }),
+    );
+  }
+  return Promise.resolve(null);
+};
+type UTXOStatus =
+  | {
+      excluded: true;
+      reason: "pickPendingUtxo" | "userExclusion";
+    }
+  | {
+      excluded: false;
+    };
+export const getUTXOStatus = (utxo: BitcoinOutput, utxoStrategy: UtxoStrategy): UTXOStatus => {
+  if (!utxo.blockHeight && !utxo.isChange) {
+    // exclude pending and not change utxo
+    return {
+      excluded: true,
+      reason: "pickPendingUtxo",
+    };
+  }
+  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;
+};
+
+export const bchToCashaddrAddressWithoutPrefix = (recipient: string): string =>
+  recipient ? recipient.substring(recipient.indexOf(":") + 1) : recipient;
+
+export const perCoinLogic: Partial<
+  Record<CryptoCurrencyId | "LBRY" | "groestcoin" | "osmo", CoinLogic>
+> = {
+  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",
+    }),
+  },
+};
+
+export const mapTxToOperations = (
+  tx: TX,
+  currencyId: CryptoCurrencyId | "LBRY" | "groestcoin" | "osmo",
+  accountId: string,
+  accountAddresses: Set<string>,
+  changeAddresses: Set<string>,
+): $Shape<Operation[]> => {
+  const operations: Operation[] = [];
+  const txId = tx.id;
+  const fee = new BigNumber(tx.fees ?? 0);
+  const blockHeight = tx.block?.height;
+  const blockHash = tx.block?.hash;
+  const date = new Date(tx.block?.time || tx.received_at);
+  const senders = new Set<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.add(syncReplaceAddress ? syncReplaceAddress(input.address) : input.address);
+
+      if (input.value) {
+        if (accountAddresses.has(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);
+
+  // Change output is always the last one
+  const changeOutputIndex =
+    tx.outputs.length === 0
+      ? 0
+      : tx.outputs.map(o => o.output_index).reduce((p, c) => (p > c ? p : c));
+
+  for (const output of tx.outputs) {
+    // ledger explorer returns "unknown" as recipient for OP_RETURN outputs, we don't want to display it in our UI
+    if (output.address && !output.address.includes("unknown")) {
+      if (!accountAddresses.has(output.address)) {
+        // The output doesn't belong to this account
+        if (
+          accountInputs.length > 0 && // It's a SEND operation
+          (tx.outputs.length === 1 || // The transaction has only 1 output
+            output.output_index < changeOutputIndex) // The output isn't the change output
+        ) {
+          recipients.push(syncReplaceAddress ? syncReplaceAddress(output.address) : output.address);
+        }
+      } else {
+        // The output belongs to this account
+        accountOutputs.push(output);
+
+        if (!changeAddresses.has(output.address)) {
+          // The output isn't a change output of this account
+          recipients.push(syncReplaceAddress ? syncReplaceAddress(output.address) : output.address);
+        } else {
+          // The output is a change output of this account,
+          // we count it as a recipient only in some special cases
+          if (
+            (recipients.length === 0 && output.output_index >= changeOutputIndex) ||
+            hasSpentNothing
+          ) {
+            recipients.push(
+              syncReplaceAddress ? syncReplaceAddress(output.address) : output.address,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  if (accountInputs.length > 0) {
+    // It's a SEND operation
+    for (const output of accountOutputs) {
+      if (changeAddresses.has(output.address)) {
+        value = value.minus(output.value);
+      }
+    }
+
+    type = "OUT";
+    operations.push({
+      id: encodeOperationId(accountId, txId, type),
+      hash: txId,
+      type,
+      value,
+      fee,
+      senders: Array.from(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.has(output.address)) {
+        finalAmount = finalAmount.plus(output.value);
+        accountOutputCount += 1;
+      }
+    }
+
+    if (accountOutputCount > 0) {
+      value = finalAmount;
+      type = "IN";
+      operations.push({
+        id: encodeOperationId(accountId, txId, type),
+        hash: txId,
+        type,
+        value,
+        fee,
+        senders: Array.from(senders),
+        recipients,
+        blockHeight,
+        blockHash,
+        transactionSequenceNumber,
+        accountId,
+        date,
+        hasFailed,
+        extra: {},
+      });
+    }
+  }
+
+  return operations;
+};

package/src/logic.unit.test.ts

@@ -0,0 +1,54 @@
+import { mapTxToOperations } from "./logic";
+import { TX } from "./wallet-btc";
+
+describe("mapTxToOperations", () => {
+  it("should filter out outputs that have unknown in their address", () => {
+    const ops = mapTxToOperations(
+      {
+        outputs: [
+          {
+            address: "<unknown>",
+          },
+        ],
+        inputs: [],
+      } as unknown as TX,
+      "bitcoin",
+      "accountId",
+      new Set(["myAddress"]),
+      new Set(["changeAddress"]),
+    );
+    expect(ops.length).toEqual(0);
+  });
+
+  it("should filter out outputs that have no address", () => {
+    const ops = mapTxToOperations(
+      {
+        outputs: [{}],
+        inputs: [],
+      } as unknown as TX,
+      "bitcoin",
+      "accountId",
+      new Set(["myAddress"]),
+      new Set(["changeAddress"]),
+    );
+    expect(ops.length).toEqual(0);
+  });
+
+  it("shouldn't filter out outputs with address", () => {
+    const ops = mapTxToOperations(
+      {
+        outputs: [
+          {
+            address: "myAddress",
+          },
+        ],
+        inputs: [],
+      } as unknown as TX,
+      "bitcoin",
+      "accountId",
+      new Set(["myAddress"]),
+      new Set(["changeAddress"]),
+    );
+    expect(ops.length).toEqual(1);
+  });
+});

package/src/mockBtcSigner.ts

@@ -0,0 +1,66 @@
+import hash from "object-hash";
+import type {
+  AddressFormat,
+  BitcoinSignature,
+  BitcoinSigner,
+  BitcoinXPub,
+  CreateTransaction,
+  SignerTransaction,
+} from "./signer";
+
+class MockBtcSigner implements BitcoinSigner {
+  // eslint-disable-next-line class-methods-use-this
+  async getWalletPublicKey(
+    path: string,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _opts: { verify?: boolean; format?: AddressFormat },
+  ) {
+    switch (path) {
+      case "44'/0'":
+        return {
+          publicKey:
+            "04c621f37493d99f39ca12fb02ba7fe1687b1650b875dcb6733f386a98958e6556fc95dcecb6ac41af0a5296965751b1598aa475a537474bab5b316fcdc1196568",
+          chainCode: "a45d311c31a80bf06cc38d8ed7934bd1e8a7b2d48b2868a70258a86e094bacfb",
+          bitcoinAddress: "1BKWjmA9swxRKMH9NgXpSz8YZfVMnWWU9D",
+        };
+        break;
+      case "44'/0'/0'":
+        return {
+          publicKey:
+            "04d52d1ad9311c5a3d542fa652fbd7d7b0be70109e329d359704d9f2946f8eb52a829c23f8b980c5f7b6c51bf446b21f3dc80c865095243c9215dbf9f3cb6403b8",
+          chainCode: "0bd3e45edca4d8a466f523a2c4094c412d25c36d5298b2d3a29938151a8d37fe",
+          bitcoinAddress: "1FHa4cuKdea21ByTngP9vz3KYDqqQe9SsA",
+        };
+        break;
+      default:
+        throw new Error("not supported");
+    }
+  }
+
+  async createPaymentTransaction(arg: CreateTransaction) {
+    return hash(arg);
+  }
+
+  getWalletXpub(_arg: { path: string; xpubVersion: number }): Promise<BitcoinXPub> {
+    return Promise.reject();
+  }
+  signMessage(_path: string, _messageHex: string): Promise<BitcoinSignature> {
+    return Promise.reject();
+  }
+  splitTransaction(
+    _transactionHex: string,
+    _isSegwitSupported: boolean | null | undefined,
+    _hasTimestamp: boolean | null | undefined,
+    _hasExtraData: boolean | null | undefined,
+    _additionals: Array<string> | null | undefined,
+  ): SignerTransaction {
+    // Stub
+    return {
+      version: Buffer.from(""),
+      inputs: [],
+      outputs: [],
+    };
+  }
+}
+
+export default MockBtcSigner;