edge-currency-plugins 2.4.1 → 2.5.0

package/lib/common/plugin/types.js

@@ -8,9 +8,10 @@
 
 
 
-var _cleaners = require('cleaners');
 
 
+var _cleaners = require('cleaners');
+
 
 
 
@@ -21,6 +22,7 @@ var _cleaners = require('cleaners');
 
 
 
+var _types3 = require('../utxobased/db/types');
 
 
 
@@ -46,7 +48,11 @@ var _cleaners = require('cleaners');
 
 
 
-
+ const asTxOptions = _cleaners.asObject({
+  utxos: _cleaners.asOptional.call(void 0, _cleaners.asArray.call(void 0, _types3.asIUTXO)),
+  subtractFee: _cleaners.asOptional.call(void 0, _cleaners.asBoolean),
+  CPFP: _cleaners.asOptional.call(void 0, _cleaners.asString)
+}); exports.asTxOptions = asTxOptions
 
 
 

package/lib/common/utxobased/db/Models/ProcessorTransaction.js

@@ -78,8 +78,7 @@ var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
     }
   }
 
-  const feeRes = {}
-
+  let feeRateUsed
   try {
     const altcoinTx = _altcoinjs.Transaction.fromHex(tx.hex)
     const vBytes = altcoinTx.virtualSize()
@@ -87,12 +86,10 @@ var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
     const feeRate = new (0, _bnjs2.default)(tx.fees, 10)
       .div(new (0, _bnjs2.default)(vBytes, 10))
       .toNumber()
-    Object.assign(feeRes, {
-      feeRateUsed: {
-        // GUI repo uses satPerVByte rather than satPerByte defined in customFeeTemplate
-        satPerVByte: feeRate
-      }
-    })
+    feeRateUsed = {
+      // GUI repo uses satPerVByte rather than satPerByte defined in customFeeTemplate
+      satPerVByte: feeRate
+    }
   } catch (e) {}
 
   return {
@@ -108,6 +105,6 @@ var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
     signedTx: tx.hex,
     txid: tx.txid,
     walletId,
-    ...feeRes
+    feeRateUsed
   }
 }; exports.toEdgeTransaction = toEdgeTransaction

package/lib/common/utxobased/db/types.js

@@ -1,7 +1,9 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _cleaners = require('cleaners');
 
 
 
+var _keymanager = require('../keymanager/keymanager');
+
 
 
 
@@ -40,6 +42,18 @@
 
 
 
+ const asIUTXO = _cleaners.asObject({
+  id: _cleaners.asString,
+  txid: _cleaners.asString,
+  vout: _cleaners.asNumber,
+  value: _cleaners.asString,
+  scriptPubkey: _cleaners.asString,
+  script: _cleaners.asString,
+  redeemScript: _cleaners.asOptional.call(void 0, _cleaners.asString),
+  scriptType: _keymanager.asScriptTypeEnum,
+  blockHeight: _cleaners.asNumber,
+  spent: _cleaners.asBoolean
+}); exports.asIUTXO = asIUTXO
 
 
 

package/lib/common/utxobased/db/util/utxo.js

@@ -0,0 +1,70 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _utils = require('../../engine/utils');
+
+
+
+var _keymanager = require('../../keymanager/keymanager');
+
+
+
+ const utxoFromProcessorTransactionInput = async (
+  processor,
+  processorTransaction,
+  inputIndex
+) => {
+  const input = processorTransaction.inputs[inputIndex]
+  const { scriptPubkey } = input
+  const address = await processor.fetchAddress(scriptPubkey)
+
+  if (address == null)
+    throw new Error(`Cannot find address for ${scriptPubkey}`)
+  if (address.path == null)
+    throw new Error(`Address has no derivation path information`)
+
+  // Optional redeemScript for "our addresses"
+  const redeemScript = address.redeemScript
+
+  const purposeType = _utils.currencyFormatToPurposeType.call(void 0, address.path.format)
+  const getScripts = async (
+    scriptPubkey
+  
+
+
+) => {
+    switch (purposeType) {
+      case _keymanager.BIP43PurposeTypeEnum.Airbitz:
+      case _keymanager.BIP43PurposeTypeEnum.Legacy: {
+        return {
+          script: processorTransaction.hex,
+          scriptType:
+            redeemScript != null ? _keymanager.ScriptTypeEnum.p2sh : _keymanager.ScriptTypeEnum.p2pkh
+        }
+      }
+      case _keymanager.BIP43PurposeTypeEnum.WrappedSegwit:
+        return {
+          script: scriptPubkey,
+          scriptType: _keymanager.ScriptTypeEnum.p2wpkhp2sh
+        }
+      case _keymanager.BIP43PurposeTypeEnum.Segwit:
+        return {
+          script: scriptPubkey,
+          scriptType: _keymanager.ScriptTypeEnum.p2wpkh
+        }
+      default:
+        throw new Error(`Unknown purpose type ${purposeType}`)
+    }
+  }
+  const { script, scriptType } = await getScripts(scriptPubkey)
+
+  return {
+    id: `${input.txId}_${input.outputIndex}`,
+    txid: input.txId,
+    vout: input.outputIndex,
+    value: input.amount,
+    scriptPubkey,
+    script,
+    redeemScript,
+    scriptType,
+    blockHeight: processorTransaction.blockHeight,
+    spent: true
+  }
+}; exports.utxoFromProcessorTransactionInput = utxoFromProcessorTransactionInput

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

