@ledgerhq/coin-bitcoin 0.4.0-nightly.0

package/src/wallet-btc/__tests__/xpub.txs.litecoin.integration.test.ts

@@ -0,0 +1,150 @@
+import * as bip32 from "bip32";
+import * as bip39 from "bip39";
+import * as bitcoin from "bitcoinjs-lib";
+import coininfo from "coininfo";
+import axios from "axios";
+import BigNumber from "bignumber.js";
+import { DerivationModes } from "../types";
+import Xpub from "../xpub";
+import Litecoin from "../crypto/litecoin";
+import BitcoinLikeExplorer from "../explorer";
+import BitcoinLikeStorage from "../storage";
+import { Merge } from "../pickingstrategies/Merge";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+/*
+In order to launch this litecoin test locally
+TICKER=ltc TAG=latest LOG_LEVEL=debug docker-compose -f ./environments/explorer-praline-btc.yml up -d
+*/
+// FIXME Skipped because Praline required on CI
+describe.skip("testing xpub legacy litecoin transactions", () => {
+  const explorer = new BitcoinLikeExplorer({
+    cryptoCurrency: getCryptoCurrencyById("litecoin"),
+  });
+
+  const network = coininfo.litecoin.test?.toBitcoinJS();
+  const crypto = new Litecoin({ network });
+
+  const xpubs = [1, 2, 3].map(i => {
+    const storage = new BitcoinLikeStorage();
+    const seed = bip39.mnemonicToSeedSync(`test${i} test${i} test${i}`);
+    const node = bip32.fromSeed(seed, network);
+    const signer = (account: number, index: number) =>
+      bitcoin.ECPair.fromWIF(node.derive(account).derive(index).toWIF(), network);
+    const xpub = new Xpub({
+      storage,
+      explorer,
+      crypto,
+      xpub: node.neutered().toBase58(),
+      derivationMode: DerivationModes.LEGACY,
+    });
+
+    return {
+      storage,
+      seed,
+      node,
+      signer,
+      xpub,
+    };
+  });
+
+  beforeAll(async () => {
+    const { address } = await xpubs[0].xpub.getNewAddress(0, 0);
+    try {
+      await axios.post("http://localhost:28443/chain/clear/all");
+      await axios.post(`http://localhost:28443/chain/mine/${address}/1`);
+      await axios.post(`http://localhost:28443/chain/faucet/${address}/7.0`);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log("praline setup error", e);
+    }
+
+    // time for explorer to sync
+    await sleep(30000);
+
+    try {
+      await xpubs[0].xpub.sync();
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log("praline explorer setup error", e);
+    }
+  }, 70000);
+
+  it("should be setup correctly", async () => {
+    const balance1 = await xpubs[0].xpub.getXpubBalance();
+    expect(balance1.toNumber()).toEqual(5700000000);
+  });
+
+  let expectedFee1: number;
+  it("should send a 1 litecoin tx to xpubs[1].xpub", async () => {
+    const { address } = await xpubs[1].xpub.getNewAddress(0, 0);
+    const changeAddress = await xpubs[0].xpub.getNewAddress(1, 0);
+    const psbt = new bitcoin.Psbt({ network });
+
+    const utxoPickingStrategy = new Merge(xpubs[0].xpub.crypto, xpubs[0].xpub.derivationMode, []);
+
+    const { inputs, associatedDerivations, outputs } = await xpubs[0].xpub.buildTx({
+      destAddress: address,
+      amount: new BigNumber(100000000),
+      feePerByte: 100,
+      changeAddress,
+      utxoPickingStrategy,
+      sequence: 0,
+    });
+
+    inputs.forEach(input => {
+      const nonWitnessUtxo = Buffer.from(input.txHex, "hex");
+      const tx = bitcoin.Transaction.fromHex(input.txHex);
+
+      psbt.addInput({
+        hash: tx.getId(),
+        index: input.output_index,
+        nonWitnessUtxo,
+      });
+    });
+    outputs.forEach(output => {
+      psbt.addOutput({
+        script: output.script,
+        value: output.value.toNumber(),
+      });
+    });
+    expect(outputs.length).toEqual(2);
+    inputs.forEach((_, i) => {
+      psbt.signInput(i, xpubs[0].signer(associatedDerivations[i][0], associatedDerivations[i][1]));
+      psbt.validateSignaturesOfInput(i);
+    });
+    psbt.finalizeAllInputs();
+    const rawTxHex = psbt.extractTransaction().toHex();
+    //
+
+    try {
+      await xpubs[0].xpub.broadcastTx(rawTxHex);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log("broadcast error", e);
+    }
+
+    // time for explorer to sync
+    await sleep(40000);
+
+    try {
+      const { address: mineAddress } = await xpubs[2].xpub.getNewAddress(0, 0);
+      await axios.post(`http://localhost:28443/chain/mine/${mineAddress}/1`);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log("praline error");
+    }
+    await sleep(40000);
+    await xpubs[0].xpub.sync();
+    await xpubs[1].xpub.sync();
+
+    expectedFee1 = 10 * 100 + inputs.length * 100 * 180 + outputs.length * 34 * 100;
+
+    expect((await xpubs[0].xpub.getXpubBalance()).toNumber()).toEqual(
+      5700000000 - 100000000 - expectedFee1,
+    );
+    expect((await xpubs[1].xpub.getXpubBalance()).toNumber()).toEqual(100000000);
+  }, 100000);
+});

