@ledgerhq/coin-bitcoin 0.3.9

package/src/wallet-btc/pickingstrategies/Merge.ts

@@ -0,0 +1,92 @@
+import BigNumber from "bignumber.js";
+import flatten from "lodash/flatten";
+import sortBy from "lodash/sortBy";
+import { NotEnoughBalance } from "@ledgerhq/errors";
+import { Output } from "../storage/types";
+import Xpub from "../xpub";
+import { PickingStrategy } from "./types";
+import * as utils from "../utils";
+import { log } from "@ledgerhq/logs";
+import { OutputInfo } from "..";
+
+/**
+ * prioritize using UTXOs with smaller denominations
+ */
+export class Merge extends PickingStrategy {
+  async selectUnspentUtxosToUse(
+    xpub: Xpub,
+    outputs: OutputInfo[],
+    feePerByte: number,
+  ): Promise<{
+    unspentUtxos: Output[];
+    totalValue: BigNumber;
+    fee: number;
+    needChangeoutput: boolean;
+  }> {
+    // get the utxos to use as input
+    // from all addresses of the account
+    const addresses = await xpub.getXpubAddresses();
+    log("picking strategy", "Merge");
+
+    let unspentUtxos = flatten(
+      await Promise.all(addresses.map(address => xpub.storage.getAddressUnspentUtxos(address))),
+    ).filter(
+      o =>
+        !this.excludedUTXOs.filter(
+          x => x.hash === o.output_hash && x.outputIndex === o.output_index,
+        ).length,
+    );
+
+    const outputScripts = outputs.map(o => o.script);
+    const emptyTxSize = utils.maxTxSizeCeil(0, [], false, this.crypto, this.derivationMode);
+    const sizePerInput =
+      utils.maxTxSize(1, [], false, this.crypto, this.derivationMode) - emptyTxSize;
+
+    const sizePerOutput =
+      (outputScripts[0]
+        ? utils.maxTxSize(0, [outputScripts[0]], false, this.crypto, this.derivationMode)
+        : utils.maxTxSize(0, [], true, this.crypto, this.derivationMode)) - emptyTxSize;
+
+    unspentUtxos = sortBy(unspentUtxos, utxo => parseInt(utxo.value, 10));
+    // https://metamug.com/article/security/bitcoin-transaction-fee-satoshi-per-byte.html
+    const txSizeNoInput = utils.maxTxSize(
+      0,
+      outputScripts,
+      false,
+      this.crypto,
+      this.derivationMode,
+    );
+    let fee = txSizeNoInput * feePerByte;
+
+    let total = new BigNumber(0);
+    const unspentUtxoSelected: Output[] = [];
+
+    let i = 0;
+    const amount = outputs.reduce((sum, output) => sum.plus(output.value), new BigNumber(0));
+    while (total.lt(amount.plus(fee))) {
+      if (!unspentUtxos[i]) {
+        throw new NotEnoughBalance();
+      }
+      total = total.plus(unspentUtxos[i].value);
+      unspentUtxoSelected.push(unspentUtxos[i]);
+      fee += sizePerInput * feePerByte;
+      i += 1;
+    }
+    if (total.minus(amount.plus(fee)).lt(sizePerOutput * feePerByte)) {
+      // not enough fund to make a change output
+      return {
+        totalValue: total,
+        unspentUtxos: unspentUtxoSelected,
+        fee: Math.ceil(fee),
+        needChangeoutput: false,
+      };
+    }
+    fee += sizePerOutput * feePerByte; // fee to make a change output
+    return {
+      totalValue: total,
+      unspentUtxos: unspentUtxoSelected,
+      fee: Math.ceil(fee),
+      needChangeoutput: true,
+    };
+  }
+}

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

