edge-currency-plugins 1.0.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Edge (formerly Airbitz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# edge-currency-plugins 
+
+> Plugins for edge-core-js to support various cryptocurrencies such as bitcoin, bitcoin cash, and litecoin, 

package/lib/bch.js

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }
+
+var _makeCurrencyPlugin = require('./common/plugin/makeCurrencyPlugin');
+var _bitcoincash = require('./common/utxobased/info/bitcoincash');
+
+const plugin = (options) =>
+  _makeCurrencyPlugin.makeCurrencyPlugin.call(void 0, options, _bitcoincash.info)
+
+if (typeof window !== 'undefined') {
+  _optionalChain([window, 'access', _ => _.addEdgeCorePlugins, 'optionalCall', _2 => _2({
+    [_bitcoincash.info.currencyInfo.pluginId]: plugin
+  })])
+}
+
+exports. default = plugin

package/lib/bsv.js

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }
+
+var _makeCurrencyPlugin = require('./common/plugin/makeCurrencyPlugin');
+var _bitcoinsv = require('./common/utxobased/info/bitcoinsv');
+
+const plugin = (options) =>
+  _makeCurrencyPlugin.makeCurrencyPlugin.call(void 0, options, _bitcoinsv.info)
+
+if (typeof window !== 'undefined') {
+  _optionalChain([window, 'access', _ => _.addEdgeCorePlugins, 'optionalCall', _2 => _2({
+    [_bitcoinsv.info.currencyInfo.pluginId]: plugin
+  })])
+}
+
+exports. default = plugin

package/lib/btc.js

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }
+
+var _makeCurrencyPlugin = require('./common/plugin/makeCurrencyPlugin');
+var _bitcoin = require('./common/utxobased/info/bitcoin');
+
+const plugin = (options) =>
+  _makeCurrencyPlugin.makeCurrencyPlugin.call(void 0, options, _bitcoin.info)
+
+if (typeof window !== 'undefined') {
+  _optionalChain([window, 'access', _ => _.addEdgeCorePlugins, 'optionalCall', _2 => _2({
+    [_bitcoin.info.currencyInfo.pluginId]: plugin
+  })])
+}
+
+exports. default = plugin

package/lib/common/constants.js

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); const IMAGE_SERVER_URL = 'https://content.edge.app'; exports.IMAGE_SERVER_URL = IMAGE_SERVER_URL
+ const INFO_SERVER_URI = 'https://info1.edgesecure.co:8444/v1'; exports.INFO_SERVER_URI = INFO_SERVER_URI
+
+// Fees
+ const FEES_PATH = 'fees.json'; exports.FEES_PATH = FEES_PATH
+ const MAX_FEE = 999999999.0; exports.MAX_FEE = MAX_FEE
+ const LOW_FEE = 2; exports.LOW_FEE = LOW_FEE
+ const MAX_HIGH_DELAY = 200; exports.MAX_HIGH_DELAY = MAX_HIGH_DELAY
+ const MAX_STANDARD_DELAY = 6; exports.MAX_STANDARD_DELAY = MAX_STANDARD_DELAY
+ const MIN_STANDARD_DELAY = 2; exports.MIN_STANDARD_DELAY = MIN_STANDARD_DELAY
+ const MIN_LOW_DELAY = 1; exports.MIN_LOW_DELAY = MIN_LOW_DELAY

package/lib/common/fees/calcMinerFeePerByte.js