package/src/wallet-btc/__tests__/xpub.utxo.unit.test.ts

@@ -0,0 +1,66 @@
+import coininfo from "coininfo";
+import { script } from "bitcoinjs-lib";
+
+import BTCCrypto from "../crypto/bitcoin";
+import BTCCashCrypto from "../crypto/bitcoincash";
+import DogeCrypto from "../crypto/doge";
+import ZECCrypto from "../crypto/zec";
+import ZENCrypto from "../crypto/zen";
+
+describe("Transaction Output script", () => {
+  const btcCrypto = new BTCCrypto({
+    network: coininfo.bitcoin.main.toBitcoinJS(),
+  });
+
+  const zecCrypto = new ZECCrypto({
+    network: coininfo.zcash.main.toBitcoinJS(),
+  });
+
+  const zenCrypto = new ZENCrypto({
+    network: coininfo.zcash.main.toBitcoinJS(),
+  });
+
+  const btcCashCrypto = new BTCCashCrypto({
+    network: coininfo.bitcoincash.main.toBitcoinJS(),
+  });
+
+  const dogeCrypto = new DogeCrypto({
+    network: coininfo.dogecoin.main.toBitcoinJS(),
+  });
+
+  it("Test toOutputScript for btc, zcash and zen", () => {
+    expect(btcCrypto.toOutputScript("1F1tAaz5x1HUXrCNLbtMDqcw6o5GNn4xqX").toString("hex")).toEqual(
+      "76a91499bc78ba577a95a11f1a344d4d2ae55f2f857b9888ac",
+    );
+    // Legacy zcash address
+    expect(zecCrypto.toOutputScript("t1T5XJvzQhh2gTsi3c5Vn9x5SMhpSWLSnVy").toString("hex")).toEqual(
+      "76a91464fa33fb6f8d72455af2a4e73ae30412af2c97ba88ac",
+    );
+    // P2SH zcash address
+    expect(zecCrypto.toOutputScript("t3PU1j7YW3fJ67jUbkGhSRto8qK2qXCUiW3").toString("hex")).toEqual(
+      "a91435c929cb2ee32626e1f5c8d773ab4fe9d94686e087",
+    );
+    // Legacy zen address
+    expect(zenCrypto.toOutputScript("znjbHth4PxBJM8FmHgvXYHkuq99nKFkWvMg").toString("hex")).toEqual(
+      "76a914cb009bf12fc17d28e61527951101fdabfeaa187288ac209ec9845acb02fab24e1c0368b3b517c1a4488fba97f0e3459ac053ea0100000003c01f02b4",
+    );
+    // P2SH zen address
+    expect(zenCrypto.toOutputScript("zszpcLB6C5B8QvfDbF2dYWXsrpac5DL9WRk").toString("hex")).toEqual(
+      "a914df23c5eaba30b4d95798c5d5d0e2ecc2a3dc4ff287209ec9845acb02fab24e1c0368b3b517c1a4488fba97f0e3459ac053ea0100000003c01f02b4",
+    );
+  }, 30000);
+
+  it("should get correct output script for OP_RETURN opcode", () => {
+    [btcCrypto, btcCashCrypto, dogeCrypto].forEach(coin => {
+      const data = Buffer.from("charley loves heidi", "utf-8");
+
+      const output = coin.toOpReturnOutputScript(data);
+      const [opType, message] = script.decompile(output) as [number, Buffer];
+
+      expect(output.toString("hex")).toEqual("6a13636861726c6579206c6f766573206865696469");
+
+      expect(opType).toEqual(script.OPS.OP_RETURN);
+      expect(message.toString()).toEqual("charley loves heidi");
+    });
+  });
+});