@@ -0,0 +1,44 @@
+import BigNumber from "bignumber.js";
+import { OutputInfo } from "..";
+import { ICrypto } from "../crypto/types";
+import { Output } from "../storage/types";
+import Xpub from "../xpub";
+
+export abstract class PickingStrategy {
+  crypto: ICrypto;
+
+  derivationMode: string;
+
+  // TODO Write tests for excluded UTXOs
+  excludedUTXOs: Array<{
+    hash: string;
+    outputIndex: number;
+  }>;
+
+  constructor(
+    crypto: ICrypto,
+    derivationMode: string,
+    excludedUTXOs: Array<{
+      hash: string;
+      outputIndex: number;
+    }>,
+  ) {
+    this.crypto = crypto;
+    this.derivationMode = derivationMode;
+    this.excludedUTXOs = excludedUTXOs;
+  }
+
+  /**
+   * returns the unspent UTXOs to use as input for the transaction
+   */
+  abstract selectUnspentUtxosToUse(
+    xpub: Xpub,
+    outputs: OutputInfo[],
+    feePerByte: number,
+  ): Promise<{
+    unspentUtxos: Output[];
+    totalValue: BigNumber;
+    fee: number;
+    needChangeoutput: boolean;
+  }>;
+}

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

@@ -0,0 +1,282 @@
+import findLast from "lodash/findLast";
+import filter from "lodash/filter";
+import uniqBy from "lodash/uniqBy";
+import findIndex from "lodash/findIndex";
+import Base from "../crypto/base";
+import { Input, IStorage, Output, TX, Address, Block } from "./types";
+
+// a mock storage class that just use js objects
+// sql.js would be perfect for the job
+class BitcoinLikeStorage implements IStorage {
+  private txs: TX[] = [];
+
+  // indexe: address + hash -> tx
+  primaryIndex: { [key: string]: number } = {};
+
+  // indexe: account + index -> tx
+  accountIndex: { [key: string]: number[] } = {};
+
+  // accounting
+  unspentUtxos: { [key: string]: Output[] } = {};
+
+  addressCache: Record<string, string> = {};
+
+  // only needed to handle the case when the input
+  // is seen before the output (typically explorer
+  // returning unordered tx within the same block)
+  spentUtxos: { [key: string]: Input[] } = {};
+
+  hasTx(txFilter: { account: number; index: number }): boolean {
+    const index = `${txFilter.account}-${txFilter.index}`;
+    return !!this.accountIndex[index] && this.accountIndex[index].length > 0;
+  }
+
+  txsSize(): number {
+    return this.txs.length;
+  }
+
+  hasPendingTx(txFilter: { account: number; index: number }): boolean {
+    const index = `${txFilter.account}-${txFilter.index}`;
+    return (
+      !!this.accountIndex[index] &&
+      this.accountIndex[index].map(i => this.txs[i]).some(tx => !tx.block)
+    );
+  }
+  getHighestBlockHeightAndHash(): Block | null {
+    let highestBlock: Block | null = null;
+    this.txs.forEach(tx => {
+      if (!!tx.block && (!highestBlock || tx.block.height > highestBlock.height)) {
+        highestBlock = tx.block;
+      }
+    });
+    return highestBlock;
+  }
+
+  getLastConfirmedTxBlock(txFilter: { account: number; index: number }): Block | null {
+    if (typeof this.accountIndex[`${txFilter.account}-${txFilter.index}`] === "undefined") {
+      return null;
+    }
+    let lastConfirmedTxBlock: Block | null = null;
+    this.accountIndex[`${txFilter.account}-${txFilter.index}`]
+      .map(i => this.txs[i])
+      .forEach(tx => {
+        if (
+          !!tx.block &&
+          (!lastConfirmedTxBlock || tx.block.height > lastConfirmedTxBlock.height)
+        ) {
+          lastConfirmedTxBlock = tx.block;
+        }
+      });
+    return lastConfirmedTxBlock;
+  }
+
+  getLastUnconfirmedTx(): TX | undefined {
+    const tx: TX | undefined = findLast(this.txs, t => {
+      return !t.block;
+    });
+    return tx;
+  }
+
+  getTx(address: string, txId: string): TX {
+    const index = `${address}-${txId}`;
+    return this.txs[this.primaryIndex[index]];
+  }
+
+  // TODO: only expose unspentUtxos
+  getAddressUnspentUtxos(address: Address): Output[] {
+    const indexAddress = address.address;
+    return this.unspentUtxos[indexAddress];
+  }
+
+  /**
+   * add a list of txs to the current account
+   * update related indexes and UTXOs of the account
+   */
+  appendTxs(txs: TX[]): number {
+    const lastLength = this.txs.length;
+
+    txs.forEach(tx => {
+      const indexAddress = tx.address;
+      const index = `${indexAddress}-${tx.id}`;
+
+      // we reject already seen tx
+      if (this.txs[this.primaryIndex[index]]) {
+        return;
+      }
+      const idx = this.txs.push(tx) - 1;
+      this.primaryIndex[index] = idx;
+      this.accountIndex[`${tx.account}-${tx.index}`] =
+        this.accountIndex[`${tx.account}-${tx.index}`] || [];
+      this.accountIndex[`${tx.account}-${tx.index}`].push(idx);
+      this.unspentUtxos[indexAddress] = this.unspentUtxos[indexAddress] || [];
+      this.spentUtxos[indexAddress] = this.spentUtxos[indexAddress] || [];
+
+      tx.outputs.forEach(output => {
+        if (output.address === tx.address) {
+          this.unspentUtxos[indexAddress].push(output);
+        }
+      });
+
+      tx.inputs.forEach(input => {
+        if (input.address === tx.address) {
+          this.spentUtxos[indexAddress].push(input);
+        }
+      });
+
+      this.unspentUtxos[indexAddress] = this.unspentUtxos[indexAddress].filter(output => {
+        const matchIndex = findIndex(
+          this.spentUtxos[indexAddress],
+          (input: Input) =>
+            input.output_hash === output.output_hash && input.output_index === output.output_index,
+        );
+        if (matchIndex > -1) {
+          this.spentUtxos[indexAddress].splice(matchIndex, 1);
+          return false;
+        }
+        return true;
+      });
+    });
+
+    return this.txs.length - lastLength;
+  }
+
+  getUniquesAddresses(addressesFilter: { account?: number; index?: number }): Address[] {
+    // TODO: to speed up, create more useful indexes in appendTxs
+    return uniqBy(
+      filter(
+        this.txs,
+        t =>
+          (typeof addressesFilter.account === "undefined" ||
+            addressesFilter.account === t.account) &&
+          (typeof addressesFilter.index === "undefined" || addressesFilter.index === t.index),
+      ).map((tx: TX) => ({
+        address: tx.address,
+        account: tx.account,
+        index: tx.index,
+      })),
+      "address",
+    );
+  }
+
+  removeTxs(txsFilter: { account: number; index: number }): void {
+    const newTxs: TX[] = [];
+    this.primaryIndex = {};
+    this.accountIndex = {};
+    this.txs.forEach((tx: TX) => {
+      // clean
+      const indexAddress = tx.address;
+      const index = `${indexAddress}-${tx.id}`;
+
+      if (tx.account !== txsFilter.account || tx.index !== txsFilter.index) {
+        this.primaryIndex[index] = newTxs.push(tx) - 1;
+        return;
+      }
+
+      delete this.unspentUtxos[indexAddress];
+      delete this.spentUtxos[indexAddress];
+    });
+    this.txs = newTxs;
+    this.createAccountIndex();
+  }
+
+  // We are a bit ugly because we can't rely undo unspentUTXO
+  // So we clean the address and rebuild without the pendings
+  removePendingTxs(txsFilter: { account: number; index: number }): void {
+    const newTxs: TX[] = [];
+    const txsToReAdd: TX[] = [];
+    this.primaryIndex = {};
+    this.accountIndex = {};
+    this.txs.forEach((tx: TX) => {
+      // clean
+      const indexAddress = tx.address;
+      const index = `${indexAddress}-${tx.id}`;
+
+      if (tx.account !== txsFilter.account || tx.index !== txsFilter.index) {
+        this.primaryIndex[index] = newTxs.push(tx) - 1;
+        return;
+      }
+
+      if (tx.block) {
+        txsToReAdd.push(tx);
+      }
+
+      delete this.unspentUtxos[indexAddress];
+      delete this.spentUtxos[indexAddress];
+    });
+
+    this.txs = newTxs;
+    this.createAccountIndex();
+    this.appendTxs(txsToReAdd);
+  }
+
+  addAddress(key: string, address: string): void {
+    if (!this.addressCache) {
+      this.addressCache = {};
+    }
+    this.addressCache[key] = address;
+  }
+
+  exportSync(): { txs: TX[]; addressCache: Record<string, string> } {
+    return {
+      txs: this.txs,
+      addressCache: this.addressCache,
+    };
+  }
+
+  loadSync(data: { txs: TX[]; addressCache: Record<string, string> }) {
+    this.txs = [];
+    this.primaryIndex = {};
+    this.accountIndex = {};
+    this.unspentUtxos = {};
+    this.spentUtxos = {};
+    data.txs.forEach(tx => {
+      // migration from the field "hash" to "id" to adapt old data format
+      if (!tx.id && tx.hash) {
+        tx.id = tx.hash;
+      }
+    });
+    this.appendTxs(data.txs);
+    this.addressCache = data.addressCache;
+    const addressCacheConverted: Record<string, Promise<string>> = Object.keys(
+      this.addressCache,
+    ).reduce(
+      (acc, key) => ({
+        ...acc,
+        [key]: Promise.resolve(this.addressCache[key]),
+      }),
+      {},
+    );
+    Base.addressCache = {
+      ...Base.addressCache,
+      ...addressCacheConverted,
+    };
+  }
+
+  /**
+   * export the storage data(txs, UTXOs, index...) to app.json
+   */
+  async export(): Promise<{
+    txs: TX[];
+    addressCache: Record<string, string>;
+  }> {
+    return this.exportSync();
+  }
+
+  /**
+   * load account data(txs, UTXOs, index...) from app.json
+   */
+  async load(data: { txs: TX[]; addressCache: Record<string, string> }): Promise<void> {
+    return this.loadSync(data);
+  }
+
+  private createAccountIndex() {
+    this.txs.forEach((tx: TX, idx: number) => {
+      if (typeof this.accountIndex[`${tx.account}-${tx.index}`] === "undefined") {
+        this.accountIndex[`${tx.account}-${tx.index}`] = [];
+      }
+      this.accountIndex[`${tx.account}-${tx.index}`].push(idx);
+    });
+  }
+}
+
+export default BitcoinLikeStorage;

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