@@ -0,0 +1,62 @@
+"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; } }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
+
+
+
+
+
+
+/**
+ * Calculate the sat/byte mining fee given an amount to spend and a SimpleFeeSettings object
+ * @param nativeAmount
+ * @param fees
+ * @param networkFeeOption
+ * @param customNetworkFee
+ * @returns {string}
+ */
+ const calcMinerFeePerByte = (
+  nativeAmount,
+  fees,
+  networkFeeOption,
+  customNetworkFee
+) => {
+  switch (networkFeeOption) {
+    case 'low':
+      return fees.lowFee
+
+    case 'standard': {
+      if (bs.gte(nativeAmount, fees.standardFeeHighAmount)) {
+        return fees.standardFeeHigh
+      }
+      if (bs.lte(nativeAmount, fees.standardFeeLowAmount)) {
+        return fees.standardFeeLow
+      }
+
+      // Scale the fee by the amount the user is sending scaled between standardFeeLowAmount and standardFeeHighAmount
+      const lowHighAmountDiff = bs.sub(
+        fees.standardFeeHighAmount,
+        fees.standardFeeLowAmount
+      )
+      const lowHighFeeDiff = bs.sub(fees.standardFeeHigh, fees.standardFeeLow)
+
+      // How much above the lowFeeAmount is the user sending
+      const amountDiffFromLow = bs.sub(nativeAmount, fees.standardFeeLowAmount)
+
+      // Add this much to the low fee = (amountDiffFromLow * lowHighFeeDiff) / lowHighAmountDiff)
+      const temp1 = bs.mul(amountDiffFromLow, lowHighFeeDiff)
+      const addFeeToLow = bs.div(temp1, lowHighAmountDiff)
+      return bs.add(fees.standardFeeLow, addFeeToLow)
+    }
+
+    case 'high':
+      return fees.highFee
+
+    case 'custom':
+      if (customNetworkFee == null || customNetworkFee === '0') {
+        throw new Error(`Invalid custom network fee: ${customNetworkFee}`)
+      }
+      return customNetworkFee
+
+    default:
+      throw new Error(`Invalid networkFeeOption: ${networkFeeOption}`)
+  }
+}; exports.calcMinerFeePerByte = calcMinerFeePerByte

package/lib/common/fees/makeFees.js