package/src/wallet-btc/account.ts

@@ -0,0 +1,30 @@
+import { DerivationModes } from "./types";
+import { Currency } from "./crypto/types";
+import Xpub from "./xpub";
+
+export interface Account {
+  params: {
+    path: string;
+    index: number;
+    currency: Currency;
+    network: "mainnet" | "testnet";
+    derivationMode: DerivationModes;
+  };
+
+  xpub: Xpub;
+}
+
+export interface SerializedAccount {
+  params: {
+    path: string;
+    index: number;
+    currency: Currency;
+    network: "mainnet" | "testnet";
+    derivationMode: DerivationModes;
+  };
+
+  xpub: {
+    xpub: string;
+    data: unknown;
+  };
+}

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

@@ -0,0 +1,179 @@
+// from https://github.com/LedgerHQ/xpub-scan/blob/master/src/actions/deriveAddresses.ts
+
+import * as bjs from "bitcoinjs-lib";
+import { address as btcAddress } from "bitcoinjs-lib";
+import bs58check from "bs58check";
+import { DerivationModes } from "../types";
+import { ICrypto } from "./types";
+import bs58 from "bs58";
+import bech32 from "bech32";
+import BIP32 from "./bip32";
+
+// https://developer.bitcoin.org/devguide/transactions.html#null-data
+export const OP_RETURN_DATA_SIZE_LIMIT = 83; // bytes
+
+export function fallbackValidateAddress(address: string): boolean {
+  try {
+    bjs.address.fromBase58Check(address);
+  } catch {
+    // Not a valid Base58 address
+    try {
+      bjs.address.fromBech32(address);
+    } catch {
+      // Not a valid Bech32 address either
+      return false;
+    }
+  }
+  return true;
+}
+
+class Base implements ICrypto {
+  network: any;
+  private static bip32Cache: Map<string, Promise<BIP32>> = new Map(); // xpub + account + index to publicKey
+  public static addressCache: Record<string, Promise<string>> = {}; // derivationMode + xpub + account + index to address
+
+  constructor({ network }: { network: any }) {
+    this.network = network;
+    this.network.dustThreshold = 3000;
+    this.network.dustPolicy = "PER_KBYTE";
+    this.network.usesTimestampedTransaction = false;
+  }
+
+  protected async getPubkeyAt(xpub: string, account: number, index: number): Promise<Buffer> {
+    // a cache is stored in Base.bip32Cache to optimize the calculation
+    // at each step, we make sure the level has been calculated and calc if necessary
+
+    // 0: root level
+    const keyRoot = `${this.network.name}-${xpub}`;
+    let rootLevel = Base.bip32Cache.get(keyRoot);
+    if (!rootLevel) {
+      const buffer: Buffer = bs58.decode(xpub);
+      const depth: number = buffer[4];
+      const i: number = buffer.readUInt32BE(9);
+      const chainCode: Buffer = buffer.slice(13, 45);
+      const publicKey: Buffer = buffer.slice(45, 78);
+      rootLevel = Promise.resolve(new BIP32(publicKey, chainCode, this.network, depth, i));
+      Base.bip32Cache.set(keyRoot, rootLevel);
+    }
+
+    // 1: account level
+    const keyAccount = `${keyRoot}-${account}`;
+    let accountLevelP = Base.bip32Cache.get(keyAccount); // it's stored as promise
+    if (!accountLevelP) {
+      accountLevelP = rootLevel.then(root => root.derive(account));
+      // accountLevelP = await rootLevel.derive(account);
+      Base.bip32Cache.set(keyAccount, accountLevelP);
+    }
+
+    // 2: index level
+    const keyIndex = `${keyAccount}-${index}`;
+    let indexLevelP = Base.bip32Cache.get(keyIndex); // it's stored as promise
+    if (!indexLevelP) {
+      indexLevelP = accountLevelP.then(a => a.derive(index));
+      // indexLevelP = await accountLevelP.derive(index);
+      Base.bip32Cache.set(keyIndex, indexLevelP);
+    }
+
+    // We can finally return the publicKey. in most case, indexLevelP will be "resolved"
+    return (await indexLevelP).publicKey;
+  }
+
+  // derive legacy address at account and index positions
+  protected async getLegacyAddress(xpub: string, account: number, index: number): Promise<string> {
+    const publicKeyBuffer: Buffer = await this.getPubkeyAt(xpub, account, index);
+    const publicKeyHash160: Buffer = bjs.crypto.hash160(publicKeyBuffer);
+    return bjs.address.toBase58Check(publicKeyHash160, this.network.pubKeyHash);
+  }
+
+  // derive native SegWit at account and index positions
+  private async getNativeSegWitAddress(
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string> {
+    const publicKeyBuffer: Buffer = await this.getPubkeyAt(xpub, account, index);
+    const publicKeyHash160: Buffer = bjs.crypto.hash160(publicKeyBuffer);
+    const words: number[] = bech32.toWords(publicKeyHash160);
+    words.unshift(0x00);
+    return bech32.encode(this.network.bech32, words);
+  }
+
+  // derive SegWit at account and index positions
+  private async getSegWitAddress(xpub: string, account: number, index: number): Promise<string> {
+    const publicKeyBuffer: Buffer = await this.getPubkeyAt(xpub, account, index);
+    const redeemOutput: Buffer = bjs.script.compile([0, bjs.crypto.hash160(publicKeyBuffer)]);
+    const publicKeyHash160: Buffer = bjs.crypto.hash160(redeemOutput);
+    const payload: Buffer = Buffer.allocUnsafe(21);
+    payload.writeUInt8(this.network.scriptHash, 0);
+    publicKeyHash160.copy(payload, 1);
+    return bs58check.encode(payload);
+  }
+
+  // get address given an address type
+  async getAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string> {
+    const addressCacheKey = `${this.network.name}-${derivationMode}-${xpub}-${account}-${index}`;
+    if (addressCacheKey in Base.addressCache) {
+      return Base.addressCache[addressCacheKey];
+    }
+    const res = this.customGetAddress(derivationMode, xpub, account, index);
+    Base.addressCache[addressCacheKey] = res;
+    return res;
+  }
+
+  async customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string> {
+    switch (derivationMode) {
+      case DerivationModes.LEGACY:
+        return await this.getLegacyAddress(xpub, account, index);
+      case DerivationModes.SEGWIT:
+        return await this.getSegWitAddress(xpub, account, index);
+      case DerivationModes.NATIVE_SEGWIT:
+        return await this.getNativeSegWitAddress(xpub, account, index);
+      default:
+        throw new Error(`Invalid derivation Mode: ${derivationMode}`);
+    }
+  }
+
+  /**
+   * The output script sets the conditions under which the amount can be spent.
+   * It is a crucial part of Bitcoin's scripting system, ensuring that only the rightful owner can spend the bitcoins
+   * This function returns the output script for a given address
+   * see https://developer.bitcoin.org/devguide/transactions.html for more details
+   */
+  toOutputScript(address: string): Buffer {
+    return btcAddress.toOutputScript(address, this.network);
+  }
+
+  /**
+   * OutputScript to with OP_RETURN data
+   * see https://developer.bitcoin.org/reference/transactions.html?highlight=op_return for more details
+   */
+  toOpReturnOutputScript(data: Buffer): Buffer {
+    const script = bjs.payments.embed({ data: [data] });
+    return script.output!;
+  }
+
+  validateAddress(address: string): boolean {
+    // 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)
+    );
+  }
+
+  isTaprootAddress(_address: string): boolean {
+    return false;
+  }
+}
+
+export default Base;

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