@@ -0,0 +1,61 @@
+export interface TX {
+  id: string;
+  hash?: string;
+  account: number;
+  index: number;
+  received_at: string;
+  block: Block | null;
+  address: string;
+  inputs: Input[];
+  outputs: Output[];
+  fees?: number;
+}
+
+export interface Input {
+  value: string;
+  address: string;
+  output_hash: string;
+  output_index: number;
+  sequence: number;
+}
+
+export interface Output {
+  value: string;
+  address: string;
+  output_hash: string;
+  output_index: number;
+  block_height: number | null;
+  // TODO Write tests for RBF unconfirmed outputs
+  rbf: boolean;
+}
+
+export interface Block {
+  height: number;
+  hash: string;
+  time: string;
+}
+
+export interface Address {
+  account: number;
+  index: number;
+  address: string;
+}
+
+export interface IStorage {
+  appendTxs(txs: TX[]): number;
+  getAddressUnspentUtxos(address: Address): Output[];
+  getLastConfirmedTxBlock(txFilter: { account: number; index: number }): Block | null;
+  hasTx(txFilter: { account: number; index: number }): boolean;
+  hasPendingTx(txFilter: { account: number; index: number }): boolean;
+  getLastUnconfirmedTx(): TX | undefined;
+  getHighestBlockHeightAndHash(): Block | null;
+  getTx(address: string, txId: string): TX | undefined;
+  getUniquesAddresses(addressesFilter: { account?: number; index?: number }): Address[];
+  removeTxs(txsFilter: { account: number; index: number }): void;
+  removePendingTxs(txsFilter: { account: number; index: number }): void;
+  addAddress(key: string, address: string): void;
+  export(): Promise<unknown>;
+  load(data: unknown): Promise<void>;
+  exportSync(): unknown;
+  loadSync(data: unknown): void;
+}