@@ -0,0 +1,182 @@
+"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 _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; }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
+var _cleaners = require('cleaners');
+
+
+
+
+
+
+
+var _memlet = require('memlet');
+
+var _constants = require('../constants');
+
+
+
+
+var _types3 = require('../plugin/types');
+var _calcMinerFeePerByte = require('./calcMinerFeePerByte');
+var _processInfoServerFees = require('./processInfoServerFees');
+var _processMempoolSpaceFees = require('./processMempoolSpaceFees');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const makeFees = async (config) => {
+  const { disklet, pluginInfo, ...common } = config
+  const { currencyInfo, engineInfo } = pluginInfo
+
+  const memlet = _memlet.makeMemlet.call(void 0, disklet)
+  const fees = await fetchCachedFees(
+    memlet,
+    engineInfo.simpleFeeSettings
+  )
+  // The last time the fees were updated
+  let timestamp = 0
+  let vendorIntervalId
+
+  const updateVendorFees = async () => {
+    if (Date.now() - timestamp <= engineInfo.feeUpdateInterval) return
+
+    const vendorFees = await fetchFeesFromVendor({
+      ...common,
+      mempoolSpaceFeeInfoServer: engineInfo.mempoolSpaceFeeInfoServer
+    })
+    Object.assign(fees, _nullishCoalesce(vendorFees, () => ( {})))
+    timestamp = Date.now()
+
+    await cacheFees(memlet, fees)
+  }
+
+  return {
+    async start() {
+      const edgeFees = await fetchFees({
+        ...common,
+        uri: `${_constants.INFO_SERVER_URI}/networkFees/${currencyInfo.currencyCode}`,
+        processor: _processInfoServerFees.processInfoServerFees
+      })
+      Object.assign(fees, edgeFees)
+      await updateVendorFees()
+      vendorIntervalId = setInterval(
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        updateVendorFees,
+        engineInfo.feeUpdateInterval
+      )
+    },
+
+    stop() {
+      clearInterval(vendorIntervalId)
+    },
+
+    async clearCache() {
+      await memlet.delete(_constants.FEES_PATH)
+    },
+
+    async getRate(edgeSpendInfo) {
+      const {
+        spendTargets,
+        networkFeeOption = 'standard',
+        customNetworkFee = {},
+        otherParams = {}
+      } = edgeSpendInfo
+
+      const requiredFeeRate =
+        _optionalChain([otherParams, 'access', _ => _.paymentProtocolInfo, 'optionalAccess', _2 => _2.merchant, 'optionalAccess', _3 => _3.requiredFeeRate])
+      if (requiredFeeRate != null) {
+        const rate = bs.add(bs.mul(`${requiredFeeRate}`, '1.5'), '1')
+        return bs.toFixed(rate, 0, 0)
+      }
+
+      const customFeeTemplate = (_nullishCoalesce(currencyInfo.customFeeTemplate, () => ( [])))[0]
+      if (customFeeTemplate == null) throw new Error('No custom fee template')
+
+      const rate = _calcMinerFeePerByte.calcMinerFeePerByte.call(void 0, 
+        sumSpendTargets(spendTargets),
+        fees,
+        networkFeeOption,
+        customNetworkFee[customFeeTemplate.key]
+      )
+      return rate
+    },
+
+    get fees() {
+      return fees
+    }
+  }
+}; exports.makeFees = makeFees
+
+const fetchCachedFees = async (
+  memlet,
+  fallback
+) => {
+  const data = await memlet.getJson(_constants.FEES_PATH).catch(() => undefined)
+  const feeSettings = _cleaners.asMaybe.call(void 0, _types3.asSimpleFeeSettings, fallback)(data)
+  return feeSettings
+}
+
+const cacheFees = async (
+  memlet,
+  fees
+) => await memlet.setJson(_constants.FEES_PATH, fees)
+
+const sumSpendTargets = (spendTargets) =>
+  spendTargets.reduce((amount, { nativeAmount }) => {
+    if (nativeAmount == null)
+      throw new Error(`Invalid spend target amount: ${nativeAmount}`)
+    return bs.add(amount, nativeAmount)
+  }, '0')
+
+
+
+
+
+const fetchFees = async ( args) => {
+  const { uri, processor, io, log } = args
+
+  try {
+    const response = await io.fetch(uri)
+    if (!response.ok) throw new Error(`Error fetching fees from ${uri}`)
+
+    const fees = await response.json()
+    return processor(fees)
+  } catch (err) {
+    log(err.message)
+    return null
+  }
+}
+
+
+
+
+
+const fetchFeesFromVendor = async (
+  args
+) => {
+  if (args.mempoolSpaceFeeInfoServer != null) {
+    const mempoolFees = await fetchFees({
+      ...args,
+      uri: args.mempoolSpaceFeeInfoServer,
+      processor: _processMempoolSpaceFees.processMempoolSpaceFees
+    })
+    if (mempoolFees != null) {
+      return mempoolFees
+    }
+  }
+
+  return {}
+}

package/lib/common/fees/processInfoServerFees.js

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _cleaners = require('cleaners');
+
+
+
+const asInfoServerFees = _cleaners.asObject({
+  lowFee: _cleaners.asString,
+  standardFeeLow: _cleaners.asString,
+  standardFeeHigh: _cleaners.asString,
+  highFee: _cleaners.asString,
+
+  // The amount of satoshis which will be charged the standardFeeLow
+  standardFeeLowAmount: _cleaners.asString,
+  // The amount of satoshis which will be charged the standardFeeHigh
+  standardFeeHighAmount: _cleaners.asString
+})
+
+/**
+ * Processes the fee object from Edge Info Server
+ * @param fees
+ * @returns {SimpleFeeSettings}
+ */
+ const processInfoServerFees = (
+  fees
+) => {
+  try {
+    return asInfoServerFees(fees)
+  } catch (e) {
+    return null
+  }
+}; exports.processInfoServerFees = processInfoServerFees

package/lib/common/fees/processMempoolSpaceFees.js

