@ledgerhq/coin-bitcoin 0.4.0-nightly.0

package/src/wallet-btc/crypto/bitcoincash.ts

@@ -0,0 +1,47 @@
+import bchaddr from "bchaddrjs";
+import { address as btcAddress } from "bitcoinjs-lib";
+import { InvalidAddress } from "@ledgerhq/errors";
+import Base from "./base";
+
+// a mock explorer class that just use js objects
+class BitcoinCash extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  network: any;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network = network;
+    this.network.dustThreshold = 5430;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+
+  async getLegacyBitcoinCashAddress(xpub: string, account: number, index: number): Promise<string> {
+    return bchaddr.toCashAddress(await super.getLegacyAddress(xpub, account, index));
+  }
+
+  // get address given an address type
+  async customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string> {
+    return await this.getLegacyBitcoinCashAddress(xpub, account, index);
+  }
+
+  toOutputScript(address: string): Buffer {
+    if (!this.validateAddress(address)) {
+      throw new InvalidAddress();
+    }
+    // TODO find a better way to calculate the script from bch address instead of converting to bitcoin address
+    return btcAddress.toOutputScript(bchaddr.toLegacyAddress(address), this.network);
+  }
+
+  validateAddress(address: string): boolean {
+    return bchaddr.isValidAddress(address);
+  }
+}
+
+export default BitcoinCash;

package/src/wallet-btc/crypto/bitcoingold.ts

@@ -0,0 +1,13 @@
+import Base from "./base";
+
+class BitcoinGold extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.dustThreshold = 5430;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+}
+
+export default BitcoinGold;

package/src/wallet-btc/crypto/dash.ts

@@ -0,0 +1,21 @@
+import Base from "./base";
+
+class Dash extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.messagePrefix = "\x19DarkCoin Signed Message:\n";
+    this.network.bip32 = {
+      public: 0x02fe52f8,
+      private: 0x02fe52cc,
+    };
+    this.network.wif = 0xcc;
+    this.network.pubKeyHash = 0x4c;
+    this.network.scriptHash = 0x10;
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+}
+
+export default Dash;

package/src/wallet-btc/crypto/decred.ts

@@ -0,0 +1,91 @@
+import Base from "./base";
+import { InvalidAddress } from "@ledgerhq/errors";
+import * as bjs from "bitcoinjs-lib";
+import bs58checkBase from "bs58check/base";
+import bs58check from "bs58check";
+import createBlakeHash from "blake-hash";
+import RIPEMD160 from "ripemd160";
+import bs58 from "bs58";
+import BIP32 from "./bip32";
+
+class Decred extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+  static blake256(buffer: Buffer): Buffer {
+    let b = buffer;
+    if (buffer instanceof Uint8Array) {
+      b = Buffer.from(buffer);
+    }
+    return createBlakeHash("blake256").update(b).digest();
+  }
+
+  // refer to decred spec https://devdocs.decred.org/developer-guides/addresses/
+  static getAddressFromPk(publicKey: Buffer): string {
+    const prefix = Buffer.from("073f", "hex");
+    const pkhash = Buffer.concat([
+      prefix,
+      new RIPEMD160().update(Decred.blake256(publicKey)).digest(),
+    ]);
+    const checksum = Decred._blake256x2(pkhash).slice(0, 4);
+    return bs58.encode(Buffer.concat([pkhash, checksum]));
+  }
+
+  static readonly _blake256x2 = (buffer: Buffer): Buffer =>
+    Decred.blake256(Decred.blake256(buffer));
+  static readonly bs58check = bs58checkBase(Decred._blake256x2);
+
+  toOutputScript(address: string): Buffer {
+    if (!this.validateAddress(address)) {
+      throw new InvalidAddress();
+    }
+    const decodeBase58 = Decred.bs58check.decode(address, Decred._blake256x2);
+    const prefix = address.toLocaleUpperCase().substring(0, 2);
+    if (prefix === "DC") {
+      return bjs.payments.p2sh({ hash: decodeBase58.slice(2) }).output as Buffer;
+    } else if (prefix === "DE" || prefix === "DS") {
+      return bjs.payments.p2pkh({ hash: decodeBase58.slice(2) }).output as Buffer;
+    }
+    throw new InvalidAddress();
+  }
+
+  validateAddress(address: string): boolean {
+    if (address.length < 25 || address.length > 36) {
+      return false;
+    }
+    try {
+      Decred.bs58check.decode(address, Decred._blake256x2);
+    } catch (error) {
+      return false;
+    }
+    return true;
+  }
+
+  // get address given an address type
+  async customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string> {
+    let buffer: Buffer;
+    try {
+      buffer = Decred.bs58check.decode(xpub);
+    } catch {
+      buffer = bs58check.decode(xpub);
+    }
+    const depth = buffer[4];
+    const i = buffer.readUInt32BE(9);
+    const chainCode = buffer.slice(13, 45);
+    const X = buffer.slice(45, 78);
+    const hd = new BIP32(X, chainCode, this.network, depth, i);
+    const publicKey = (await (await hd.derive(account)).derive(index)).publicKey;
+    return Decred.getAddressFromPk(publicKey);
+  }
+}
+
+export default Decred;

