edge-currency-plugins 1.0.0-rc.1

package/lib/common/utxobased/keymanager/keymanager.js

@@ -0,0 +1,1214 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }/* eslint-disable camelcase */
+var _altcoinjs = require('altcoin-js'); var bitcoin = _interopRequireWildcard(_altcoinjs);
+var _biggystring = require('biggystring');
+var _bip32 = require('bip32'); var bip32 = _interopRequireWildcard(_bip32);
+var _bip39 = require('bip39'); var bip39 = _interopRequireWildcard(_bip39);
+var _bitcoinjsmessage = require('bitcoinjs-message'); var _bitcoinjsmessage2 = _interopRequireDefault(_bitcoinjsmessage);
+var _types = require('edge-core-js/types');
+
+var _indexAtProtected = require('../../../util/indexAtProtected');
+var _undefinedIfEmptyString = require('../../../util/undefinedIfEmptyString');
+
+
+
+var _bip69 = require('./bip69');
+
+
+
+
+var _cashAddress = require('./bitcoincashUtils/cashAddress');
+var _coinmapper = require('./coinmapper');
+var _utxopicker = require('./utxopicker'); var utxopicker = _interopRequireWildcard(_utxopicker);
+
+// in bitcoin these are bip44, bip49, bip84 xpub prefixes
+// other coins contain different formats which still need to be gathered.
+var BIP43PurposeTypeEnum; (function (BIP43PurposeTypeEnum) {
+  const Airbitz = 'airbitz'; BIP43PurposeTypeEnum["Airbitz"] = Airbitz;
+  const Legacy = 'legacy'; BIP43PurposeTypeEnum["Legacy"] = Legacy; // xpub/xprv tpub/tprv etc.
+  const Segwit = 'segwit'; BIP43PurposeTypeEnum["Segwit"] = Segwit; // zpub/zprv vpub/vprv etc.
+  const WrappedSegwit = 'wrappedSegwit'; BIP43PurposeTypeEnum["WrappedSegwit"] = WrappedSegwit; // ypub/yprv upub/uprv etc.
+})(BIP43PurposeTypeEnum || (exports.BIP43PurposeTypeEnum = BIP43PurposeTypeEnum = {}));
+
+// supported address types.
+var AddressTypeEnum; (function (AddressTypeEnum) {
+  const p2pkh = 'p2pkh'; AddressTypeEnum["p2pkh"] = p2pkh;
+  const p2sh = 'p2sh'; AddressTypeEnum["p2sh"] = p2sh;
+  const p2wpkh = 'p2wpkh'; AddressTypeEnum["p2wpkh"] = p2wpkh; // short bech32 address
+  const p2wsh = 'p2wsh'; AddressTypeEnum["p2wsh"] = p2wsh; // long bech32 address
+})(AddressTypeEnum || (exports.AddressTypeEnum = AddressTypeEnum = {}));
+
+var ScriptTypeEnum; (function (ScriptTypeEnum) {
+  const p2wpkh = 'p2wpkh'; ScriptTypeEnum["p2wpkh"] = p2wpkh;
+  const p2wpkhp2sh = 'p2wpkhp2sh'; ScriptTypeEnum["p2wpkhp2sh"] = p2wpkhp2sh;
+  const p2wsh = 'p2wsh'; ScriptTypeEnum["p2wsh"] = p2wsh;
+  const p2pk = 'p2pk'; ScriptTypeEnum["p2pk"] = p2pk;
+  const p2pkh = 'p2pkh'; ScriptTypeEnum["p2pkh"] = p2pkh;
+  const p2sh = 'p2sh'; ScriptTypeEnum["p2sh"] = p2sh;
+  const replayProtection = 'replayprotection'; ScriptTypeEnum["replayProtection"] = replayProtection;
+  const replayProtectionP2SH = 'replayprotectionp2sh'; ScriptTypeEnum["replayProtectionP2SH"] = replayProtectionP2SH;
+})(ScriptTypeEnum || (exports.ScriptTypeEnum = ScriptTypeEnum = {}));
+
+// A transaction input is either legacy or segwit. This is used for transaction creation and passed per input
+var TransactionInputTypeEnum; (function (TransactionInputTypeEnum) {
+  const Legacy = 'legacy'; TransactionInputTypeEnum["Legacy"] = Legacy;
+  const Segwit = 'segwit'; TransactionInputTypeEnum["Segwit"] = Segwit;
+})(TransactionInputTypeEnum || (exports.TransactionInputTypeEnum = TransactionInputTypeEnum = {}));
+
+
+
+
+
+
+var VerifyAddressEnum; (function (VerifyAddressEnum) {
+  const good = 'good'; VerifyAddressEnum["good"] = good;
+  const legacy = 'legacy'; VerifyAddressEnum["legacy"] = legacy;
+  const bad = 'bad'; VerifyAddressEnum["bad"] = bad;
+})(VerifyAddressEnum || (exports.VerifyAddressEnum = VerifyAddressEnum = {}));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ function bip43PurposeNumberToTypeEnum(
+  num
+) {
+  switch (num) {
+    case 32:
+      return BIP43PurposeTypeEnum.Airbitz
+    case 44:
+      return BIP43PurposeTypeEnum.Legacy
+    case 49:
+      return BIP43PurposeTypeEnum.WrappedSegwit
+    case 84:
+      return BIP43PurposeTypeEnum.Segwit
+    default:
+      throw new Error('InvalidPurposeNumber')
+  }
+} exports.bip43PurposeNumberToTypeEnum = bip43PurposeNumberToTypeEnum;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const verifyAddressInternal = (
+  prefixIndex,
+  args
+) => {
+  const coinInfo = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    prefixIndex
+  })
+
+  // Special case for CashAddr
+  const cashAddrPrefixes = getCashAddrPrefixes(coinInfo)
+  if (cashAddrPrefixes.length > 0) {
+    // If coin has cashaddr prefixes, and address passes cashaddr validation,
+    // then we return as "valid", otherwise we return as "legacy" if it passes
+    // the normal guess check.
+    try {
+      _cashAddress.cashAddressToHash.call(void 0, args.address, cashAddrPrefixes)
+      return VerifyAddressEnum.good
+    } catch (e) {}
+    guessAddressTypeFromAddress(args.address, network, args.coin, undefined)
+    return VerifyAddressEnum.legacy
+  }
+
+  // Normal case
+  guessAddressTypeFromAddress(args.address, network, args.coin, undefined)
+  // All indices above 0 are treated as legacy
+  return prefixIndex === 0 ? VerifyAddressEnum.good : VerifyAddressEnum.legacy
+}
+
+ const verifyAddress = (args) => {
+  const verification = filterCoinPrefixes(
+    args.coin,
+    prefixIndex => verifyAddressInternal(prefixIndex, args),
+    [`Could not determine address type of ${args.address}`]
+  )
+  return _nullishCoalesce(verification, () => ( VerifyAddressEnum.bad))
+}; exports.verifyAddress = verifyAddress
+
+ const getAddressTypeFromAddress = (
+  address,
+  coinName
+) => {
+  const addressType = filterCoinPrefixes(
+    coinName,
+    prefixIndex => {
+      const network = bip32NetworkFromCoin({
+        coinString: coinName,
+        prefixIndex
+      })
+      return guessAddressTypeFromAddress(address, network, coinName)
+    },
+    [`Could not determine address type of ${address}`]
+  )
+  if (addressType == null) throw new Error('Could not determine address type')
+  return addressType
+}; exports.getAddressTypeFromAddress = getAddressTypeFromAddress
+
+ function seedOrMnemonicToXPriv(args) {
+  // match hexadecimal number from beginning to end of string
+  const isMnemonic = args.seed.includes(' ')
+  const seed = isMnemonic
+    ? bip39.mnemonicToSeedSync(args.seed)
+    : Buffer.from(args.seed, 'base64')
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    sigType: args.type,
+    prefixIndex: 0
+  })
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  const purpose = bip43PurposeTypeEnumToNumber(args.type)
+  const coinType = _nullishCoalesce(args.coinType, () => ( coin.coinType))
+  const account = _nullishCoalesce(args.account, () => ( 0))
+  const bip32FromSeedFunc = _nullishCoalesce(coin.bip32FromSeedFunc, () => ( bip32.fromSeed))
+  const root = bip32FromSeedFunc(seed)
+  root.network = network
+  // treat a detected seed as an airbitz seed
+  return purpose === 32 || !isMnemonic
+    ? root.derive(0).toBase58()
+    : root
+        .deriveHardened(purpose)
+        .deriveHardened(coinType)
+        .deriveHardened(account)
+        .toBase58()
+} exports.seedOrMnemonicToXPriv = seedOrMnemonicToXPriv;
+const xprivToXPubInternal = (
+  prefixIndex,
+  args
+) => {
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    sigType: args.type,
+    prefixIndex
+  })
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  const bip32FromBase58Func = _nullishCoalesce(coin.bip32FromBase58Func, () => ( bip32.fromBase58))
+  return bip32FromBase58Func(args.xpriv, network).neutered().toBase58()
+}
+
+ const xprivToXPub = (args) => {
+  const xpub = filterCoinPrefixes(
+    args.coin,
+    prefixIndex => xprivToXPubInternal(prefixIndex, args),
+    ['Invalid private key']
+  )
+  if (xpub == null) {
+    throw Error('unable to convert xpriv to xpub')
+  }
+  return xpub
+}; exports.xprivToXPub = xprivToXPub
+
+ function derivationLevelScriptHash(
+  scriptTemplate
+) {
+  // currently returns the derivation for an empty script template for a bitcoin cash
+  // replay protection script (without key material)
+  let hash = '0000'
+  hash = bitcoin.crypto
+    .hash160(Buffer.from(scriptTemplate(''), 'hex'))
+    .slice(0, 4)
+    .toString('hex')
+  return parseInt(hash, 16)
+} exports.derivationLevelScriptHash = derivationLevelScriptHash;
+
+ const isPathUsingDerivationLevelScriptHash = (
+  scriptTemplate,
+  path
+) => {
+  return path.changeIndex === derivationLevelScriptHash(scriptTemplate)
+}; exports.isPathUsingDerivationLevelScriptHash = isPathUsingDerivationLevelScriptHash
+
+const xpubToPubkeyInternal = (
+  prefixIndex,
+  args
+) => {
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    sigType: args.type,
+    prefixIndex
+  })
+  const bip32FromBase58Func = _nullishCoalesce(coin.bip32FromBase58Func, () => ( bip32.fromBase58))
+  const node = bip32FromBase58Func(args.xpub, network)
+  return node
+    .derive(args.bip44ChangeIndex)
+    .derive(args.bip44AddressIndex)
+    .publicKey.toString('hex')
+}
+
+ const xpubToPubkey = (args) => {
+  const pubkey = filterCoinPrefixes(
+    args.coin,
+    prefixIndex => xpubToPubkeyInternal(prefixIndex, args),
+    [`Invalid network version`]
+  )
+  if (pubkey == null) {
+    throw Error('unable to derive pubkey from xpub')
+  }
+  return pubkey
+}; exports.xpubToPubkey = xpubToPubkey
+
+const addressToScriptPubkeyInternal = (
+  prefixIndex,
+  args
+) => {
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  const cashAddrPrefixes = getCashAddrPrefixes(coin)
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    prefixIndex
+  })
+  const selectedPrefixes = selectedCoinPrefixes(coin.prefixes, prefixIndex)
+  const addressType = guessAddressTypeFromAddress(
+    args.address,
+    network,
+    args.coin,
+    args.addressType
+  )
+  let payment
+
+  const maybeScriptHashFromCashAddress = () => {
+    try {
+      return _cashAddress.cashAddressToHash.call(void 0, 
+        args.address,
+        cashAddrPrefixes
+      ).scriptHash.toString('hex')
+    } catch (e) {}
+  }
+
+  switch (addressType) {
+    case AddressTypeEnum.p2pkh:
+      if (selectedPrefixes.cashaddr != null) {
+        const scriptHash = maybeScriptHashFromCashAddress()
+        if (scriptHash != null) {
+          const scriptPubkey = scriptHashToScriptPubkey({
+            scriptHash,
+            scriptType: ScriptTypeEnum.p2pkh,
+            coin: args.coin
+          })
+          if (scriptPubkey == null) {
+            throw new Error(
+              `unable to convert address ${args.address} to script pubkey`
+            )
+          }
+          return scriptPubkey
+        }
+      }
+      payment = bitcoin.payments.p2pkh
+      break
+    case AddressTypeEnum.p2sh:
+      if (selectedPrefixes.cashaddr != null) {
+        const scriptHash = maybeScriptHashFromCashAddress()
+        if (scriptHash != null) {
+          const scriptPubkey = scriptHashToScriptPubkey({
+            scriptHash,
+            scriptType: ScriptTypeEnum.p2sh,
+            coin: args.coin
+          })
+          if (scriptPubkey == null) {
+            throw new Error(
+              `unable to convert address ${args.address} to script pubkey`
+            )
+          }
+          return scriptPubkey
+        }
+      }
+      payment = bitcoin.payments.p2sh
+      break
+    case AddressTypeEnum.p2wpkh:
+      payment = bitcoin.payments.p2wpkh
+      break
+    case AddressTypeEnum.p2wsh:
+      payment = bitcoin.payments.p2wsh
+      break
+    default:
+      throw new Error('invalid address type in address to script pubkey')
+  }
+  const scriptPubkey = payment({
+    address: args.address,
+    network: network,
+    bs58DecodeFunc: coin.bs58DecodeFunc,
+    bs58EncodeFunc: coin.bs58EncodeFunc
+  }).output
+  if (scriptPubkey == null) {
+    throw new Error('failed converting address to scriptPubkey')
+  }
+  return scriptPubkey.toString('hex')
+}
+
+ const addressToScriptPubkey = (
+  args
+) => {
+  const scriptPubkey = filterCoinPrefixes(
+    args.coin,
+    prefixIndex => addressToScriptPubkeyInternal(prefixIndex, args),
+    [
+      'Invalid version or Network mismatch',
+      'Invalid prefix or Network mismatch',
+      `InvalidArgument: ${args.address} has Mixed case`,
+      `Could not determine address type of ${args.address}`
+    ]
+  )
+  if (scriptPubkey == null) {
+    throw new Error(
+      `unable to convert address ${args.address} to script pubkey`
+    )
+  }
+  return scriptPubkey
+}; exports.addressToScriptPubkey = addressToScriptPubkey
+
+ function scriptPubkeyToAddress(
+  args
+) {
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    prefixIndex: 0 // standard serialization at index 0
+  })
+  const legacyNetwork = bip32NetworkFromCoin({
+    coinString: args.coin,
+    prefixIndex: 1 // legacy serialziation at index 1
+  })
+  const coinClass = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  const coinPrefixes = coinClass.prefixes
+  const standardPrefixes = selectedCoinPrefixes(coinPrefixes, 0)
+  const legacyPrefixes = selectedCoinPrefixes(coinPrefixes, 1)
+  let address
+  let legacyAddress
+  let payment
+  switch (args.addressType) {
+    case AddressTypeEnum.p2pkh:
+      if (standardPrefixes.cashaddr != null) {
+        address = _cashAddress.hashToCashAddress.call(void 0, 
+          scriptPubkeyToScriptHash({
+            scriptPubkey: args.scriptPubkey,
+            scriptType: ScriptTypeEnum.p2pkh,
+            coin: args.coin
+          }),
+          _cashAddress.CashaddrTypeEnum.pubkeyhash,
+          standardPrefixes.cashaddr
+        )
+      }
+      if (legacyPrefixes.cashaddr != null) {
+        legacyAddress = _cashAddress.hashToCashAddress.call(void 0, 
+          scriptPubkeyToScriptHash({
+            scriptPubkey: args.scriptPubkey,
+            scriptType: ScriptTypeEnum.p2pkh,
+            coin: args.coin
+          }),
+          _cashAddress.CashaddrTypeEnum.pubkeyhash,
+          legacyPrefixes.cashaddr
+        )
+      }
+      payment = bitcoin.payments.p2pkh
+      break
+    case AddressTypeEnum.p2sh:
+      if (standardPrefixes.cashaddr != null) {
+        address = _cashAddress.hashToCashAddress.call(void 0, 
+          scriptPubkeyToScriptHash({
+            scriptPubkey: args.scriptPubkey,
+            scriptType: ScriptTypeEnum.p2sh,
+            coin: args.coin
+          }),
+          _cashAddress.CashaddrTypeEnum.scripthash,
+          standardPrefixes.cashaddr
+        )
+      }
+      if (legacyPrefixes.cashaddr != null) {
+        legacyAddress = _cashAddress.hashToCashAddress.call(void 0, 
+          scriptPubkeyToScriptHash({
+            scriptPubkey: args.scriptPubkey,
+            scriptType: ScriptTypeEnum.p2sh,
+            coin: args.coin
+          }),
+          _cashAddress.CashaddrTypeEnum.scripthash,
+          legacyPrefixes.cashaddr
+        )
+      }
+      payment = bitcoin.payments.p2sh
+      break
+    case AddressTypeEnum.p2wpkh:
+      payment = bitcoin.payments.p2wpkh
+      break
+    case AddressTypeEnum.p2wsh:
+      payment = bitcoin.payments.p2wsh
+      break
+    default:
+      throw new Error('invalid address type in address to script pubkey')
+  }
+  address =
+    _nullishCoalesce(address, () => (
+    payment({
+      output: Buffer.from(args.scriptPubkey, 'hex'),
+      network: network,
+      bs58DecodeFunc: coinClass.bs58DecodeFunc,
+      bs58EncodeFunc: coinClass.bs58EncodeFunc
+    }).address))
+
+  legacyAddress =
+    _nullishCoalesce(legacyAddress, () => (
+    payment({
+      output: Buffer.from(args.scriptPubkey, 'hex'),
+      network: legacyNetwork,
+      bs58DecodeFunc: coinClass.bs58DecodeFunc,
+      bs58EncodeFunc: coinClass.bs58EncodeFunc
+    }).address))
+
+  if (address == null || legacyAddress == null) {
+    throw new Error('failed converting scriptPubkey to address')
+  }
+  return { address, legacyAddress }
+} exports.scriptPubkeyToAddress = scriptPubkeyToAddress;
+
+ function scriptPubkeyToScriptHash(
+  args
+) {
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    prefixIndex: 0
+  })
+  let payment
+  switch (args.scriptType) {
+    case ScriptTypeEnum.p2pkh:
+      payment = bitcoin.payments.p2pkh
+      break
+    case ScriptTypeEnum.p2sh:
+      payment = bitcoin.payments.p2sh
+      break
+    case ScriptTypeEnum.p2wpkh:
+      payment = bitcoin.payments.p2wpkh
+      break
+    default:
+      throw new Error('invalid address type in address to script pubkey')
+  }
+  const scriptHash = payment({
+    output: Buffer.from(args.scriptPubkey, 'hex'),
+    network: network
+  }).hash
+  if (scriptHash == null) {
+    throw new Error('failed converting scriptPubkey to address')
+  }
+  return scriptHash.toString('hex')
+} exports.scriptPubkeyToScriptHash = scriptPubkeyToScriptHash;
+
+ function scriptPubkeyToP2SH(
+  args
+) {
+  const { scriptPubkey, coin } = args
+  let bip32Network
+  if (coin != null) {
+    bip32Network = bip32NetworkFromCoin({
+      coinString: coin,
+      prefixIndex: 0
+    })
+  }
+  const p2sh = bitcoin.payments.p2sh({
+    network: bip32Network,
+    redeem: {
+      output: Buffer.from(scriptPubkey, 'hex')
+    }
+  })
+  if (p2sh.output == null || _optionalChain([p2sh, 'access', _ => _.redeem, 'optionalAccess', _2 => _2.output]) == null) {
+    throw new Error('unable to convert script to p2sh')
+  }
+  return {
+    scriptPubkey: p2sh.output.toString('hex'),
+    redeemScript: p2sh.redeem.output.toString('hex'),
+    address: p2sh.address
+  }
+} exports.scriptPubkeyToP2SH = scriptPubkeyToP2SH;
+
+ function pubkeyToScriptPubkey(
+  args
+) {
+  let payment
+  switch (args.scriptType) {
+    case ScriptTypeEnum.p2pkh:
+      payment = bitcoin.payments.p2pkh({
+        pubkey: Buffer.from(args.pubkey, 'hex')
+      })
+      if (payment.output == null) {
+        throw new Error('failed converting pubkey to script pubkey')
+      }
+      return { scriptPubkey: payment.output.toString('hex') }
+    case ScriptTypeEnum.p2wpkhp2sh:
+      return scriptPubkeyToP2SH({
+        scriptPubkey: pubkeyToScriptPubkey({
+          pubkey: args.pubkey,
+          scriptType: ScriptTypeEnum.p2wpkh
+        }).scriptPubkey
+      })
+    case ScriptTypeEnum.p2wpkh:
+      payment = bitcoin.payments.p2wpkh({
+        pubkey: Buffer.from(args.pubkey, 'hex')
+      })
+      if (payment.output == null) {
+        throw new Error('failed converting pubkey to script pubkey')
+      }
+      return { scriptPubkey: payment.output.toString('hex') }
+    default:
+      throw new Error('invalid address type in pubkey to script pubkey')
+  }
+} exports.pubkeyToScriptPubkey = pubkeyToScriptPubkey;
+
+ const toNewFormat = (address, coinName) => {
+  const addressType = exports.getAddressTypeFromAddress.call(void 0, address, coinName)
+  return scriptPubkeyToAddress({
+    scriptPubkey: exports.addressToScriptPubkey.call(void 0, {
+      address: address,
+      coin: coinName
+    }),
+    addressType,
+    coin: coinName
+  }).address
+}; exports.toNewFormat = toNewFormat
+
+const xprivToPrivateKeyInternal = (
+  prefixIndex,
+  args
+) => {
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    sigType: args.type,
+    prefixIndex
+  })
+  const bip32FromBase58Func = _nullishCoalesce(coin.bip32FromBase58Func, () => ( bip32.fromBase58))
+  const node = bip32FromBase58Func(args.xpriv, network)
+  return _optionalChain([node
+, 'access', _3 => _3.derive, 'call', _4 => _4(args.bip44ChangeIndex)
+, 'access', _5 => _5.derive, 'call', _6 => _6(args.bip44AddressIndex)
+, 'access', _7 => _7.privateKey, 'optionalAccess', _8 => _8.toString, 'call', _9 => _9('hex')])
+}
+
+ const xprivToPrivateKey = (args) => {
+  const privateKey = filterCoinPrefixes(
+    args.coin,
+    prefixIndex => xprivToPrivateKeyInternal(prefixIndex, args),
+    ['Invalid network version']
+  )
+  if (privateKey == null) {
+    throw new Error('Failed to generate private key from xpriv')
+  }
+  return privateKey
+}; exports.xprivToPrivateKey = xprivToPrivateKey
+
+ function privateKeyToWIF(args) {
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    forWIF: true,
+    prefixIndex: 0
+  })
+  const coinClass = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  return bitcoin.ECPair.fromPrivateKey(Buffer.from(args.privateKey, 'hex'), {
+    network
+  }).toWIF(coinClass.wifEncodeFunc)
+} exports.privateKeyToWIF = privateKeyToWIF;
+
+const wifToPrivateKeyInternal = (
+  prefixIndex,
+  args
+) => {
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    forWIF: true,
+    prefixIndex
+  })
+  return _optionalChain([bitcoin, 'access', _10 => _10.ECPair, 'access', _11 => _11.fromWIF, 'call', _12 => _12(
+    args.wifKey,
+    network,
+    coin.bs58DecodeFunc
+  ), 'access', _13 => _13.privateKey, 'optionalAccess', _14 => _14.toString, 'call', _15 => _15('hex')])
+}
+ const wifToPrivateKey = (args) => {
+  const privateKey = filterCoinPrefixes(
+    args.coin,
+    prefixIndex => wifToPrivateKeyInternal(prefixIndex, args),
+    ['Invalid network version']
+  )
+  if (privateKey == null) {
+    throw new Error('Failed to convert WIF key to private key')
+  }
+  return privateKey
+}; exports.wifToPrivateKey = wifToPrivateKey
+
+ function privateKeyToPubkey(privateKey) {
+  return bitcoin.ECPair.fromPrivateKey(
+    Buffer.from(privateKey, 'hex')
+  ).publicKey.toString('hex')
+} exports.privateKeyToPubkey = privateKeyToPubkey;
+
+ function signMessageBase64(message, privateKey) {
+  const keyPair = bitcoin.ECPair.fromPrivateKey(Buffer.from(privateKey, 'hex'))
+  if (keyPair.privateKey == null) {
+    throw new Error('Address could not sign message')
+  }
+  return _bitcoinjsmessage2.default
+    .sign(message, keyPair.privateKey, keyPair.compressed)
+    .toString('base64')
+} exports.signMessageBase64 = signMessageBase64;
+
+ async function makeTx(args) {
+  let sequence = 0xffffffff
+  if (args.setRBF) {
+    sequence -= 2
+  }
+
+  // get coin specific replay protection sighhash bits
+  let sighashType = bitcoin.Transaction.SIGHASH_ALL
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+  if (coin.sighash != null) {
+    sighashType = coin.sighash
+  }
+
+  const useUtxos = []
+  const mappedUtxos = []
+
+  const mergedArray = [...args.utxos, ...args.forceUseUtxo]
+  const uniqueUtxos = [
+    ...mergedArray
+      .filter(utxo => !utxo.spent)
+      .reduce((map, obj) => map.set(obj.id, obj), new Map())
+      .values()
+  ].sort((a, b) => {
+    if (a.blockHeight <= 0 && b.blockHeight > 0) return 1
+    if (b.blockHeight <= 0 && a.blockHeight > 0) return -1
+    return _biggystring.lt.call(void 0, a.value, b.value) ? 1 : _biggystring.gt.call(void 0, a.value, b.value) ? -1 : 0
+  })
+
+  for (const utxo of uniqueUtxos) {
+    // Cannot use a utxo without a script
+    if (utxo.script == null) continue
+    const input = {
+      hash: Buffer.from(utxo.txid, 'hex').reverse(),
+      index: utxo.vout,
+      value: parseInt(utxo.value),
+      script: Buffer.from(utxo.script, 'hex'),
+      scriptPubkey: Buffer.from(utxo.scriptPubkey, 'hex'),
+      scriptType: utxo.scriptType,
+      sequence,
+      sighashType
+    }
+    // Map script type to the correct PsbtInput UTXO field
+    switch (utxo.scriptType) {
+      // Non-segwit
+      case ScriptTypeEnum.p2pk:
+      case ScriptTypeEnum.p2pkh:
+      case ScriptTypeEnum.p2sh:
+      case ScriptTypeEnum.replayProtection:
+      case ScriptTypeEnum.replayProtectionP2SH: {
+        input.nonWitnessUtxo = input.script
+        break
+      }
+      // Segwit
+      case ScriptTypeEnum.p2wpkh:
+      case ScriptTypeEnum.p2wpkhp2sh:
+      case ScriptTypeEnum.p2wsh: {
+        input.witnessUtxo = {
+          script: input.script,
+          value: parseInt(utxo.value)
+        }
+        break
+      }
+      default:
+        throw new Error(`unknown script type ${utxo.scriptType}`)
+    }
+    if (utxo.redeemScript != null) {
+      input.redeemScript = Buffer.from(utxo.redeemScript, 'hex')
+    }
+    let forceUsage = false
+    for (const forceUtxo of args.forceUseUtxo) {
+      if (forceUtxo.id === utxo.id) {
+        useUtxos.push(input)
+        forceUsage = true
+      }
+    }
+    if (!forceUsage) mappedUtxos.push(input)
+  }
+
+  const targets = args.targets.map(target => {
+    const script = exports.addressToScriptPubkey.call(void 0, {
+      address: target.address,
+      coin: coin.name
+    })
+    return {
+      script,
+      value: target.value
+    }
+  })
+  const changeScript = exports.addressToScriptPubkey.call(void 0, {
+    address: args.freshChangeAddress,
+    coin: coin.name
+  })
+
+  const utxoPicker = _nullishCoalesce(coin.utxoPicker, () => ( utxopicker.utxoPicker))
+
+  const utxopicking =
+    args.forceUseUtxo.length > 0
+      ? utxoPicker.forceUseUtxo
+      : _nullishCoalesce(args.subtractFee, () => ( false))
+      ? utxoPicker.subtractFee
+      : utxoPicker.accumulative
+  const result = utxopicking({
+    utxos: mappedUtxos,
+    useUtxos,
+    targets,
+    feeRate: args.feeRate,
+    changeScript
+  })
+  if (result.inputs == null || result.outputs == null) {
+    throw new (0, _types.InsufficientFundsError)(args.coin)
+  }
+
+  const sortedInputs = _bip69.sortInputs.call(void 0, result.inputs)
+  const sortedOutputs = _bip69.sortOutputs.call(void 0, result.outputs)
+
+  const psbt = new bitcoin.Psbt()
+  psbt.addInputs(sortedInputs)
+  psbt.addOutputs(sortedOutputs)
+
+  return {
+    inputs: sortedInputs,
+    outputs: sortedOutputs,
+    changeUsed: result.changeUsed,
+    fee: result.fee,
+    psbtBase64: psbt.toBase64(),
+    hex: _optionalChain([psbt, 'access', _16 => _16.data, 'optionalAccess', _17 => _17.globalMap, 'optionalAccess', _18 => _18.unsignedTx, 'optionalAccess', _19 => _19.toBuffer, 'call', _20 => _20(), 'optionalAccess', _21 => _21.toString, 'call', _22 => _22('hex')])
+  }
+} exports.makeTx = makeTx;
+
+ async function signTx(args) {
+  const psbt = bitcoin.Psbt.fromBase64(args.psbtBase64)
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coin)
+
+  for (let i = 0; i < psbt.inputCount; i++) {
+    const privateKey = Buffer.from(
+      _nullishCoalesce(args.privateKeys[i], () => ( args.privateKeys[args.privateKeys.length - 1])),
+      'hex'
+    )
+    psbt.signInput(
+      i,
+      bitcoin.ECPair.fromPrivateKey(privateKey),
+      bitcoin.Psbt.DEFAULT_SIGHASHES,
+      coin.sighashFunction
+    )
+    psbt.validateSignaturesOfInput(i)
+    psbt.finalizeInput(i)
+  }
+  const tx = psbt.extractTransaction(true)
+  return {
+    id: tx.getId(coin.txHashFunction),
+    hex: tx.toHex()
+  }
+} exports.signTx = signTx;
+
+// ---------------------------------------------------------------------
+// Internal Utilities
+// ---------------------------------------------------------------------
+
+const bip32NetworkFromCoin = (
+  args
+) => {
+  const sigType = _nullishCoalesce(args.sigType, () => ( BIP43PurposeTypeEnum.Legacy))
+  const forWIF = _nullishCoalesce(args.forWIF, () => ( false))
+  const coin = _coinmapper.getCoinFromString.call(void 0, args.coinString)
+  return bip32NetworkFromCoinPrefix(
+    sigType,
+    coin.prefixes,
+    coin.segwit,
+    forWIF,
+    args.prefixIndex
+  )
+}
+
+const bip32NetworkFromCoinPrefix = (
+  sigType,
+  coinPrefixes,
+  _segwit,
+  forWIF,
+  prefixIndex
+) => {
+  let xKeyPrefixes
+  const prefixes = selectedCoinPrefixes(coinPrefixes, prefixIndex)
+
+  switch (sigType) {
+    case BIP43PurposeTypeEnum.Segwit:
+      if (prefixes.segwitXPub == null || prefixes.segwitXPriv == null) {
+        throw new Error('segwit xpub prefix is undefined')
+      }
+      xKeyPrefixes = {
+        public: prefixes.segwitXPub,
+        private: prefixes.segwitXPriv
+      }
+      break
+    case BIP43PurposeTypeEnum.WrappedSegwit:
+      if (
+        prefixes.wrappedSegwitXPub == null ||
+        prefixes.wrappedSegwitXPriv == null
+      ) {
+        throw new Error('wrapped segwit xpub prefix is undefined')
+      }
+      xKeyPrefixes = {
+        public: prefixes.wrappedSegwitXPub,
+        private: prefixes.wrappedSegwitXPriv
+      }
+      break
+    case BIP43PurposeTypeEnum.Legacy:
+    case BIP43PurposeTypeEnum.Airbitz:
+      xKeyPrefixes = {
+        public: prefixes.legacyXPub,
+        private: prefixes.legacyXPriv
+      }
+      break
+    default:
+      throw new Error('invalid bip43 purpose type')
+  }
+
+  const bech32 = _nullishCoalesce(prefixes.bech32, () => ( ''))
+  if (forWIF) {
+    return {
+      messagePrefix: prefixes.messagePrefix,
+      wif: prefixes.wif,
+      bip32: xKeyPrefixes,
+      bech32: bech32,
+      pubKeyHash: prefixes.pubkeyHash,
+      scriptHash: prefixes.scriptHash
+    }
+  }
+  return {
+    messagePrefix: prefixes.messagePrefix,
+    wif: 0x80,
+    bip32: xKeyPrefixes,
+    bech32: bech32,
+    pubKeyHash: prefixes.pubkeyHash,
+    scriptHash: prefixes.scriptHash
+  }
+}
+
+const bip43PurposeTypeEnumToNumber = (
+  purpose
+) => {
+  switch (purpose) {
+    case BIP43PurposeTypeEnum.Airbitz:
+      return 32
+    case BIP43PurposeTypeEnum.Legacy:
+      return 44
+    case BIP43PurposeTypeEnum.WrappedSegwit:
+      return 49
+    case BIP43PurposeTypeEnum.Segwit:
+      return 84
+  }
+}
+
+/**
+ * Filters through a coin's prefixes calling a filter function for each coin
+ * prefixIndex until the function returns a value.
+ * If the function throws an error, the error is can be ignored if it's message
+ * matches one of the given ignoredErrorMessages.
+ */
+const filterCoinPrefixes = (
+  coinName,
+  filterer,
+  ignoredErrorMessages = []
+) => {
+  const coinPrefixes = _coinmapper.getCoinFromString.call(void 0, coinName).prefixes
+  const maxLength = Object.values(coinPrefixes).reduce(
+    (max, prefixes) => Math.max(prefixes.length, max),
+    0
+  )
+  let out
+  for (let prefixIndex = 0; prefixIndex < maxLength; prefixIndex++) {
+    try {
+      out = filterer(prefixIndex)
+    } catch (e) {
+      if (ignoredErrorMessages.includes(e.message)) {
+        continue
+      }
+      throw e
+    }
+    if (out != null) break
+  }
+  return out
+}
+
+const getCashAddrPrefixes = (coinInfo) => {
+  return _nullishCoalesce(coinInfo.prefixes.cashaddr, () => ( []))
+}
+
+const guessAddressTypeFromAddress = (
+  address,
+  network,
+  coin,
+  addressType
+) => {
+  if (addressType != null) {
+    return addressType
+  }
+  const coinClass = _coinmapper.getCoinFromString.call(void 0, coin)
+  try {
+    bitcoin.payments.p2pkh({
+      address,
+      network,
+      bs58DecodeFunc: coinClass.bs58DecodeFunc,
+      bs58EncodeFunc: coinClass.bs58EncodeFunc
+    })
+    return AddressTypeEnum.p2pkh
+  } catch (e) {}
+  try {
+    bitcoin.payments.p2sh({
+      address,
+      network,
+      bs58DecodeFunc: coinClass.bs58DecodeFunc,
+      bs58EncodeFunc: coinClass.bs58EncodeFunc
+    })
+    return AddressTypeEnum.p2sh
+  } catch (e) {}
+  try {
+    bitcoin.payments.p2wsh({ address, network })
+    return AddressTypeEnum.p2wsh
+  } catch (e) {}
+  try {
+    bitcoin.payments.p2wpkh({ address, network })
+    return AddressTypeEnum.p2wpkh
+  } catch (e) {}
+  const cashAddrPrefixes = getCashAddrPrefixes(coinClass)
+  if (cashAddrPrefixes.length > 0) {
+    try {
+      const info = _cashAddress.cashAddressToHash.call(void 0, address, cashAddrPrefixes)
+      if (info.type === _cashAddress.CashaddrTypeEnum.pubkeyhash) {
+        return AddressTypeEnum.p2pkh
+      }
+      return AddressTypeEnum.p2sh
+    } catch (e) {}
+  }
+  throw new Error(`Could not determine address type of ${address}`)
+}
+
+const selectedCoinPrefixes = (
+  prefixes,
+  index
+) => {
+  return {
+    messagePrefix: _indexAtProtected.indexAtProtected.call(void 0, prefixes.messagePrefix, index),
+    wif: _indexAtProtected.indexAtProtected.call(void 0, prefixes.wif, index),
+    legacyXPriv: _indexAtProtected.indexAtProtected.call(void 0, prefixes.legacyXPriv, index),
+    legacyXPub: _indexAtProtected.indexAtProtected.call(void 0, prefixes.legacyXPub, index),
+    wrappedSegwitXPriv: _indexAtProtected.indexAtProtected.call(void 0, prefixes.wrappedSegwitXPriv, index),
+    wrappedSegwitXPub: _indexAtProtected.indexAtProtected.call(void 0, prefixes.wrappedSegwitXPub, index),
+    segwitXPriv: _indexAtProtected.indexAtProtected.call(void 0, prefixes.segwitXPriv, index),
+    segwitXPub: _indexAtProtected.indexAtProtected.call(void 0, prefixes.segwitXPub, index),
+    pubkeyHash: _indexAtProtected.indexAtProtected.call(void 0, prefixes.pubkeyHash, index),
+    scriptHash: _indexAtProtected.indexAtProtected.call(void 0, prefixes.scriptHash, index),
+    bech32: _indexAtProtected.indexAtProtected.call(void 0, prefixes.bech32, index),
+    // Special handling for cashaddr to accommodate legacy addresses.
+    // By allowing them to overflow we will fallback to p2pkh.
+    cashaddr: _undefinedIfEmptyString.undefinedIfEmptyString.call(void 0, (_nullishCoalesce(prefixes.cashaddr, () => ( [])))[index])
+  }
+}
+
+const scriptHashToScriptPubkey = (
+  args
+) => {
+  const network = bip32NetworkFromCoin({
+    coinString: args.coin,
+    prefixIndex: 0
+  })
+  let payment
+  switch (args.scriptType) {
+    case ScriptTypeEnum.p2pkh:
+      payment = bitcoin.payments.p2pkh
+      break
+    case ScriptTypeEnum.p2sh:
+      payment = bitcoin.payments.p2sh
+      break
+    case ScriptTypeEnum.p2wpkh:
+      payment = bitcoin.payments.p2wpkh
+      break
+    default:
+      throw new Error('invalid address type in address to script pubkey')
+  }
+  const scriptPubkey = payment({
+    hash: Buffer.from(args.scriptHash, 'hex'),
+    network: network
+  }).output
+  if (scriptPubkey == null) {
+    throw new Error('failed converting scriptPubkey to address')
+  }
+  return scriptPubkey.toString('hex')
+}