@@ -0,0 +1,38 @@
+"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; } }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
+var _cleaners = require('cleaners');
+
+var _constants = require('../constants');
+
+
+ const asMempoolSpaceFees = _cleaners.asObject.call(void 0, {
+  fastestFee: _cleaners.asNumber,
+  halfHourFee: _cleaners.asNumber,
+  hourFee: _cleaners.asNumber
+}); exports.asMempoolSpaceFees = asMempoolSpaceFees
+
+/**
+ * Calculates the FeeRates object from MempoolSpace
+ * Sets the minimum of LOW_FEE on all fee levels
+ * @param fees
+ * @returns Partial<FeeRates>
+ */
+ const processMempoolSpaceFees = (fees) => {
+  let mempoolFees
+  try {
+    mempoolFees = exports.asMempoolSpaceFees.call(void 0, fees)
+  } catch (e) {
+    return null
+  }
+
+  const standardFeeLow = mempoolFees.hourFee.toString()
+  const lowFee = bs.div(standardFeeLow, '2')
+  const standardFeeHigh = mempoolFees.halfHourFee.toString()
+  const highFee = mempoolFees.fastestFee.toString()
+
+  return {
+    lowFee: bs.max(lowFee, _constants.LOW_FEE.toString()),
+    standardFeeLow: bs.max(standardFeeLow, _constants.LOW_FEE.toString()),
+    standardFeeHigh: bs.max(standardFeeHigh, _constants.LOW_FEE.toString()),
+    highFee: bs.max(highFee, _constants.LOW_FEE.toString())
+  }
+}; exports.processMempoolSpaceFees = processMempoolSpaceFees

package/lib/common/plugin/makeCurrencyPlugin.js

@@ -0,0 +1,66 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+var _makeUtxoEngine = require('../utxobased/engine/makeUtxoEngine');
+var _types3 = require('../utxobased/engine/types');
+var _makeCurrencyTools = require('./makeCurrencyTools');
+var _makeEngineEmitter = require('./makeEngineEmitter');
+var _pluginState = require('./pluginState');
+
+
+ function makeCurrencyPlugin(
+  pluginOptions,
+  pluginInfo
+) {
+  const { currencyInfo } = pluginInfo
+  const { io, log, pluginDisklet } = pluginOptions
+  const currencyTools = _makeCurrencyTools.makeCurrencyTools.call(void 0, io, pluginInfo)
+  const { defaultSettings, pluginId, currencyCode } = currencyInfo
+  const state = _pluginState.makePluginState.call(void 0, {
+    io,
+    currencyCode,
+    pluginId,
+    pluginDisklet,
+    log,
+    defaultSettings: _types3.asUtxoUserSettings.call(void 0, defaultSettings)
+  })
+  return {
+    currencyInfo,
+
+    async makeCurrencyEngine(
+      walletInfo,
+      engineOptions
+    ) {
+      const emitter = _makeEngineEmitter.makeEngineEmitter.call(void 0, engineOptions.callbacks)
+      const engineConfig = {
+        walletInfo,
+        pluginInfo,
+        pluginDisklet,
+        currencyTools,
+        io,
+        options: {
+          ...pluginOptions,
+          ...engineOptions,
+          emitter
+        },
+        pluginState: state
+      }
+      const engine = await _makeUtxoEngine.makeUtxoEngine.call(void 0, engineConfig)
+
+      return engine
+    },
+
+    async makeCurrencyTools() {
+      state.load().catch(e => {
+        throw e
+      })
+      return currencyTools
+    }
+  }
+} exports.makeCurrencyPlugin = makeCurrencyPlugin;

package/lib/common/plugin/makeCurrencyTools.js