package/src/wallet-btc/crypto/digibyte.ts

@@ -0,0 +1,33 @@
+import * as bech32 from "bech32";
+import bs58check from "bs58check";
+import Base from "./base";
+
+class Digibyte extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    // missing bip32 info in coininfo network for digibyte, we fill it mannually
+    // https://electrum.readthedocs.io/en/latest/xpub_version_bytes.html
+    super({ network });
+    this.network.bip32 = { public: 0x0488b21e, private: 0x0488ade4 };
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+
+  validateAddress(address: string): boolean {
+    // bech32 address
+    if (address.substring(0, 3) === "dgb") {
+      if (bech32.decodeUnsafe(address)) {
+        return true;
+      }
+    }
+    // bs58 address
+    const res = bs58check.decodeUnsafe(address);
+    if (!res) return false;
+    return (
+      res.length > 3 && (res[0] === this.network.pubKeyHash || res[0] === this.network.scriptHash)
+    );
+  }
+}
+
+export default Digibyte;

package/src/wallet-btc/crypto/doge.ts

@@ -0,0 +1,15 @@
+import Base from "./base";
+
+class Doge extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    // https://github.com/dogecoin/dogecoin/blob/master/doc/fee-recommendation.md
+    // set 0.01 DOGE as dustThreshold
+    this.network.dustThreshold = 1000000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+}
+
+export default Doge;

package/src/wallet-btc/crypto/factory.ts

@@ -0,0 +1,104 @@
+import coininfo from "coininfo";
+import { Currency, ICrypto } from "./types";
+import * as crypto from "./index";
+
+export default function cryptoFactory(currency: Currency): ICrypto {
+  let res: ICrypto;
+  switch (currency) {
+    case "bitcoin": {
+      const network = coininfo.bitcoin.main.toBitcoinJS();
+      res = new crypto.Bitcoin({ network });
+      break;
+    }
+    case "bitcoin_cash": {
+      const network = coininfo.bitcoincash.main.toBitcoinJS();
+      res = new crypto.BitcoinCash({ network });
+      break;
+    }
+    case "litecoin": {
+      const network = coininfo.litecoin.main.toBitcoinJS();
+      res = new crypto.Litecoin({ network });
+      break;
+    }
+    case "dash": {
+      const network = coininfo.dash.main.toBitcoinJS();
+      res = new crypto.Dash({ network });
+      break;
+    }
+    case "qtum": {
+      const network = coininfo.qtum.main.toBitcoinJS();
+      res = new crypto.Qtum({ network });
+      break;
+    }
+    case "zcash": {
+      const network = coininfo.zcash.main.toBitcoinJS();
+      res = new crypto.Zec({ network });
+      break;
+    }
+    case "bitcoin_gold": {
+      const network = coininfo["bitcoin gold"].main.toBitcoinJS();
+      res = new crypto.BitcoinGold({ network });
+      break;
+    }
+    case "dogecoin": {
+      const network = coininfo.dogecoin.main.toBitcoinJS();
+      res = new crypto.Doge({ network });
+      break;
+    }
+    case "digibyte": {
+      const network = coininfo.digibyte.main.toBitcoinJS();
+      res = new crypto.Digibyte({ network });
+      break;
+    }
+    case "komodo": {
+      const network = coininfo.bitcoin.main.toBitcoinJS();
+      res = new crypto.Komodo({ network });
+      break;
+    }
+    case "pivx": {
+      const network = coininfo.bitcoin.main.toBitcoinJS();
+      res = new crypto.Pivx({ network });
+      break;
+    }
+    case "zencash": {
+      const network = coininfo.zcash.main.toBitcoinJS();
+      res = new crypto.Zen({ network });
+      break;
+    }
+    case "vertcoin": {
+      const network = coininfo.vertcoin.main.toBitcoinJS();
+      res = new crypto.Vertcoin({ network });
+      break;
+    }
+    case "peercoin": {
+      const network = coininfo.peercoin.main.toBitcoinJS();
+      res = new crypto.Peercoin({ network });
+      break;
+    }
+    case "viacoin": {
+      const network = coininfo.viacoin.main.toBitcoinJS();
+      res = new crypto.ViaCoin({ network });
+      break;
+    }
+    case "stealthcoin": {
+      const network = coininfo.bitcoin.main.toBitcoinJS();
+      res = new crypto.Stealth({ network });
+      break;
+    }
+    case "bitcoin_testnet": {
+      const network = coininfo.bitcoin.test.toBitcoinJS();
+      res = new crypto.Bitcoin({ network });
+      break;
+    }
+    case "decred": {
+      const network = coininfo.decred.main.toBitcoinJS();
+      res = new crypto.Decred({ network });
+      break;
+    }
+    default: {
+      throw new Error(`Currency ${currency} doesn't exist!`);
+    }
+  }
+  return res;
+}
+// TODO: Currently, all bitcoin currencies included setSupportedCurrencies must be supported here. We are working on a new way to support/enable new currencies

