edge-currency-plugins 1.0.0-rc.1

package/lib/common/utxobased/engine/makeUtxoEngine.js

@@ -0,0 +1,690 @@
+"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(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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; } async function _asyncOptionalChain(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 = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
+var _cleaners = require('cleaners');
+var _disklet = require('disklet');
+
+
+
+
+
+
+
+
+
+
+
+
+var _types = require('edge-core-js/types');
+
+var _filterUndefined = require('../../../util/filterUndefined');
+var _unixTime = require('../../../util/unixTime');
+var _makeFees = require('../../fees/makeFees');
+var _makeEngineEmitter = require('../../plugin/makeEngineEmitter');
+var _makeMetadata = require('../../plugin/makeMetadata');
+
+var _makeProcessor = require('../db/makeProcessor');
+
+
+
+var _ProcessorTransaction = require('../db/Models/ProcessorTransaction');
+
+
+
+
+
+var _cleaners3 = require('../keymanager/cleaners');
+var _keymanager = require('../keymanager/keymanager');
+var _makeUtxoEngineState = require('./makeUtxoEngineState');
+var _makeUtxoWalletTools = require('./makeUtxoWalletTools');
+var _paymentRequest = require('./paymentRequest');
+var _types7 = require('./types');
+var _getOwnUtxosFromTx = require('./util/getOwnUtxosFromTx');
+var _utils = require('./utils');
+
+ async function makeUtxoEngine(
+  config
+) {
+  const {
+    pluginInfo,
+    pluginDisklet,
+    // Rename to make it explicit that this is sensitive memory
+    walletInfo: sensitiveWalletInfo,
+    options,
+    io,
+    pluginState
+  } = config
+  const {
+    walletLocalDisklet,
+    walletLocalEncryptedDisklet,
+    emitter,
+    log
+  } = options
+  const { currencyInfo, engineInfo, coinInfo } = pluginInfo
+  const userSettings = _types7.asUtxoUserSettings.call(void 0, options.userSettings)
+
+  // We should move the active server list to the engine state,
+  // since multiple accounts can be logged in at once,
+  // each with a different list of custom servers.
+  // The Edge UI only allows for one active login, though,
+  // so this is OK for now:
+  await pluginState.updateServers(userSettings)
+
+  const asCurrencyPrivateKey = _cleaners3.asPrivateKey.call(void 0, coinInfo.name, coinInfo.coinType)
+  // Private key may be missing for watch-only wallets
+  const asMaybeCurrencyPrivateKey = _cleaners.asMaybe.call(void 0, asCurrencyPrivateKey)
+  // This walletInfo is desensitized (numb) and should be passed around over the original walletInfo
+  const walletInfo = _cleaners3.asNumbWalletInfo.call(void 0, pluginInfo)(sensitiveWalletInfo)
+  const { primaryFormat, publicKey, walletFormats } = walletInfo.keys
+
+  if (
+    engineInfo.formats == null ||
+    !engineInfo.formats.includes(primaryFormat)
+  ) {
+    const message = `Wallet format is not supported: ${primaryFormat}`
+    log.error(message)
+    throw new Error(message)
+  }
+
+  const walletTools = _makeUtxoWalletTools.makeUtxoWalletTools.call(void 0, {
+    publicKey,
+    coin: coinInfo.name
+  })
+
+  const fees = await _makeFees.makeFees.call(void 0, {
+    disklet: pluginDisklet,
+    pluginInfo,
+    io,
+    log: config.options.log
+  })
+
+  const metadata = await _makeMetadata.makeMetadata.call(void 0, {
+    disklet: walletLocalDisklet,
+    emitter,
+    log
+  })
+  const processor = await _makeProcessor.makeProcessor.call(void 0, {
+    disklet: walletLocalDisklet
+  })
+  const state = _makeUtxoEngineState.makeUtxoEngineState.call(void 0, {
+    ...config,
+    walletTools,
+    walletInfo,
+    processor,
+    pluginState
+  })
+
+  const fns = {
+    async startEngine() {
+      emitter.emit(
+        _makeEngineEmitter.EngineEvent.WALLET_BALANCE_CHANGED,
+        currencyInfo.currencyCode,
+        metadata.balance
+      )
+
+      pluginState.addEngine(state)
+      await fees.start()
+      await state.start()
+    },
+
+    async killEngine() {
+      await state.stop()
+      fees.stop()
+      pluginState.removeEngine(state)
+    },
+
+    getBalance(_opts) {
+      return metadata.balance
+    },
+
+    getBlockHeight() {
+      return metadata.lastSeenBlockHeight
+    },
+
+    async addCustomToken(_token) {
+      return await Promise.resolve(undefined)
+    },
+
+    async addGapLimitAddresses(addresses) {
+      return await state.addGapLimitAddresses(addresses)
+    },
+
+    async broadcastTx(transaction) {
+      const { otherParams } = transaction
+      if (
+        _optionalChain([otherParams, 'optionalAccess', _ => _.paymentProtocolInfo, 'optionalAccess', _2 => _2.payment]) != null &&
+        _optionalChain([otherParams, 'optionalAccess', _3 => _3.paymentProtocolInfo, 'optionalAccess', _4 => _4.paymentUrl]) != null
+      ) {
+        const paymentAck = await _paymentRequest.sendPayment.call(void 0, 
+          io.fetch,
+          otherParams.paymentProtocolInfo.paymentUrl,
+          otherParams.paymentProtocolInfo.payment
+        )
+        if (typeof paymentAck === 'undefined') {
+          throw new Error(
+            `Error when sending to ${otherParams.paymentProtocolInfo.paymentUrl}`
+          )
+        }
+      }
+      const id = await state.broadcastTx(transaction)
+      if (id !== transaction.txid) {
+        throw new Error('broadcast response txid does not match original')
+      }
+      return transaction
+    },
+
+    async changeUserSettings(userSettings) {
+      await pluginState.updateServers(_types7.asUtxoUserSettings.call(void 0, userSettings))
+    },
+
+    async disableTokens(_tokens) {
+      return await Promise.resolve(undefined)
+    },
+
+    async dumpData() {
+      return {
+        walletId: walletInfo.id.split(' - ')[0],
+        walletType: walletInfo.type,
+        data: {
+          walletInfo: {
+            pluginType: currencyInfo.pluginId,
+            primaryFormat,
+            walletFormats
+          },
+          processorState: await processor.dumpData(),
+          pluginState: pluginState.dumpData()
+        }
+      }
+    },
+
+    async enableTokens(_tokens) {
+      return await Promise.resolve(undefined)
+    },
+
+    getDisplayPrivateSeed() {
+      const privateKey = asMaybeCurrencyPrivateKey(sensitiveWalletInfo.keys)
+      if (privateKey == null) return null
+      return privateKey.format === 'bip32'
+        ? Buffer.from(privateKey.seed, 'base64').toString('hex')
+        : privateKey.seed
+    },
+
+    getDisplayPublicSeed() {
+      const xpubs = publicKey.publicKeys
+      return Object.values(xpubs)
+        .filter(xpub => xpub != null)
+        .join('\n')
+    },
+
+    async getEnabledTokens() {
+      return await Promise.resolve([])
+    },
+
+    async getFreshAddress(
+      _opts
+    ) {
+      return await state.getFreshAddress()
+    },
+
+    getNumTransactions(_opts) {
+      return processor.numTransactions()
+    },
+
+    async getPaymentProtocolInfo(
+      paymentProtocolUrl
+    ) {
+      return await _paymentRequest.getPaymentDetails.call(void 0, 
+        paymentProtocolUrl,
+        currencyInfo.currencyCode,
+        io.fetch
+      )
+    },
+
+    getTokenStatus(_token) {
+      return false
+    },
+
+    async getTransactions(
+      options
+    ) {
+      const txs = _filterUndefined.filterUndefined.call(void 0, 
+        await processor.fetchTransactions({ options })
+      )
+      return await Promise.all(
+        txs.map(
+          async (tx) =>
+            await _ProcessorTransaction.toEdgeTransaction.call(void 0, {
+              tx,
+              currencyCode: currencyInfo.currencyCode,
+              pluginInfo,
+              processor,
+              walletBlockHeight: metadata.lastSeenBlockHeight,
+              walletTools
+            })
+        )
+      )
+    },
+
+    async isAddressUsed(address) {
+      const scriptPubkey = walletTools.addressToScriptPubkey(address)
+      const addressData = await processor.fetchAddress(scriptPubkey)
+      if (addressData == null) throw new Error('Address not found in wallet')
+      return addressData.used
+    },
+
+    async makeSpend(
+      edgeSpendInfo,
+      options
+    ) {
+      const { spendTargets } = edgeSpendInfo
+      if (_optionalChain([options, 'optionalAccess', _5 => _5.CPFP]) == null && spendTargets.length < 1) {
+        throw new Error('Need to provide Spend Targets')
+      }
+      // Calculate the total amount to send
+      const totalAmountToSend = spendTargets.reduce(
+        (sum, { nativeAmount }) => bs.add(sum, _nullishCoalesce(nativeAmount, () => ( '0'))),
+        '0'
+      )
+      const utxos =
+        await _asyncNullishCoalesce(await _asyncOptionalChain([options, 'optionalAccess', async _6 => _6.utxos]), async () => (
+        ((await processor.fetchUtxos({ utxoIds: [] })) )))
+
+      if (bs.gt(totalAmountToSend, `${_utils.sumUtxos.call(void 0, utxos)}`)) {
+        throw new (0, _types.InsufficientFundsError)(currencyInfo.currencyCode)
+      }
+
+      let targets = []
+      const ourReceiveAddresses = []
+      for (const target of spendTargets) {
+        if (target.publicAddress == null || target.nativeAmount == null) {
+          throw new Error('Invalid spend target')
+        }
+
+        // if script exists construct address from script
+        if (_optionalChain([target, 'access', _7 => _7.otherParams, 'optionalAccess', _8 => _8.script]) != null) {
+          const { script } = target.otherParams
+          if (script.type === 'replayProtection') {
+            // construct a replay protection p2sh address
+            const { publicAddress } = await state.deriveScriptAddress(
+              script.type
+            )
+            targets.push({
+              address: publicAddress,
+              value: parseInt(target.nativeAmount)
+            })
+          }
+        } else {
+          const scriptPubkey = walletTools.addressToScriptPubkey(
+            target.publicAddress
+          )
+          if (processor.fetchAddress(scriptPubkey) != null) {
+            ourReceiveAddresses.push(target.publicAddress)
+          }
+          targets.push({
+            address: target.publicAddress,
+            value: parseInt(target.nativeAmount)
+          })
+        }
+      }
+
+      if (targets.length < 1) {
+        throw new Error('Need to provide Spend Targets')
+      }
+
+      const freshAddress = await state.getFreshAddress(1)
+      const freshChangeAddress =
+        _nullishCoalesce(freshAddress.segwitAddress, () => ( freshAddress.publicAddress))
+      const setRBF = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.setRBF]), () => ( false))
+      const rbfTxid = edgeSpendInfo.rbfTxid
+      let maxUtxo
+      let feeRate = parseInt(await fees.getRate(edgeSpendInfo))
+      if (rbfTxid != null) {
+        const [rbfTx] = await processor.fetchTransactions({ txId: rbfTxid })
+        if (rbfTx == null) throw new Error('transaction not found')
+        // double the fee used for the RBF transaction
+        feeRate *= 2
+        const rbfInputs = rbfTx.inputs
+        const maxInput = rbfInputs.reduce((a, b) =>
+          bs.gt(a.amount, b.amount) ? a : b
+        )
+        const maxId = `${maxInput.txId}_${maxInput.outputIndex}`
+        maxUtxo = (await processor.fetchUtxos({ utxoIds: [maxId] }))[0]
+        if (maxUtxo == null) {
+          log.error('transaction to be replaced found, but not its input utxos')
+          throw new Error(
+            'transaction to be replaced found, but not its input utxos'
+          )
+        }
+      }
+      if (_optionalChain([options, 'optionalAccess', _10 => _10.CPFP]) != null) {
+        const [childTx] = await processor.fetchTransactions({
+          txId: _optionalChain([options, 'optionalAccess', _11 => _11.CPFP])
+        })
+        if (childTx == null) throw new Error('transaction not found')
+        const utxos = []
+        for (const txid of childTx.ourOuts) {
+          const [output] = await processor.fetchUtxos({ utxoIds: [txid] })
+          if (output != null) utxos.push(output)
+        }
+        maxUtxo = utxos.reduce((a, b) => (bs.gt(a.value, b.value) ? a : b))
+        // cpfp just sends to change, no target addresses are required
+        targets = []
+      }
+      log.warn(`spend: Using fee rate ${feeRate} sat/B`)
+      const subtractFee =
+        _optionalChain([options, 'optionalAccess', _12 => _12.subtractFee]) != null ? options.subtractFee : false
+      const tx = await _keymanager.makeTx.call(void 0, {
+        utxos,
+        forceUseUtxo: maxUtxo != null ? [maxUtxo] : [],
+        targets,
+        feeRate,
+        coin: coinInfo.name,
+        setRBF,
+        freshChangeAddress,
+        subtractFee
+      })
+      if (tx.changeUsed) {
+        ourReceiveAddresses.push(freshChangeAddress)
+      }
+
+      let nativeAmount = '0'
+      const ourScriptPubkeys = tx.inputs.map(input =>
+        input.scriptPubkey.toString('hex')
+      )
+      for (const output of tx.outputs) {
+        const scriptPubkey = output.scriptPubkey.toString('hex')
+        const own = await processor.fetchAddress(scriptPubkey)
+        if (own == null) {
+          // Not our output
+          nativeAmount = bs.sub(nativeAmount, output.value.toString())
+        } else {
+          // Our output
+          ourScriptPubkeys.push(scriptPubkey)
+        }
+      }
+
+      const networkFee = tx.fee.toString()
+      nativeAmount = bs.sub(nativeAmount, networkFee)
+
+      const otherParams = {
+        txJson: { hex: tx.hex },
+        psbt: {
+          base64: tx.psbtBase64,
+          inputs: tx.inputs,
+          outputs: tx.outputs
+        },
+        edgeSpendInfo,
+        ourScriptPubkeys
+      }
+
+      const transaction = {
+        ourReceiveAddresses,
+        otherParams,
+        currencyCode: currencyInfo.currencyCode,
+        txid: '',
+        date: _unixTime.unixTime.call(void 0, ),
+        confirmations: 'unconfirmed',
+        blockHeight: 0,
+        nativeAmount,
+        networkFee,
+        feeRateUsed: {
+          satPerVByte: feeRate
+        },
+        signedTx: ''
+      }
+
+      return transaction
+    },
+
+    async resyncBlockchain() {
+      // Stops the engine
+      await fns.killEngine()
+
+      // Clear cache and state
+      await processor.clearAll()
+      await pluginState.clearCache()
+      await metadata.clear()
+      await fees.clearCache()
+
+      // Refresh the servers for the engine
+      await pluginState.refreshServers()
+
+      // Restart the engine
+      await fns.startEngine()
+    },
+
+    async saveTx(edgeTx) {
+      const tx = _ProcessorTransaction.fromEdgeTransaction.call(void 0, edgeTx)
+      await _makeUtxoEngineState.transactionChanged.call(void 0, {
+        emitter,
+        pluginInfo,
+        processor,
+        tx,
+        walletBlockHeight: metadata.lastSeenBlockHeight,
+        walletTools
+      })
+      await processor.saveTransaction({
+        tx,
+        scriptPubkeys: _optionalChain([edgeTx, 'access', _13 => _13.otherParams, 'optionalAccess', _14 => _14.ourScriptPubkeys])
+      })
+
+      /*
+      Get the wallet's UTXOs from the new transaction and save them to the processsor.
+      */
+      const utxos = await _getOwnUtxosFromTx.getOwnUtxosFromTx.call(void 0, engineInfo, processor, tx)
+      await Promise.all(utxos.map(async utxo => await processor.saveUtxo(utxo)))
+    },
+
+    async signTx(transaction) {
+      const otherParams = transaction.otherParams 
+      if (otherParams == null) throw new Error('Invalid transaction data')
+
+      const { psbt, edgeSpendInfo } = otherParams
+      if (psbt == null || edgeSpendInfo == null)
+        throw new Error('Invalid transaction data')
+
+      const privateKey = asMaybeCurrencyPrivateKey(sensitiveWalletInfo.keys)
+
+      if (privateKey == null)
+        throw new Error('Cannot sign a transaction for a read-only wallet')
+
+      // Derive the xprivs on the fly, since we do not persist them
+      const xprivKeys = await _utils.fetchOrDeriveXprivFromKeys.call(void 0, {
+        privateKey,
+        walletLocalEncryptedDisklet,
+        coin: coinInfo.name
+      })
+
+      // Use the privateKeys (WIFs) from spendInfo, otherwise get them from the
+      // PBST inputs.
+      const privateKeys = await (async () => {
+        if (edgeSpendInfo.privateKeys != null) {
+          return edgeSpendInfo.privateKeys.map(wif =>
+            walletTools.getPrivateKeyFromWif(wif)
+          )
+        } else {
+          return await Promise.all(
+            psbt.inputs.map(async ({ hash, index }) => {
+              const txid = Buffer.from(hash).reverse().toString('hex')
+
+              const [utxo] = await processor.fetchUtxos({
+                utxoIds: [`${txid}_${index}`]
+              })
+              if (utxo == null) throw new Error('Invalid UTXO')
+
+              const address = await processor.fetchAddress(utxo.scriptPubkey)
+              if (_optionalChain([address, 'optionalAccess', _15 => _15.path]) == null)
+                throw new Error('Invalid script pubkey')
+
+              return walletTools.getPrivateKey({
+                path: address.path,
+                xprivKeys
+              })
+            })
+          )
+        }
+      })()
+      const signedTx = await _keymanager.signTx.call(void 0, {
+        psbtBase64: psbt.base64,
+        coin: coinInfo.name,
+        privateKeys
+      })
+      transaction.txid = signedTx.id
+      transaction.signedTx = signedTx.hex
+
+      const { paymentProtocolInfo } =
+        _nullishCoalesce(_optionalChain([transaction, 'access', _16 => _16.otherParams, 'optionalAccess', _17 => _17.edgeSpendInfo, 'optionalAccess', _18 => _18.otherParams]), () => ( {}))
+      if (paymentProtocolInfo != null) {
+        const payment = _paymentRequest.createPayment.call(void 0, 
+          transaction.signedTx,
+          transaction.currencyCode
+        )
+        Object.assign(transaction.otherParams, {
+          paymentProtocolInfo: {
+            ...paymentProtocolInfo,
+            payment
+          }
+        })
+      }
+
+      // Update the transaction's date because it's has been modified
+      transaction.date = _unixTime.unixTime.call(void 0, )
+
+      return transaction
+    },
+
+    async sweepPrivateKeys(spendInfo) {
+      // Create the promise to return
+      let success
+
+
+      let failure
+      const end = new Promise((resolve, reject) => {
+        success = resolve
+        failure = reject
+      })
+
+      // The temporary wallet info should include all formats for the currency
+      const allFormats = engineInfo.formats
+      if (allFormats == null) {
+        throw new Error(
+          `Missing  formats for wallet type ${currencyInfo.walletType}`
+        )
+      }
+
+      const tmpWalletInfo = {
+        id: walletInfo.id,
+        type: walletInfo.type,
+        keys: {
+          primaryFormat: walletInfo.keys.primaryFormat,
+          walletFormats: allFormats,
+          publicKey: {
+            publicKeys: {}
+          }
+        }
+      }
+
+      const privateKeys = _nullishCoalesce(spendInfo.privateKeys, () => ( []))
+      if (privateKeys.length < 1) throw new Error('No private keys given')
+
+      // Make temporary wallet disklet
+      const tmpDisklet = _disklet.makeMemoryDisklet.call(void 0, )
+      const tmpEncryptedDisklet = _disklet.makeMemoryDisklet.call(void 0, )
+      const tmpEmitter = new (0, _makeEngineEmitter.EngineEmitter)()
+      const tmpConfig = {
+        disklet: tmpDisklet,
+        emitter: tmpEmitter,
+        log
+      }
+      const tmpMetadata = await _makeMetadata.makeMetadata.call(void 0, tmpConfig)
+      const tmpProcessor = await _makeProcessor.makeProcessor.call(void 0, tmpConfig)
+      const tmpWalletTools = _makeUtxoWalletTools.makeUtxoWalletTools.call(void 0, {
+        publicKey: tmpWalletInfo.keys.publicKey,
+        coin: coinInfo.name
+      })
+
+      // Max spend after imported wallet finishes sync
+      tmpEmitter.on(_makeEngineEmitter.EngineEvent.ADDRESSES_CHECKED, async (ratio) => {
+        if (ratio === 1) {
+          try {
+            await tmpState.stop()
+
+            const tmpUtxos = (await tmpProcessor.fetchUtxos({
+              utxoIds: []
+            })) 
+            if (tmpUtxos === null || tmpUtxos.length < 1) {
+              throw new Error('Private key has no funds')
+            }
+            const destAddress = await this.getFreshAddress({})
+            const nativeAmount = tmpMetadata.balance
+            const options = { utxos: tmpUtxos, subtractFee: true }
+            spendInfo.spendTargets = [
+              { publicAddress: destAddress.publicAddress, nativeAmount }
+            ]
+            // @ts-expect-error TODO: TheCharlatan - add option to makeSpend declaration in edge-core-js
+            const tx = await this.makeSpend(spendInfo, options)
+            success(tx)
+          } catch (e) {
+            failure(e)
+          }
+        }
+      })
+
+      const tmpState = _makeUtxoEngineState.makeUtxoEngineState.call(void 0, {
+        ...config,
+        options: {
+          ...config.options,
+          walletLocalDisklet: tmpDisklet,
+          walletLocalEncryptedDisklet: tmpEncryptedDisklet,
+          emitter: tmpEmitter
+        },
+        pluginInfo: {
+          ...pluginInfo,
+          engineInfo: {
+            ...engineInfo,
+            // Disables setLookAhead because we're gonna load from WIFs
+            gapLimit: 0
+          }
+        },
+        processor: tmpProcessor,
+        walletTools: tmpWalletTools,
+        walletInfo: tmpWalletInfo
+      })
+      await tmpState.loadWifs(privateKeys)
+      await tmpState.start()
+
+      return await end
+    },
+
+    otherMethods: {
+      signMessageBase64: async (
+        message,
+        address
+      ) => {
+        const scriptPubkey = walletTools.addressToScriptPubkey(address)
+        const processorAddress = await processor.fetchAddress(scriptPubkey)
+        if (_optionalChain([processorAddress, 'optionalAccess', _19 => _19.path]) == null) {
+          throw new Error('Missing address to sign with')
+        }
+        const privateKey = asMaybeCurrencyPrivateKey(sensitiveWalletInfo.keys)
+
+        if (privateKey == null)
+          throw new Error('Cannot sign a message for a read-only wallet')
+
+        // Derive the xprivs on the fly, since we do not persist them
+        const xprivKeys = await _utils.fetchOrDeriveXprivFromKeys.call(void 0, {
+          privateKey,
+          walletLocalEncryptedDisklet,
+          coin: coinInfo.name
+        })
+
+        const signature = await walletTools.signMessageBase64({
+          path: _optionalChain([processorAddress, 'optionalAccess', _20 => _20.path]),
+          message,
+          xprivKeys
+        })
+        return signature
+      }
+    }
+  }
+
+  return fns
+} exports.makeUtxoEngine = makeUtxoEngine;