@@ -1,4 +1,4 @@
-"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);
+"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; }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
 var _cleaners = require('cleaners');
 var _disklet = require('disklet');
 
@@ -31,6 +31,7 @@ var _makeProcessor = require('../db/makeProcessor');
 
 var _ProcessorTransaction = require('../db/Models/ProcessorTransaction');
 
+var _utxo = require('../db/util/utxo');
 
 
 
@@ -41,7 +42,11 @@ var _cleaners3 = require('../keymanager/cleaners');
 
 
 
+
+
 var _keymanager = require('../keymanager/keymanager');
+var _types5 = require('../keymanager/types');
+var _utils = require('../keymanager/utxopicker/utils');
 var _makeUtxoEngineState = require('./makeUtxoEngineState');
 var _makeUtxoWalletTools = require('./makeUtxoWalletTools');
 var _paymentRequest = require('./paymentRequest');
@@ -49,9 +54,15 @@ var _paymentRequest = require('./paymentRequest');
 
 
 
-var _types5 = require('./types');
+
+var _types7 = require('./types');
 var _getOwnUtxosFromTx = require('./util/getOwnUtxosFromTx');
-var _utils = require('./utils');
+
+
+
+
+
+var _utils3 = require('./utils');
 
  async function makeUtxoEngine(
   config
@@ -71,7 +82,7 @@ var _utils = require('./utils');
     log
   } = options
   const { currencyInfo, engineInfo, coinInfo } = pluginInfo