package/src/wallet-btc/crypto/index.ts

@@ -0,0 +1,18 @@
+export { default as Bitcoin } from "./bitcoin";
+export { default as BitcoinCash } from "./bitcoincash";
+export { default as Litecoin } from "./litecoin";
+export { default as Digibyte } from "./digibyte";
+export { default as Zec } from "./zec";
+export { default as Zen } from "./zen";
+export { default as Dash } from "./dash";
+export { default as Peercoin } from "./peercoin";
+export { default as Komodo } from "./komodo";
+export { default as Pivx } from "./pivx";
+export { default as Stealth } from "./stealth";
+export { default as BitcoinGold } from "./bitcoingold";
+export { default as Doge } from "./doge";
+export { default as Qtum } from "./qtum";
+export { default as Vertcoin } from "./vtc";
+export { default as ViaCoin } from "./via";
+export { default as Decred } from "./decred";
+export { setSecp256k1Instance, getSecp256k1Instance } from "./secp256k1";

package/src/wallet-btc/crypto/komodo.ts

@@ -0,0 +1,16 @@
+import Base from "./base";
+
+class Komodo extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.bip32.public = 0xf9eee48d;
+    this.network.pubKeyHash = 0x3c;
+    this.network.scriptHash = 0x55;
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+}
+
+export default Komodo;

package/src/wallet-btc/crypto/litecoin.ts

@@ -0,0 +1,31 @@
+import { address as btcAddress } from "bitcoinjs-lib";
+import * as bech32 from "bech32";
+import Base from "./base";
+
+// Todo copy paste from bitcoin.ts. we can merge them later
+class Litecoin extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+
+  toOutputScript(address: string): Buffer {
+    return btcAddress.toOutputScript(address, this.network);
+  }
+
+  validateAddress(address: string): boolean {
+    // bech32 address
+    if (address.substring(0, 3) === "ltc") {
+      if (bech32.decodeUnsafe(address)) {
+        return true;
+      }
+    }
+    // bs58 address
+    return super.validateAddress(address);
+  }
+}
+
+export default Litecoin;

package/src/wallet-btc/crypto/peercoin.ts

@@ -0,0 +1,15 @@
+import Base from "./base";
+
+class Peercoin extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    // https://github.com/LedgerHQ/lib-ledger-core/blob/master/core/src/wallet/bitcoin/networks.cpp#L176
+    this.network.bip32.public = 0xe6e8e9e5;
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = true;
+  }
+}
+
+export default Peercoin;

package/src/wallet-btc/crypto/pivx.ts

@@ -0,0 +1,17 @@
+import Base from "./base";
+
+class Pivx extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/master/core/src/wallet/bitcoin/networks.cpp#L369
+    this.network.bip32.public = 0x022d2533;
+    this.network.pubKeyHash = 0x1e;
+    this.network.scriptHash = 0x0d;
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+}
+
+export default Pivx;

package/src/wallet-btc/crypto/qtum.ts

@@ -0,0 +1,13 @@
+import Base from "./base";
+
+class Qtum extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.dustThreshold = 100000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+}
+
+export default Qtum;

package/src/wallet-btc/crypto/secp256k1.ts