@@ -0,0 +1,40 @@
+import invariant from "invariant";
+import createHmac from "create-hmac";
+import { getSecp256k1Instance } from "./secp256k1";
+
+// the BIP32 class is inspired from https://github.com/bitcoinjs/bip32/blob/master/src/bip32.js
+class BIP32 {
+  publicKey: Buffer;
+  chainCode: Buffer;
+  network: any;
+  depth: number;
+  index: number;
+  constructor(
+    publicKey: Buffer,
+    chainCode: Buffer,
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    network: any,
+    depth = 0,
+    index = 0,
+  ) {
+    invariant(publicKey && publicKey.length > 0, "publicKey must not be empty");
+    invariant(chainCode && chainCode.length > 0, "chainCode must not be empty");
+    this.publicKey = publicKey;
+    this.chainCode = chainCode;
+    this.network = network;
+    this.depth = depth;
+    this.index = index;
+  }
+  async derive(index: number): Promise<BIP32> {
+    const data = Buffer.allocUnsafe(37);
+    this.publicKey.copy(data, 0);
+    data.writeUInt32BE(index, 33);
+    const I = createHmac("sha512", this.chainCode).update(data).digest();
+    const IL = I.slice(0, 32);
+    const IR = I.slice(32);
+    const Ki = Buffer.from(await getSecp256k1Instance().publicKeyTweakAdd(this.publicKey, IL));
+    return new BIP32(Ki, IR, this.network, this.depth + 1, index);
+  }
+}
+
+export default BIP32;

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