@@ -0,0 +1,211 @@
+"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; }var _biggystring = require('biggystring'); var bn = _interopRequireWildcard(_biggystring);
+var _bip39 = require('bip39'); var bip39 = _interopRequireWildcard(_bip39);
+var _cleaners = require('cleaners');
+
+
+
+
+
+
+
+
+var _urijs = require('uri-js'); var uri = _interopRequireWildcard(_urijs);
+var _urlparse = require('url-parse'); var _urlparse2 = _interopRequireDefault(_urlparse);
+
+var _utils = require('../utxobased/engine/utils');
+
+
+
+
+var _cleaners3 = require('../utxobased/keymanager/cleaners');
+
+var _utils3 = require('./utils');
+
+/**
+ * The core currency plugin.
+ * Provides information about the currency,
+ * as well as generic (non-wallet) functionality.
+ */
+ function makeCurrencyTools(
+  io,
+  pluginInfo
+) {
+  const { currencyInfo, engineInfo, coinInfo } = pluginInfo
+
+  const asCurrencyPrivateKey = _cleaners3.asPrivateKey.call(void 0, coinInfo.name, coinInfo.coinType)
+  const wasCurrencyPrivateKey = _cleaners.uncleaner.call(void 0, asCurrencyPrivateKey)
+  const asCurrencyNumbWalletInfo = _cleaners3.asNumbWalletInfo.call(void 0, pluginInfo)
+
+  const fns = {
+    async createPrivateKey(
+      _walletType,
+      opts
+    ) {
+      const mnemonic = bip39.entropyToMnemonic(Buffer.from(io.random(32)))
+
+      const privateKey = {
+        imported: false,
+        seed: mnemonic,
+        format: _nullishCoalesce(_nullishCoalesce(_optionalChain([opts, 'optionalAccess', _ => _.format]), () => ( _optionalChain([engineInfo, 'access', _2 => _2.formats, 'optionalAccess', _3 => _3[0]]))), () => ( 'bip44')),
+        coinType: _nullishCoalesce(_nullishCoalesce(_optionalChain([opts, 'optionalAccess', _4 => _4.coinType]), () => ( coinInfo.coinType)), () => ( 0))
+      }
+
+      return wasCurrencyPrivateKey(privateKey)
+    },
+
+    async importPrivateKey(
+      entropy,
+      opts
+    ) {
+      const isMnemonic = bip39.validateMnemonic(entropy)
+
+      // Handle error case(s) if not a valid form of entropy
+      if (!isMnemonic) {
+        // An Airbitz seed is a 256 bit base64 encoded string. Convert the string
+        // to a buffer and then count the bytes (32 bytes is 256 bits).
+        const isAirbitzSeed = Buffer.from(entropy, 'base64').length === 32
+        if (isAirbitzSeed) {
+          throw new Error('Import for Airbitz seeds is unsupported.')
+        }
+        throw new Error('Invalid mnemonic')
+      }
+
+      const privateKey = {
+        imported: true,
+        seed: entropy,
+        format: _nullishCoalesce(_nullishCoalesce(_optionalChain([opts, 'optionalAccess', _5 => _5.format]), () => ( _optionalChain([engineInfo, 'access', _6 => _6.formats, 'optionalAccess', _7 => _7[0]]))), () => ( 'bip44')),
+        coinType: _nullishCoalesce(_nullishCoalesce(_optionalChain([opts, 'optionalAccess', _8 => _8.coinType]), () => ( coinInfo.coinType)), () => ( 0))
+      }
+
+      return wasCurrencyPrivateKey(privateKey)
+    },
+
+    async derivePublicKey(walletInfo) {
+      const numbWalletInfo = asCurrencyNumbWalletInfo(walletInfo)
+      return numbWalletInfo.keys.publicKey
+    },
+
+    async parseUri(uri) {
+      const isGateway = uri
+        .toLocaleLowerCase()
+        .startsWith(`${coinInfo.name}://`)
+      if (isGateway) uri = uri.replace('//', '')
+
+      const uriObj = _urlparse2.default.call(void 0, uri, {}, true)
+      const protocol = uriObj.protocol.replace(':', '').toLowerCase()
+
+      // If the currency URI belongs to the wrong network then error
+      if (
+        protocol !== '' &&
+        protocol !== currencyInfo.pluginId &&
+        protocol !== engineInfo.uriPrefix &&
+        protocol !== 'pay'
+      ) {
+        throw new Error('InvalidUriError')
+      }
+
+      // Get all possible query params
+      const { pathname, query } = uriObj
+      // If we don't have a pathname or a paymentProtocolURL uri then we bail
+      if (pathname === '' && query.r == null) throw new Error('InvalidUriError')
+
+      // Create the returned object
+      const parsedUri = {}
+      // Parse the pathname and add it to the result object
+      if (pathname !== '') {
+        const parsedPath = _utils.parsePathname.call(void 0, {
+          pathname: uriObj.pathname,
+          coin: coinInfo.name
+        })
+        if (parsedPath == null) throw new Error('InvalidUriError')
+
+        Object.assign(parsedUri, parsedPath)
+      }
+
+      // Assign the query params to the parsedUri object
+      const metadata = {}
+      if (query.label != null) metadata.name = query.label
+      if (query.message != null) metadata.notes = query.message
+      if (query.category != null) metadata.category = query.category
+      if (query.r != null) parsedUri.paymentProtocolUrl = query.r
+      if (isGateway) metadata.gateway = true
+      Object.assign(parsedUri, { metadata })
+
+      // Get amount in native denomination if exists
+      const denomination = currencyInfo.denominations.find(
+        ({ name }) => name === currencyInfo.currencyCode
+      )
+      if (denomination != null && query.amount != null) {
+        const { multiplier = '1' } = denomination
+        const t = bn.mul(query.amount, multiplier.toString())
+        parsedUri.currencyCode = currencyInfo.currencyCode
+        parsedUri.nativeAmount = bn.toFixed(t, 0, 0)
+      }
+      return parsedUri
+    },
+
+    async encodeUri(
+      obj,
+      _customTokens
+    ) {
+      const { publicAddress } = obj
+      if (publicAddress === '') {
+        throw new Error('InvalidPublicAddressError')
+      }
+
+      // TODO: validate network address
+
+      const query = []
+
+      if (obj.nativeAmount != null) {
+        const currencyCode = _nullishCoalesce(obj.currencyCode, () => ( currencyInfo.currencyCode))
+        const denomination = currencyInfo.denominations.find(
+          ({ name }) => name === currencyCode
+        )
+        if (denomination == null) {
+          throw new Error('InvalidDenominationError')
+        }
+
+        const amount = bn.div(obj.nativeAmount, denomination.multiplier, 8)
+        query.push(`amount=${amount}`)
+      }
+
+      if (obj.label != null) {
+        query.push(`label=${obj.label}`)
+      }
+
+      if (obj.message != null) {
+        query.push(`message=${obj.message}`)
+      }
+
+      const metadata = obj.metadata
+      if (metadata != null) {
+        if (metadata.name != null) {
+          query.push(`label=${metadata.name}`)
+        }
+        if (metadata.notes != null) {
+          query.push(`message=${metadata.notes}`)
+        }
+      }
+
+      return query.length > 0
+        ? uri.serialize({
+            scheme: _nullishCoalesce(engineInfo.uriPrefix, () => ( currencyInfo.pluginId)),
+            path: publicAddress,
+            query: query.join('&')
+          })
+        : publicAddress
+    },
+
+    getSplittableTypes(walletInfo) {
+      const { keys: { format = 'bip32' } = {} } = walletInfo
+      const forks = _nullishCoalesce(engineInfo.forks, () => ( []))
+
+      return forks
+        .filter(network => _utils3.getFormatsForNetwork.call(void 0, network).includes(format))
+        .map(network => `wallet:${network}`)
+    }
+  }
+
+  return fns
+} exports.makeCurrencyTools = makeCurrencyTools;