@@ -0,0 +1,29 @@
+import secp256k1 from "secp256k1";
+
+/**
+ * Implement the subset of secp256k1 that wallet-btc needs to work.
+ * The interface is made asynchronous to be more efficient to run in a renderer thread and defer the cryptography
+ */
+export type Secp256k1Instance = {
+  publicKeyTweakAdd(publicKey: Uint8Array, tweak: Uint8Array): Promise<Uint8Array>;
+};
+
+// default uses node.js's secp256k1
+let impl: Secp256k1Instance = {
+  publicKeyTweakAdd: (publicKey, tweak) =>
+    Promise.resolve(secp256k1.publicKeyTweakAdd(publicKey, tweak)),
+};
+
+/**
+ * allows to override the default Secp256k1Instance
+ */
+export function setSecp256k1Instance(override: Secp256k1Instance): void {
+  impl = override;
+}
+
+/**
+ * get the current Secp256k1Instance
+ */
+export function getSecp256k1Instance(): Secp256k1Instance {
+  return impl;
+}

package/src/wallet-btc/crypto/stealth.ts

@@ -0,0 +1,17 @@
+import Base from "./base";
+
+class Stealth extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/master/core/src/wallet/bitcoin/networks.cpp#L240
+    this.network.bip32.public = 0x8f624b66;
+    this.network.pubKeyHash = 0x3e;
+    this.network.scriptHash = 0x55;
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = true;
+  }
+}
+
+export default Stealth;

package/src/wallet-btc/crypto/types.ts

@@ -0,0 +1,35 @@
+export interface ICrypto {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  network: any;
+  getAddress(derivationMode: string, xpub: string, account: number, index: number): Promise<string>;
+  customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string>;
+  toOutputScript(address: string): Buffer;
+  toOpReturnOutputScript(data: Buffer): Buffer;
+  validateAddress(address: string): boolean;
+  isTaprootAddress(address: string): boolean;
+}
+
+export type Currency =
+  | "bitcoin"
+  | "bitcoin_cash"
+  | "litecoin"
+  | "dash"
+  | "qtum"
+  | "zcash"
+  | "bitcoin_gold"
+  | "dogecoin"
+  | "digibyte"
+  | "komodo"
+  | "pivx"
+  | "zencash"
+  | "vertcoin"
+  | "peercoin"
+  | "viacoin"
+  | "stealthcoin"
+  | "decred"
+  | "bitcoin_testnet";

package/src/wallet-btc/crypto/via.ts

@@ -0,0 +1,13 @@
+import Base from "./base";
+
+class ViaCoin extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.dustThreshold = 100000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+}
+
+export default ViaCoin;

package/src/wallet-btc/crypto/vtc.ts

@@ -0,0 +1,13 @@
+import Base from "./base";
+
+class Vertcoin extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+}
+
+export default Vertcoin;

package/src/wallet-btc/crypto/zec.ts

@@ -0,0 +1,66 @@
+import bs58check from "bs58check";
+import * as bjs from "bitcoinjs-lib";
+import { InvalidAddress } from "@ledgerhq/errors";
+import Base from "./base";
+
+class ZCash extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  network: any;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    this.network = network;
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+
+  async getLegacyAddress(xpub: string, account: number, index: number): Promise<string> {
+    const pk = bjs.crypto.hash160(await this.getPubkeyAt(xpub, account, index));
+    const payload = Buffer.allocUnsafe(22);
+    payload.writeUInt16BE(this.network.pubKeyHash, 0);
+    pk.copy(payload, 2);
+    return bs58check.encode(payload);
+  }
+
+  async customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string> {
+    return await this.getLegacyAddress(xpub, account, index);
+  }
+
+  toOutputScript(address: string): Buffer {
+    if (!this.validateAddress(address)) {
+      throw new InvalidAddress();
+    }
+    const version = Number("0x" + bs58check.decode(address).slice(0, 2).toString("hex"));
+    if (version === this.network.pubKeyHash) {
+      //Pay-to-PubkeyHash
+      return bjs.payments.p2pkh({ hash: bs58check.decode(address).slice(2) }).output as Buffer;
+    }
+    if (version === this.network.scriptHash) {
+      //Pay-to-Script-Hash
+      return bjs.payments.p2sh({ hash: bs58check.decode(address).slice(2) }).output as Buffer;
+    }
+    throw new InvalidAddress();
+  }
+
+  validateAddress(address: string): boolean {
+    try {
+      const version = Number("0x" + bs58check.decode(address).slice(0, 2).toString("hex"));
+      // refer to https://github.com/zcash-hackworks/bitcore-lib-zcash/blob/master/lib%2Faddress.js for the address validation
+      if (version === this.network.pubKeyHash || version === this.network.scriptHash) {
+        return true;
+      }
+    } catch {
+      return false;
+    }
+    return false;
+  }
+}
+
+export default ZCash;