package/src/wallet-btc/types.ts

@@ -0,0 +1,28 @@
+import BigNumber from "bignumber.js";
+import { Address, Input } from "./storage/types";
+
+export enum DerivationModes {
+  LEGACY = "Legacy",
+  NATIVE_SEGWIT = "Native SegWit", // This is for native segwit v0
+  SEGWIT = "SegWit", // This is wrapped segwit v0 (wrapping is only allowed for v0)
+  TAPROOT = "Taproot", // This is for segwit v1+
+}
+
+export type InputInfo = Input & { txHex: string };
+
+export type OutputInfo = {
+  script: Buffer;
+  value: BigNumber;
+  // address can be null if OP_RETURN transaction
+  address: string | null;
+  isChange: boolean;
+};
+
+// Used when building a transaction to sign and broadcast
+export type TransactionInfo = {
+  inputs: InputInfo[];
+  associatedDerivations: [number, number][];
+  outputs: OutputInfo[];
+  fee: number;
+  changeAddress: Address;
+};

package/src/wallet-btc/utils.ts

@@ -0,0 +1,195 @@
+import { DerivationModes } from "./types";
+import { Currency, ICrypto } from "./crypto/types";
+import cryptoFactory from "./crypto/factory";
+import { fallbackValidateAddress } from "./crypto/base";
+import { UnsupportedDerivation } from "@ledgerhq/coin-framework/errors";
+import varuint from "varuint-bitcoin";
+
+export function byteSize(count: number): number {
+  if (count < 0xfd) {
+    return 1;
+  }
+  if (count <= 0xffff) {
+    return 3;
+  }
+  if (count <= 0xffffffff) {
+    return 5;
+  }
+  return 9;
+}
+
+const baseByte = 4;
+function fixedWeight(currency: ICrypto, derivationMode: string): number {
+  let fixedWeight = 4 * baseByte; // Transaction version
+  if (currency.network.usesTimestampedTransaction) fixedWeight += 4 * baseByte; // Timestamp
+  fixedWeight += 4 * baseByte; // Timelock
+  if (derivationMode !== DerivationModes.LEGACY) {
+    fixedWeight += 2; // Segwit marker & segwit flag, 1 WU per byte
+  }
+  return fixedWeight;
+}
+
+function inputWeight(derivationMode: string): number {
+  let inputWeight = (32 + 4 + 1 + 4) * baseByte;
+  if (derivationMode === DerivationModes.TAPROOT) {
+    inputWeight += 1 + 1 + 65;
+  } else if (derivationMode === DerivationModes.NATIVE_SEGWIT) {
+    inputWeight += 1 + 1 + 72 + 1 + 33;
+  } else if (derivationMode === DerivationModes.SEGWIT) {
+    inputWeight += 22 * baseByte + 1 + 1 + 72 + 1 + 33;
+  } else if (derivationMode === DerivationModes.LEGACY) {
+    inputWeight += 107 * baseByte;
+  } else {
+    throw UnsupportedDerivation(`Derivation mode ${derivationMode} unknown`);
+  }
+  return inputWeight;
+}
+
+function outputWeight(derivationMode: string): number {
+  let outputSize = 8 + 1; // amount + script size
+  if (derivationMode === DerivationModes.TAPROOT) {
+    outputSize += 34; // "1" + PUSH32 + <32 bytes>
+  } else if (derivationMode === DerivationModes.NATIVE_SEGWIT) {
+    outputSize += 22; // "0" + PUSH20 + <20 bytes>
+  } else if (derivationMode === DerivationModes.SEGWIT) {
+    outputSize += 23; // HASH160 + PUSH20 + <20 bytes> + EQUAL
+  } else if (derivationMode === DerivationModes.LEGACY) {
+    outputSize += 25; // DUP + HASH160 + PUSH20 + <20 bytes> + EQUALVERIFY + CHECKSIG
+  } else {
+    throw UnsupportedDerivation(derivationMode);
+  }
+
+  return outputSize * 4;
+}
+
+export function outputSize(currency: ICrypto, outputScript: Buffer): number {
+  let size = 1 + 8 + outputScript.length;
+  // More bytes for decred
+  if (currency.network.name === "Decred") {
+    size += 8;
+  }
+
+  return size;
+}
+
+/**
+ * Calculates the maximun size of an imaginary transaction in virtual bytes
+ * (vB). 1vB = 4 WU (weight units). If a cryptocurrency doesn't use segwit, then
+ * 1 byte = 1 vB. Weight units are used for segwit transactions, where certain
+ * bytes of the transaction is counted as 4 WU and some as 1 WU. The resulting
+ * size is then ceil(totalWU/4) vB.
+ *
+ * refer to https://medium.com/coinmonks/on-bitcoin-transaction-sizes-part-2-9445373d17f4
+ * and https://bitcoin.stackexchange.com/questions/96017/what-are-the-sizes-of-single-sig-and-2-of-3-multisig-taproot-inputs
+ * and https://bitcoinops.org/en/tools/calc-size/
+ *
+ * Suggested improvement: I assume that these calculations won't be exactly
+ * correct for altcoins (but I don't know). Therefore we should move this
+ * functionality into ICrypto, to make it easier to provide slightly different
+ * calculations for different cryptocurrencies.
+ *
+ * The reason for the name maxTxSize, instead of just txSize, is that the size
+ * of modern ecdsa signatures aren't know beforehand. They are either 71 or
+ * 72 bytes. This function always count with 72 byte signatures.
+ *
+ * The size of schnorr signatures is expected to be 65 bytes, since the Bitcoin
+ * hardware app appends the optional sighash type 01 at the end of the
+ * signature. If the app removes that optional byte, this functions should be
+ * updated to use 64 byte schnorr signatures, even if 65 still is an acceptable
+ * maximum.
+ *
+ * @param inputCount Number of inputs of the imaginary transaction
+ * @param outputAddrs The addresses of the outputs, excluding change.
+ * @param includeChange Indicates whether we should add a change output. The
+ * change output will have the same derivation mode as the inputs. See
+ * derivationMode parameter.
+ * @param currency The currency for which the calculation is done.
+ * @param derivationMode The derivation mode used for calculating the size of
+ * the inputs.
+ */
+export function maxTxSize(
+  inputCount: number,
+  outputScripts: Buffer[],
+  includeChange: boolean,
+  currency: ICrypto,
+  derivationMode: string,
+): number {
+  const fixed = fixedWeight(currency, derivationMode);
+
+  let outputsWeight = byteSize(outputScripts.length) * baseByte; // Number of outputs;
+  outputScripts.forEach(script => {
+    outputsWeight += outputSize(currency, script) * baseByte;
+  });
+
+  if (includeChange) {
+    outputsWeight += outputWeight(derivationMode);
+  }
+
+  // Input: 32 PrevTxHash + 4 Index + 1 scriptSigLength + 4 sequence
+  let inputsWeight = byteSize(inputCount) * baseByte; // Number of inputs
+  inputsWeight += inputWeight(derivationMode) * inputCount;
+  // More bytes for decred, refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/api_impl/BitcoinLikeTransactionApi.cpp#L162
+  if (currency.network.name === "Decred") {
+    inputsWeight += 64 * inputCount;
+  }
+  const txWeight = fixed + inputsWeight + outputsWeight;
+
+  return txWeight / 4;
+}
+
+export function maxTxSizeCeil(
+  inputCount: number,
+  outputScripts: Buffer[],
+  includeChange: boolean,
+  currency: ICrypto,
+  derivationMode: string,
+): number {
+  const s = maxTxSize(inputCount, outputScripts, includeChange, currency, derivationMode);
+
+  return Math.ceil(s);
+}
+
+// refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/api_impl/BitcoinLikeTransactionApi.cpp#L253
+export function computeDustAmount(currency: ICrypto, txSize: number): number {
+  let dustAmount = currency.network.dustThreshold;
+  switch (currency.network.dustPolicy) {
+    case "PER_KBYTE":
+      dustAmount = (dustAmount * txSize) / 1000;
+      break;
+    case "PER_BYTE":
+      dustAmount *= txSize;
+      break;
+    default:
+      break;
+  }
+
+  return dustAmount;
+}
+
+export function isValidAddress(address: string, currency?: Currency): boolean {
+  if (!currency) {
+    // If the caller doesn't provide the currency, we'll
+    // fallback to a pre-taproot basic validation that doesn't
+    // check every aspect of the address
+    return fallbackValidateAddress(address);
+  }
+  const crypto = cryptoFactory(currency);
+  return crypto.validateAddress(address);
+}
+
+export function isTaprootAddress(address: string, currency?: Currency): boolean {
+  if (currency === "bitcoin") {
+    return cryptoFactory("bitcoin").isTaprootAddress(address);
+  } else if (currency === "bitcoin_testnet") {
+    return cryptoFactory("bitcoin_testnet").isTaprootAddress(address);
+  } else {
+    return false;
+  }
+}
+
+export function writeVarInt(buffer: Buffer, i: number, offset: number): number {
+  // refer to https://github.com/bitcoinjs/bitcoinjs-lib/blob/1f44f722d30cd14a1861c8546e6b455f73862c1e/src/bufferutils.js#L78
+  varuint.encode(i, buffer, offset);
+  offset += varuint.encode.bytes;
+  return offset;
+}