@@ -0,0 +1,203 @@
+// from https://github.com/LedgerHQ/xpub-scan/blob/master/src/actions/deriveAddresses.ts
+
+import * as bech32 from "bech32";
+import { bech32m } from "../../bech32m";
+import * as bjs from "bitcoinjs-lib";
+import { getSecp256k1Instance } from "./secp256k1";
+import { InvalidAddress } from "@ledgerhq/errors";
+import { DerivationModes } from "../types";
+import Base from "./base";
+
+/**
+ * Temporarily copied fromBech32 and toBech32 from bitcoinjs-lib master branch (as of 2021-09-02,
+ * commit 7b753caad6a5bf13d40ffb6ae28c2b00f7f5f585) so that we can make use of the
+ * updated bech32 lib version 2.0.0 that supports bech32m. bitcoinjs-lib version 5.2.0
+ * as currently used by wallet-btc uses an older version of bech32 that lacks bech32m support.
+ *
+ * When a new version of bitcoinjs-lib that supports bech32m is released this function can
+ * be removed and calls should be directed to bitcoinjs-lib instead. Our direct dependency
+ * on bech32 lib should also be removed.
+ *
+ * TODO: Replace with bitcoinjs-lib call
+ */
+/* eslint-disable */
+function fromBech32(address: string): {
+  version: number;
+  prefix: string;
+  data: Buffer;
+} {
+  let result;
+  let version;
+  try {
+    result = bech32.decode(address);
+  } catch (e) {}
+
+  if (result) {
+    version = result.words[0];
+    if (version !== 0) throw new TypeError(address + " uses wrong encoding");
+  } else {
+    result = bech32m.decode(address);
+    version = result.words[0];
+    if (version === 0) throw new TypeError(address + " uses wrong encoding");
+  }
+
+  const data = bech32.fromWords(result.words.slice(1));
+
+  return {
+    version,
+    prefix: result.prefix,
+    data: Buffer.from(data),
+  };
+}
+
+function toBech32(data: Buffer, version: number, prefix: string): string {
+  const words = bech32.toWords(data);
+  words.unshift(version);
+
+  return version === 0
+    ? bech32.encode(prefix, words)
+    : bech32m.encode(prefix, words);
+}
+/* eslint-enable */
+
+// This function expects a valid base58check address or a valid
+// bech32/bech32m address.
+function toOutputScriptTemporary(validAddress: string, network: bjs.Network): Buffer {
+  try {
+    const decodeBase58 = bjs.address.fromBase58Check(validAddress);
+    if (decodeBase58.version === network.pubKeyHash)
+      return bjs.payments.p2pkh({ hash: decodeBase58.hash }).output as Buffer;
+    if (decodeBase58.version === network.scriptHash)
+      return bjs.payments.p2sh({ hash: decodeBase58.hash }).output as Buffer;
+  } catch (e) {
+    // It's not a base58 address, so it's a segwit address
+  }
+  const decodeBech32 = fromBech32(validAddress);
+  return bjs.script.compile([
+    // OP_0 is encoded as 0x00, but OP_1 through OP_16 are encoded as 0x51 though 0x60, see BIP173
+    decodeBech32.version + (decodeBech32.version > 0 ? 0x50 : 0),
+    decodeBech32.data,
+  ]);
+}
+
+class Bitcoin extends Base {
+  toOutputScript(address: string): Buffer {
+    // Make sure the address is valid on this network
+    // otherwise we can't call toOutputScriptTemporary.
+    if (!this.validateAddress(address)) {
+      throw new InvalidAddress();
+    }
+    // bitcoinjs-lib/src/address doesn't yet have released support for bech32m,
+    // so we'll implement our own version of toOutputScript while waiting.
+    // This implementation is highly inspired (stolen) from bitcoinjs-lib's
+    // master branch.
+    // One major difference is that our function requires an already
+    // valid address, whereas to bitcoinjs-lib version doesn't.
+    // TODO: Replace with bitcoinjs-lib call
+    return toOutputScriptTemporary(address, this.network);
+  }
+
+  validateAddress(address: string): boolean {
+    try {
+      // This prefix check is to avoid returning false in cases where a valid base58 address also happens
+      // to be a valid bech32(m) string (but invalid segwit address).
+      if (address.toLowerCase().startsWith(`${this.network.bech32}1`)) {
+        return this.tryBech32(address);
+      }
+    } catch {
+      /* Try base58 instead */
+    }
+    try {
+      return this.tryBase58(address);
+    } catch {
+      return false;
+    }
+  }
+
+  // get address given an address type
+  async customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string> {
+    switch (derivationMode) {
+      case DerivationModes.TAPROOT:
+        return await this.getTaprootAddress(xpub, account, index);
+      default:
+        return super.customGetAddress(derivationMode, xpub, account, index);
+    }
+  }
+
+  private tryBech32(address: string): boolean {
+    const result = fromBech32(address);
+    if (this.network.bech32 !== result.prefix) {
+      // Address doesn't use the expected human-readable part ${network.bech32}
+      return false;
+    }
+    if (result.version > 16 || result.version < 0) {
+      // Address has invalid version
+      return false;
+    }
+    if (result.data.length < 2 || result.data.length > 40) {
+      // Address has invalid data length
+      return false;
+    }
+    if (result.version === 0 && result.data.length !== 20 && result.data.length !== 32) {
+      // Version 0 address uses an invalid witness program length
+      return false;
+    }
+    return true;
+  }
+
+  private tryBase58(address: string): boolean {
+    const result = bjs.address.fromBase58Check(address);
+    if (this.network.pubKeyHash === result.version || this.network.scriptHash === result.version) {
+      return true;
+    }
+    return false;
+  }
+
+  private hashTapTweak(x: Buffer): Buffer {
+    // hash_tag(x) = SHA256(SHA256(tag) || SHA256(tag) || x), see BIP340
+    // See https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki#specification
+    const h = bjs.crypto.sha256(Buffer.from("TapTweak", "utf-8"));
+    return bjs.crypto.sha256(Buffer.concat([h, h, x]));
+  }
+
+  private async getTaprootAddress(xpub: string, account: number, index: number): Promise<string> {
+    const ecdsaPubkey = await this.getPubkeyAt(xpub, account, index);
+    // A BIP32 derived key can be converted to a schnorr pubkey by dropping
+    // the first byte, which represent the oddness/evenness. In schnorr all
+    // pubkeys are even.
+    // https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki#public-key-conversion
+    const schnorrInternalPubkey = ecdsaPubkey.slice(1);
+
+    const evenEcdsaPubkey = Buffer.concat([Buffer.from([0x02]), schnorrInternalPubkey]);
+    const tweak = this.hashTapTweak(schnorrInternalPubkey);
+
+    // Q = P + int(hash_TapTweak(bytes(P)))G
+    const outputEcdsaKey = Buffer.from(
+      await getSecp256k1Instance().publicKeyTweakAdd(evenEcdsaPubkey, tweak),
+    );
+    // Convert to schnorr.
+    const outputSchnorrKey = outputEcdsaKey.slice(1);
+    // Create address
+    return toBech32(outputSchnorrKey, 1, this.network.bech32);
+  }
+
+  isTaprootAddress(address: string): boolean {
+    // This prefix check is to avoid returning false in cases where a valid base58 address also happens
+    // to be a valid bech32(m) string (but invalid segwit address).
+    if (address.toLowerCase().startsWith(`${this.network.bech32}1`)) {
+      try {
+        bjs.address.fromBech32(address);
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+export default Bitcoin;