-  const userSettings = _types5.asUtxoUserSettings.call(void 0, options.userSettings)
+  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,
@@ -129,6 +140,208 @@ var _utils = require('./utils');
   })
 
   const engine = {
+    async accelerate(edgeTx) {
+      // Get the replaced transaction from the processor:
+      const replacedTxid = edgeTx.txid
+      const [replacedTx] = await processor.fetchTransactions({
+        txId: replacedTxid
+      })
+
+      // Transaction checks:
+      // The transaction must be found and not confirmed or dropped.
+      if (replacedTx == null) return null
+      if (replacedTx.blockHeight !== 0) return null
+
+      // Double the fee used for the RBF transaction:
+      const vBytes = _utils.transactionSizeFromHex.call(void 0, replacedTx.hex)
+      const newFeeRate = Math.round((parseInt(replacedTx.fees) / vBytes) * 2)
+
+      const replacedTxInputs = replacedTx.inputs
+      // Recreate UTXOs from processor transaction and mark them as unspent:
+      const replacedTxUtxos = await Promise.all(
+        replacedTxInputs.map(async (_, index) => {
+          const utxo = await _utxo.utxoFromProcessorTransactionInput.call(void 0, 
+            processor,
+            replacedTx,
+            index
+          )
+          // Mark as unspent because we're going to reuse replaced tx's UTXOs
+          utxo.spent = false
+          return utxo
+        })
+      )
+      // Get the largest input from the transaction to re-use:
+      const replacedTxMaxUtxo = replacedTxUtxos.reduce((maxUtxo, utxo) => {
+        if (utxo.value > maxUtxo.value) return utxo
+        return maxUtxo
+      })
+
+      const targets = []
+      const newOurReceiveAddresses = []
+      let foundChangeAddress
+      for (const output of replacedTx.outputs) {
+        // Fetch address by output's scriptPubkey to determine output ownership
+        const ourAddress = await processor.fetchAddress(output.scriptPubkey)
+
+        // This isn't our output, so include it as a target
+        if (ourAddress == null) {
+          targets.push({
+            scriptPubkey: output.scriptPubkey,
+            value: parseInt(output.amount)
+          })
+          continue
+        }
+
+        // Addresses from database should include a path; this is a type assert
+        if (ourAddress.path == null)
+          throw new Error('Expecting path for address')
+
+        // The output is ours:
+        const purposeType = _utils3.pathToPurposeType.call(void 0, 
+          ourAddress.path,
+          engineInfo.scriptTemplates
+        )
+        const addressType = _utils3.getAddressTypeFromPurposeType.call(void 0, purposeType)
+        const { address } = _keymanager.scriptPubkeyToAddress.call(void 0, {
+          scriptPubkey: ourAddress.scriptPubkey,
+          addressType,
+          coin: coinInfo.name,
+          redeemScript: ourAddress.redeemScript
+        })
+
+        newOurReceiveAddresses.push(address)
+
+        // Detect if it's the change address:
+        if (ourAddress.path.changeIndex === 1) {
+          foundChangeAddress = address
+        } else {
+          // This isn't our change address, so include it as a target.
+          // The transaction must have been a spend-to-self.
+          targets.push({
+            scriptPubkey: output.scriptPubkey,
+            value: parseInt(output.amount)
+          })
+        }
+      }
+
+      // Use the found change address or generate a new one:
+      const freshAddress =
+        foundChangeAddress == null
+          ? await engineState.getFreshAddress({ branch: 1 })
+          : { publicAddress: foundChangeAddress }
+      const freshChangeAddress =
+        _nullishCoalesce(freshAddress.segwitAddress, () => ( freshAddress.publicAddress))
+
+      // Get all current UTXOs:
+      const currentUtxos = _filterUndefined.filterUndefined.call(void 0, 
+        await processor.fetchUtxos({
+          utxoIds: []
+        })
+      )
+        // Exclude all UTXOs which are from the replaced tx, because
+        // they wont be valid.
+        .filter(utxo => utxo.txid !== replacedTxid)
+
+      // Combine replaced transaction's inputs as UTXOs with the current UTXO set
+      const utxos = [...replacedTxUtxos, ...currentUtxos]
+
+      // New transaction to be the replacement transaction
+      const makeTxArgs = {
+        utxos,
+        forceUseUtxo: [replacedTxMaxUtxo],
+        targets,
+        memos: edgeTx.memos,
+        feeRate: newFeeRate,
+        coin: coinInfo.name,
+        currencyCode: currencyInfo.currencyCode,
+        enableRbf: true,
+        freshChangeAddress,
+        subtractFee: false,
+        log,
+        outputSort: 'bip69'
+      }
+      const newTx = (() => {
+        try {
+          return _keymanager.makeTx.call(void 0, makeTxArgs)
+        } catch (error) {
+          const cleanError = _types5.asMaybeInsufficientFundsErrorPlus.call(void 0, error)
+          if (_optionalChain([cleanError, 'optionalAccess', _2 => _2.networkFeeShortage]) != null) {
+            let feeDelta = parseInt(cleanError.networkFeeShortage)
+            // Adjust target values until we diminish the fee delta completely
+            for (const target of targets) {
+              if (target.value == null) continue
+              // The term is how much value to subtract from the target's value.
+              // The term's maximum value is the target's value.
+              // The term's minimum value is the fee delta.
+              const term = Math.min(target.value, feeDelta)
+              target.value -= term // Either decrement or zero out
+              feeDelta -= term // Ether decrement or zero out
+            }
+            // Retry making the transaction
+            return _keymanager.makeTx.call(void 0, makeTxArgs)
+          }
+          throw error
+        }
+      })()
+
+      if (newTx.changeUsed) {
+        newOurReceiveAddresses.push(freshChangeAddress)
+      }
+
+      // Generate new tracking of our scripts:
+      const newOurScriptPubkeys = newTx.inputs.map(input =>
+        input.scriptPubkey.toString('hex')
+      )
+
+      // Calculate transaction spend amount:
+      let nativeAmount = '0'
+      for (const output of newTx.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
+          newOurScriptPubkeys.push(scriptPubkey)
+        }
+      }
+
+      const networkFee = newTx.fee.toString()
+      nativeAmount = bs.sub(nativeAmount, networkFee)
+
+      const newTxOtherParams = {
+        unsignedTx: newTx.hex,
+        psbt: {
+          base64: newTx.psbtBase64,
+          inputs: newTx.inputs,
+          outputs: newTx.outputs
+        },
+        ourScriptPubkeys: newOurScriptPubkeys,
+        replacedTxid: replacedTxid
+      }
+
+      // Return a EdgeTransaction object with the updates
+      return {
+        ...edgeTx,
+        blockHeight: 0,
+        currencyCode: currencyInfo.currencyCode,
+        date: _unixTime.unixTime.call(void 0, ),
+        feeRateUsed: {
+          satPerVByte: newFeeRate
+        },
+        isSend: true,
+        nativeAmount,
+        networkFee,
+        otherParams: newTxOtherParams,
+        ourReceiveAddresses: newOurReceiveAddresses,
+        parentNetworkFee: undefined,
+        signedTx: '',
+        txid: '',
+        walletId: walletInfo.id
+      }
+    },
+
     async startEngine() {
       emitter.emit(
         _makeEngineEmitter.EngineEvent.WALLET_BALANCE_CHANGED,
@@ -166,8 +379,8 @@ var _utils = require('./utils');
     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
+        _optionalChain([otherParams, 'optionalAccess', _3 => _3.paymentProtocolInfo, 'optionalAccess', _4 => _4.payment]) != null &&
+        _optionalChain([otherParams, 'optionalAccess', _5 => _5.paymentProtocolInfo, 'optionalAccess', _6 => _6.paymentUrl]) != null
       ) {
         const paymentAck = await _paymentRequest.sendPayment.call(void 0, 
           io.fetch,
@@ -193,7 +406,7 @@ var _utils = require('./utils');
     },
 
     async changeUserSettings(userSettings) {
-      await pluginState.updateServers(_types5.asUtxoUserSettings.call(void 0, userSettings))
+      await pluginState.updateServers(_types7.asUtxoUserSettings.call(void 0, userSettings))
     },
 
     async disableTokens(_tokens) {
@@ -236,10 +449,6 @@ var _utils = require('./utils');
         .join('\n')
     },
 
-    async getEnabledTokens() {
-      return await Promise.resolve([])
-    },
-
     async getFreshAddress(
       opts
     ) {
@@ -261,10 +470,6 @@ var _utils = require('./utils');
       )
     },
 
-    getTokenStatus(_token) {
-      return false
-    },
-
     async getTransactions(
       options
     ) {
@@ -295,17 +500,22 @@ var _utils = require('./utils');
     async makeSpend(edgeSpendInfo) {
       edgeSpendInfo = _upgradeMemos.upgradeMemos.call(void 0, edgeSpendInfo, currencyInfo)
       const { memos = [], spendTargets } = edgeSpendInfo
-      const txOptions =
-        _optionalChain([edgeSpendInfo, 'access', _5 => _5.otherParams, 'optionalAccess', _6 => _6.txOptions])
-      const { outputSort = 'bip69', utxoSourceAddress, forceChangeAddress } =
+      const spendInfoOtherParams = _types7.asUtxoSpendInfoOtherParams.call(void 0, 
         _nullishCoalesce(edgeSpendInfo.otherParams, () => ( {}))
+      )
+      const txOptions = _nullishCoalesce(spendInfoOtherParams.txOptions, () => ( {}))
+      const {
+        outputSort,
+        utxoSourceAddress,
+        forceChangeAddress
+      } = spendInfoOtherParams
 
       let utxoScriptPubkey
       if (utxoSourceAddress != null) {
         utxoScriptPubkey = walletTools.addressToScriptPubkey(utxoSourceAddress)
       }
 
-      if (_optionalChain([txOptions, 'optionalAccess', _7 => _7.CPFP]) == null && spendTargets.length < 1) {
+      if (txOptions.CPFP == null && spendTargets.length < 1) {
         throw new Error('Need to provide Spend Targets')
       }
       // Calculate the total amount to send
@@ -314,7 +524,7 @@ var _utils = require('./utils');
         '0'
       )
       const utxos =
-        await _asyncNullishCoalesce(await _asyncOptionalChain([txOptions, 'optionalAccess', async _8 => _8.utxos]), async () => (
+        await _asyncNullishCoalesce(txOptions.utxos, async () => (
         _filterUndefined.filterUndefined.call(void 0, 
           (await processor.fetchUtxos({
             scriptPubkey: utxoScriptPubkey,
@@ -323,7 +533,7 @@ var _utils = require('./utils');
         )))
 
       if (
-        bs.gt(totalAmountToSend, `${_utils.sumUtxos.call(void 0, utxos)}`) ||
+        bs.gt(totalAmountToSend, `${_utils3.sumUtxos.call(void 0, utxos)}`) ||
         utxos.length === 0
       ) {
         throw new (0, _edgecorejs.InsufficientFundsError)(currencyInfo.currencyCode)
@@ -337,7 +547,7 @@ var _utils = require('./utils');
         }
 
         // if script exists construct address from script
-        if (_optionalChain([target, 'access', _9 => _9.otherParams, 'optionalAccess', _10 => _10.script]) != null) {
+        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
@@ -357,7 +567,7 @@ var _utils = require('./utils');
             const scriptPubkey = walletTools.addressToScriptPubkey(
               target.publicAddress
             )
-            if (processor.fetchAddress(scriptPubkey) != null) {
+            if ((await processor.fetchAddress(scriptPubkey)) != null) {
               ourReceiveAddresses.push(target.publicAddress)
             }
           }
@@ -381,31 +591,12 @@ var _utils = require('./utils');
         freshAddress.segwitAddress)), () => (
         freshAddress.publicAddress))
 
-      const setRBF = _nullishCoalesce(_optionalChain([txOptions, 'optionalAccess', _11 => _11.setRBF]), () => ( false))
-      const rbfTxid = edgeSpendInfo.rbfTxid
+      const feeRate = parseInt(await fees.getRate(edgeSpendInfo))
+
       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([txOptions, 'optionalAccess', _12 => _12.CPFP]) != null) {
+      if (txOptions.CPFP != null) {
         const [childTx] = await processor.fetchTransactions({
-          txId: _optionalChain([txOptions, 'optionalAccess', _13 => _13.CPFP])
+          txId: txOptions.CPFP
         })
         if (childTx == null) throw new Error('transaction not found')
         const utxos = []
@@ -417,9 +608,10 @@ var _utils = require('./utils');
         // cpfp just sends to change, no target addresses are required
         targets = []
       }
+
       log.warn(`spend: Using fee rate ${feeRate} sat/B`)
       const subtractFee =
-        _optionalChain([txOptions, 'optionalAccess', _14 => _14.subtractFee]) != null ? txOptions.subtractFee : false
+        txOptions.subtractFee != null ? txOptions.subtractFee : false
       const tx = _keymanager.makeTx.call(void 0, {
         utxos,
         forceUseUtxo: maxUtxo != null ? [maxUtxo] : [],
@@ -428,7 +620,10 @@ var _utils = require('./utils');
         feeRate,
         coin: coinInfo.name,
         currencyCode: currencyInfo.currencyCode,
-        setRBF,
+        enableRbf:
+          _nullishCoalesce(_nullishCoalesce(spendInfoOtherParams.enableRbf, () => (
+          currencyInfo.canReplaceByFee)), () => (
+          false)),
         freshChangeAddress,
         subtractFee,
         log,
@@ -507,6 +702,26 @@ var _utils = require('./utils');
     },
 
     async saveTx(edgeTx) {
+      // If the transaction being saved replaces a transaction, update it.
+      const replacedTxid = _optionalChain([edgeTx, 'access', _9 => _9.otherParams, 'optionalAccess', _10 => _10.replacedTxid])
+      if (replacedTxid != null) {
+        // Get the replaced transaction using the replacedTxid
+        const [rbfTx] = await processor.fetchTransactions({
+          txId: replacedTxid
+        })
+        if (rbfTx != null) {
+          rbfTx.blockHeight = -1
+          await _makeUtxoEngineState.transactionChanged.call(void 0, {
+            walletId: walletInfo.id,
+            tx: rbfTx,
+            pluginInfo,
+            emitter,
+            walletTools,
+            processor
+          })
+        }
+      }
+
       const tx = _ProcessorTransaction.fromEdgeTransaction.call(void 0, edgeTx)
       await _makeUtxoEngineState.transactionChanged.call(void 0, {
         walletId: walletInfo.id,
@@ -518,7 +733,7 @@ var _utils = require('./utils');
       })
       await processor.saveTransaction({
         tx,
-        scriptPubkeys: _optionalChain([edgeTx, 'access', _15 => _15.otherParams, 'optionalAccess', _16 => _16.ourScriptPubkeys])
+        scriptPubkeys: _optionalChain([edgeTx, 'access', _11 => _11.otherParams, 'optionalAccess', _12 => _12.ourScriptPubkeys])
       })
 
       /*
@@ -533,11 +748,11 @@ var _utils = require('./utils');
       privateKeys,
       opts
     ) {
-      const otherParams = _types5.asUtxoSignMessageOtherParams.call(void 0, opts.otherParams)
+      const otherParams = _types7.asUtxoSignMessageOtherParams.call(void 0, opts.otherParams)
       const { publicAddress } = otherParams
       const scriptPubkey = walletTools.addressToScriptPubkey(publicAddress)
       const processorAddress = await processor.fetchAddress(scriptPubkey)
-      if (_optionalChain([processorAddress, 'optionalAccess', _17 => _17.path]) == null) {
+      if (_optionalChain([processorAddress, 'optionalAccess', _13 => _13.path]) == null) {
         throw new Error('Missing address to sign with')
       }
       const privateKey = asMaybeCurrencyPrivateKey(privateKeys)
@@ -546,14 +761,14 @@ var _utils = require('./utils');
         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, {
+      const xprivKeys = await _utils3.fetchOrDeriveXprivFromKeys.call(void 0, {
         privateKey,
         walletLocalEncryptedDisklet,
         coin: coinInfo.name
       })
 
       const signature = await walletTools.signMessageBase64({
-        path: _optionalChain([processorAddress, 'optionalAccess', _18 => _18.path]),
+        path: _optionalChain([processorAddress, 'optionalAccess', _14 => _14.path]),
         message,
         xprivKeys
       })
@@ -568,8 +783,7 @@ var _utils = require('./utils');
       if (otherParams == null) throw new Error('Invalid transaction data')
 
       const { psbt, edgeSpendInfo } = otherParams
-      if (psbt == null || edgeSpendInfo == null)
-        throw new Error('Invalid transaction data')
+      if (psbt == null) throw new Error('Invalid transaction data')
 
       const privateKey = asMaybeCurrencyPrivateKey(privateKeys)
 
@@ -577,7 +791,7 @@ var _utils = require('./utils');
         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, {
+      const xprivKeys = await _utils3.fetchOrDeriveXprivFromKeys.call(void 0, {
         privateKey,
         walletLocalEncryptedDisklet,
         coin: coinInfo.name
@@ -588,24 +802,34 @@ var _utils = require('./utils');
       const privateKeyEncodings = await (async (
 
 ) => {
-        if (edgeSpendInfo.privateKeys != null) {
+        if (_optionalChain([edgeSpendInfo, 'optionalAccess', _15 => _15.privateKeys]) != null) {
           return edgeSpendInfo.privateKeys.map(wif =>
             walletTools.getPrivateKeyEncodingFromWif(wif)
           )
         } else {
           return await Promise.all(
-            psbt.inputs.map(async ({ hash, index }) => {
-              const txid = Buffer.from(hash).reverse().toString('hex')
-              const utxoId = `${txid}_${index}`
+            psbt.inputs.map(async ({ hash, index: vout }) => {
+              const txId = Buffer.from(hash).reverse().toString('hex')
 
-              const [utxo] = await processor.fetchUtxos({
-                utxoIds: [utxoId]
-              })
-              if (utxo == null) throw new Error('Invalid UTXO')
-
-              const address = await processor.fetchAddress(utxo.scriptPubkey)
+              const [transaction] = await processor.fetchTransactions({ txId })
+              if (transaction == null)
+                throw new Error(
+                  'Unable to find previous transaction data for input'
+                )
+              const prevout = transaction.outputs.find(
+                input => input.n === vout
+              )
+              if (prevout == null)
+                throw new Error('Unable to find prevout in transaction')
+              const { scriptPubkey } = prevout
+
+              // Use the scriptPubkey to find the private key from the address
+              // derivation path
+              const address = await processor.fetchAddress(scriptPubkey)
               if (address == null) {
-                throw new Error(`Address for UTXO ${utxoId} not found`)
+                throw new Error(
+                  `Address for scriptPubkey '${scriptPubkey}' not found`
+                )
               }
               if (address.path == null)
                 throw new Error(
@@ -634,7 +858,7 @@ var _utils = require('./utils');
       transaction.signedTx = signedTx.hex
 
       const { paymentProtocolInfo } =
-        _nullishCoalesce(_optionalChain([transaction, 'access', _19 => _19.otherParams, 'optionalAccess', _20 => _20.edgeSpendInfo, 'optionalAccess', _21 => _21.otherParams]), () => ( {}))
+        _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,

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

@@ -1569,25 +1569,27 @@ const processRawUtxo = async (
   let redeemScript
 
   // Function to call once we are finished
-  const done = () =>
+  const done = () => {
+    const processorUtxo = {
+      id,
+      txid: utxo.txid,
+      vout: utxo.vout,
+      value: utxo.value,
+      scriptPubkey: address.scriptPubkey,
+      script,
+      redeemScript,
+      scriptType,
+      blockHeight: _nullishCoalesce(utxo.height, () => ( -1)),
+      spent: false
+    }
     addToProcessorUtxoCache(
       processorUtxoCache,
       path,
       address.scriptPubkey,
       requiredCount,
-      {
-        id,
-        txid: utxo.txid,
-        vout: utxo.vout,
-        value: utxo.value,
-        scriptPubkey: address.scriptPubkey,
-        script,
-        redeemScript,
-        scriptType,
-        blockHeight: _nullishCoalesce(utxo.height, () => ( -1)),
-        spent: false
-      }
+      processorUtxo
     )
+  }
 
   switch (purposeType) {
     case _keymanager.BIP43PurposeTypeEnum.Airbitz:

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

@@ -1,8 +1,17 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _cleaners = require('cleaners');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
 
 
+
+
+
+var _cleaners = require('cleaners');
+
+
+var _types3 = require('../../plugin/types');
+
+
  const asUtxoUserSettings = _cleaners.asObject.call(void 0, {
   blockbookServers: _cleaners.asMaybe.call(void 0, _cleaners.asArray.call(void 0, _cleaners.asString), []),
   enableCustomServers: _cleaners.asMaybe.call(void 0, _cleaners.asBoolean, false)
@@ -23,6 +32,18 @@
 
 
 
+
  const asUtxoSignMessageOtherParams = _cleaners.asObject.call(void 0, {
   publicAddress: _cleaners.asString
 }); exports.asUtxoSignMessageOtherParams = asUtxoSignMessageOtherParams
+
+
+
+
+ const asUtxoSpendInfoOtherParams = _cleaners.asObject.call(void 0, {
+  enableRbf: _cleaners.asOptional.call(void 0, _cleaners.asBoolean),
+  forceChangeAddress: _cleaners.asOptional.call(void 0, _cleaners.asString),
+  outputSort: _cleaners.asOptional.call(void 0, _cleaners.asValue.call(void 0, 'bip69', 'targets'), 'bip69'),
+  txOptions: _cleaners.asOptional.call(void 0, _types3.asTxOptions),
+  utxoSourceAddress: _cleaners.asOptional.call(void 0, _cleaners.asString)
+}); exports.asUtxoSpendInfoOtherParams = asUtxoSpendInfoOtherParams

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

@@ -12,8 +12,9 @@ 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 _cleaners = require('cleaners');
 var _ecpair = require('ecpair');
-var _types = require('edge-core-js/types');
+
 
 var _indexAtProtected = require('../../../util/indexAtProtected');
 var _undefinedIfEmptyString = require('../../../util/undefinedIfEmptyString');
@@ -27,7 +28,9 @@ var _bip69 = require('./bip69');
 
 var _cashAddress = require('./bitcoincashUtils/cashAddress');
 var _coinmapper = require('./coinmapper');
+var _types9 = require('./types');
 var _utxopicker = require('./utxopicker'); var utxopicker = _interopRequireWildcard(_utxopicker);
+var _utils = require('./utxopicker/utils'); var pickerUtils = _interopRequireWildcard(_utils);
 
 let ECPair
 
@@ -73,6 +76,17 @@ var ScriptTypeEnum; (function (ScriptTypeEnum) {
   const replayProtection = 'replayprotection'; ScriptTypeEnum["replayProtection"] = replayProtection;
   const replayProtectionP2SH = 'replayprotectionp2sh'; ScriptTypeEnum["replayProtectionP2SH"] = replayProtectionP2SH;
 })(ScriptTypeEnum || (exports.ScriptTypeEnum = ScriptTypeEnum = {}));
+ const asScriptTypeEnum = _cleaners.asValue.call(void 0, 
+  'p2wpkh' ,
+  'p2wpkhp2sh' ,
+  'p2wsh' ,
+  'p2pk' ,
+  'p2pkh' ,
+  'p2sh' ,
+  'p2tr' ,
+  'replayprotection' ,
+  'replayprotectionp2sh' 
+); exports.asScriptTypeEnum = asScriptTypeEnum
 
 // A transaction input is either legacy or segwit. This is used for transaction creation and passed per input
 var TransactionInputTypeEnum; (function (TransactionInputTypeEnum) {
@@ -257,6 +271,7 @@ var VerifyAddressEnum; (function (VerifyAddressEnum) {
 
 
 
+
 
 
  function bip43PurposeNumberToTypeEnum(
@@ -928,7 +943,7 @@ const wifToPrivateKeyEncodingInternal = (
  function makeTx(args) {
   const { log, outputSort, memos } = args
   let sequence = 0xffffffff
-  if (args.setRBF) {
+  if (args.enableRbf) {
     sequence -= 2
   }
 
@@ -1006,16 +1021,22 @@ const wifToPrivateKeyEncodingInternal = (
 
   const targets = []
   for (const target of args.targets) {
-    if (target.address != null && target.value != null) {
-      const script = exports.addressToScriptPubkey.call(void 0, {
-        address: target.address,
-        coin: coin.name
-      })
-      targets.push({
-        script,
-        value: target.value
-      })
-    }
+    if (target.value == null) continue
+
+    const scriptPubkey =
+      target.address == null
+        ? target.scriptPubkey
+        : exports.addressToScriptPubkey.call(void 0, {
+            address: target.address,
+            coin: coin.name
+          })
+
+    if (scriptPubkey == null) continue
+
+    targets.push({
+      script: scriptPubkey,
+      value: target.value
+    })
   }
   for (const memo of memos) {
     const memoData =
@@ -1051,8 +1072,16 @@ const wifToPrivateKeyEncodingInternal = (
     feeRate: args.feeRate,
     changeScript
   })
-  if (result.inputs == null || result.outputs == null) {
-    throw new (0, _types.InsufficientFundsError)(args.currencyCode)
+  if (result.outputs == null) {
+    const targetsValue = pickerUtils.sumOrNaN(targets)
+    const inputsValue = pickerUtils.sumOrNaN(result.inputs)
+    // This is how much fee is needed to validate the spend
+    const feeDelta = result.fee - (inputsValue - targetsValue)
+    throw new (0, _types9.InsufficientFundsErrorPlus)({
+      currencyCode: args.currencyCode,
+      networkFee: result.fee.toString(),
+      networkFeeShortage: feeDelta.toString()
+    })
   }
 
   const sortedInputs = _bip69.sortInputs.call(void 0, result.inputs)

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

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+var _types = require('edge-core-js/types');
+
+
+
+
+
+
+
+
+ class InsufficientFundsErrorPlus extends _types.InsufficientFundsError {
+  
+  constructor(opts = {}) {
+    super(opts)
+    const { networkFeeShortage } = opts
+    this.networkFeeShortage = networkFeeShortage
+  }
+} exports.InsufficientFundsErrorPlus = InsufficientFundsErrorPlus;
+
+function asMaybeError(name) {
+  return function asError(raw) {
+    if (raw instanceof Error && raw.name === name) {
+      const typeHack = raw
+      return typeHack
+    }
+  }
+}
+
+ const asMaybeInsufficientFundsErrorPlus = asMaybeError(
+  // Share the same name because this error type is a subtype of
+  // InsufficientFundsError and therefore backwards compatible
+  'InsufficientFundsError'
+); exports.asMaybeInsufficientFundsErrorPlus = asMaybeInsufficientFundsErrorPlus

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

@@ -47,6 +47,7 @@ var _utils = require('./utils'); var utils = _interopRequireWildcard(_utils);
 
   return {
     changeUsed: false,
-    fee: Math.ceil(feeRate * utils.transactionBytes(inputs, outputs))
+    fee: Math.ceil(feeRate * utils.transactionBytes(inputs, outputs)),
+    inputs
   }
 } exports.accumulative = accumulative;

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

@@ -54,6 +54,7 @@ var _utils = require('./utils'); var utils = _interopRequireWildcard(_utils);
 
   return {
     changeUsed: false,
-    fee: Math.ceil(feeRate * utils.transactionBytes(inputs, outputs))
+    fee: Math.ceil(feeRate * utils.transactionBytes(inputs, outputs)),
+    inputs
   }
 } exports.forceUseUtxo = forceUseUtxo;

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

@@ -38,5 +38,6 @@
 
 
 
+
 
 

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

@@ -1,4 +1,6 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _keymanager = require('../keymanager');
+"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 _altcoinjs = require('altcoin-js'); var bitcoin = _interopRequireWildcard(_altcoinjs);
+
+var _keymanager = require('../keymanager');
 
 
 /*
@@ -108,6 +110,11 @@ function witnessCount(inputs) {
   return overhead + inputsSize + outputsSize
 } exports.transactionBytes = transactionBytes;
 
+ const transactionSizeFromHex = (hex) => {
+  const transaction = bitcoin.Transaction.fromHex(hex)
+  return transaction.virtualSize()
+}; exports.transactionSizeFromHex = transactionSizeFromHex
+
  function uintOrNaN(v) {
   if (!isFinite(v)) return NaN
   if (Math.floor(v) !== v) return NaN

package/lib/common/utxobased/network/BlockBookAPI.js

@@ -90,7 +90,7 @@ var _cleaners = require('cleaners');
         txid: _cleaners.asString,
         sequence: _cleaners.asOptional.call(void 0, _cleaners.asNumber),
         n: _cleaners.asNumber,
-        vout: _cleaners.asOptional.call(void 0, _cleaners.asNumber, -1),
+        vout: _cleaners.asOptional.call(void 0, _cleaners.asNumber, 0), // If Blockbook doesn't provide vout, assume 0 (empirically observed)
         addresses: _cleaners.asArray.call(void 0, asAddress),
         isAddress: _cleaners.asBoolean,
         value: _cleaners.asString,

package/lib/src/common/plugin/types.d.ts

@@ -24,9 +24,9 @@ export interface AddressPath {
 export interface TxOptions {
     utxos?: IUTXO[];
     subtractFee?: boolean;
-    setRBF?: boolean;
     CPFP?: string;
 }
+export declare const asTxOptions: import("cleaners").ObjectCleaner<TxOptions>;
 export interface PluginInfo {
     currencyInfo: EdgeCurrencyInfo;
     engineInfo: EngineInfo;

package/lib/src/common/utxobased/db/types.d.ts

@@ -24,6 +24,7 @@ export interface IUTXO {
     blockHeight: number;
     spent: boolean;
 }
+export declare const asIUTXO: import("cleaners").ObjectCleaner<IUTXO>;
 export interface IProcessorTransaction {
     txid: string;
     hex: string;

package/lib/src/common/utxobased/db/util/utxo.d.ts

@@ -0,0 +1,3 @@
+import { Processor } from '../makeProcessor';
+import { IProcessorTransaction, IUTXO } from '../types';
+export declare const utxoFromProcessorTransactionInput: (processor: Processor, processorTransaction: IProcessorTransaction, inputIndex: number) => Promise<IUTXO>;

package/lib/src/common/utxobased/engine/types.d.ts

@@ -14,8 +14,17 @@ export interface UtxoTxOtherParams {
     };
     edgeSpendInfo?: EdgeSpendInfo;
     ourScriptPubkeys: string[];
+    replacedTxid?: string;
 }
 export declare type UtxoSignMessageOtherParams = ReturnType<typeof asUtxoSignMessageOtherParams>;
 export declare const asUtxoSignMessageOtherParams: import("cleaners").ObjectCleaner<{
     publicAddress: string;
 }>;
+export declare type UtxoSpendInfoOtherParams = ReturnType<typeof asUtxoSpendInfoOtherParams>;
+export declare const asUtxoSpendInfoOtherParams: import("cleaners").ObjectCleaner<{
+    enableRbf: boolean | undefined;
+    forceChangeAddress: string | undefined;
+    outputSort: "targets" | "bip69";
+    txOptions: import("../../plugin/types").TxOptions | undefined;
+    utxoSourceAddress: string | undefined;
+}>;

package/lib/src/common/utxobased/keymanager/keymanager.d.ts

@@ -28,6 +28,7 @@ export declare enum ScriptTypeEnum {
     replayProtection = "replayprotection",
     replayProtectionP2SH = "replayprotectionp2sh"
 }
+export declare const asScriptTypeEnum: import("cleaners").Cleaner<ScriptTypeEnum>;
 export declare enum TransactionInputTypeEnum {
     Legacy = "legacy",
     Segwit = "segwit"
@@ -136,7 +137,7 @@ export interface MakeTxArgs {
     targets: MakeTxTarget[];
     memos: EdgeMemo[];
     feeRate: number;
-    setRBF: boolean;
+    enableRbf: boolean;
     coin: string;
     currencyCode: string;
     freshChangeAddress: string;
@@ -146,9 +147,10 @@ export interface MakeTxArgs {
 }
 export interface MakeTxTarget {
     address?: string;
+    scriptPubkey?: string;
     value?: number;
 }
-interface MakeTxReturn extends Required<utxopicker.UtxoPickerResult> {
+export interface MakeTxReturn extends Required<utxopicker.UtxoPickerResult> {
     hex: string;
     psbtBase64: string;
 }

package/lib/src/common/utxobased/keymanager/types.d.ts

@@ -0,0 +1,13 @@
+import { Cleaner } from 'cleaners';
+import { InsufficientFundsError } from 'edge-core-js/types';
+interface InsufficientFundsErrorOptsPlus {
+    currencyCode?: string;
+    networkFee?: string;
+    networkFeeShortage?: string;
+}
+export declare class InsufficientFundsErrorPlus extends InsufficientFundsError {
+    networkFeeShortage?: string;
+    constructor(opts?: InsufficientFundsErrorOptsPlus);
+}
+export declare const asMaybeInsufficientFundsErrorPlus: Cleaner<InsufficientFundsErrorPlus | undefined>;
+export {};

package/lib/src/common/utxobased/keymanager/utxopicker/types.d.ts

@@ -28,7 +28,7 @@ export interface UtxoPickerArgs {
     changeScript: string;
 }
 export interface UtxoPickerResult {
-    inputs?: Input[];
+    inputs: Input[];
     outputs?: Output[];
     changeUsed: boolean;
     fee: number;

package/lib/src/common/utxobased/keymanager/utxopicker/utils.d.ts

@@ -5,6 +5,7 @@ export declare function inputBytes(input: UTXO): number;
 export declare function outputBytes(output: Output): number;
 export declare function dustThreshold(output: Output, feeRate: number): number;
 export declare function transactionBytes(inputs: UTXO[], outputs: Output[]): number;
+export declare const transactionSizeFromHex: (hex: string) => number;
 export declare function uintOrNaN(v: number): number;
 export declare function sumForgiving(range: Array<{
     value: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-currency-plugins",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "Edge currency plugins to fetch and process wallet accounts, balances and transactions.",
   "repository": "https://github.com/EdgeApp/edge-currency-plugins",
   "license": "MIT",