edge-currency-plugins 1.3.0 → 1.3.2

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

@@ -5,7 +5,6 @@ var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
 
 
 
-var _keymanager = require('../../keymanager/keymanager');
 
 
 
@@ -63,35 +62,16 @@ var _keymanager = require('../../keymanager/keymanager');
   args
 ) => {
   const { tx, processor, walletTools, pluginInfo, walletId } = args
-  const { engineInfo, currencyInfo } = pluginInfo
+  const { currencyInfo } = pluginInfo
   const ourReceiveAddresses = []
   for (const out of tx.ourOuts) {
     const { scriptPubkey } = tx.outputs[parseInt(out)]
     const address = await processor.fetchAddress(scriptPubkey)
 
-    /*
-    Hack to set replay protection tx to the correct script type through the
-    address format.
-
-    We use a function which can determine whether the derivationLevelScriptHash
-    was used for the path's change index in order to detect whether an address
-    is used for replay protection. We need to detect this because we must treat
-    the address format as bip49 because the script is P2SH even though the
-    address is on the bip44 derivation chain.
-    */
-    const scriptTemplate = _optionalChain([engineInfo, 'access', _ => _.scriptTemplates, 'optionalAccess', _2 => _2.replayProtection])
-    if (
-      scriptTemplate != null &&
-      _optionalChain([address, 'optionalAccess', _3 => _3.path]) != null &&
-      _keymanager.isPathUsingDerivationLevelScriptHash.call(void 0, scriptTemplate, address.path)
-    ) {
-      address.path.format = 'bip49'
-    }
-
-    if (_optionalChain([address, 'optionalAccess', _4 => _4.path]) != null) {
+    if (_optionalChain([address, 'optionalAccess', _ => _.path]) != null) {
       const { address: addrStr } = walletTools.scriptPubkeyToAddress({
-        scriptPubkey,
-        format: address.path.format
+        changePath: address.path,
+        scriptPubkey
       })
       ourReceiveAddresses.push(addrStr)
     }

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

@@ -111,7 +111,10 @@ const BASELET_DIR = 'tables'
   config
 ) {
   const disklet = _disklet.navigateDisklet.call(void 0, config.disklet, BASELET_DIR)
-  let baselets = await _makeBaselets.makeBaselets.call(void 0, { disklet })
+  let baselets = await _makeBaselets.makeBaselets.call(void 0, { disklet }).catch(async error => {
+    await disklet.delete('.')
+    throw error
+  })
 
   /**
    * Calculates the transaction value supplied (negative) or received (positive). In order to calculate
@@ -453,8 +456,8 @@ const BASELET_DIR = 'tables'
             existingAddress.lastTouched = address.lastTouched
           }
 
-          // Only update the balance field if one was given and does not equal the existing value
-          if (address.balance !== existingAddress.balance) {
+          // Only update the balance field if we have a value here
+          if (address.balance != null) {
             existingAddress.balance = address.balance
           }
 

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

@@ -24,7 +24,6 @@
     lastQueriedBlockHeight: 0,
     lastQuery: 0,
     lastTouched: 0,
-    balance: '0',
     ...rest
   }
 }; exports.makeIAddress = makeIAddress

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

@@ -93,8 +93,8 @@ var _utils = require('./utils');
   }
 
   const walletTools = _makeUtxoWalletTools.makeUtxoWalletTools.call(void 0, {
-    publicKey,
-    coin: coinInfo.name
+    pluginInfo,
+    publicKey
   })
 
   const fees = await _makeFees.makeFees.call(void 0, {
@@ -648,8 +648,8 @@ var _utils = require('./utils');
       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
+        pluginInfo,
+        publicKey: tmpWalletInfo.keys.publicKey
       })
 
       // Max spend after imported wallet finishes sync

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

@@ -54,6 +54,8 @@ var _makeServerStates = require('./makeServerStates');
 
 
 
+
+
 var _utils3 = require('./utils');
 
 
@@ -243,8 +245,7 @@ var _utils3 = require('./utils');
         addToAddressTransactionCache(
           commonArgs,
           response.address,
-          path.format,
-          path.changeIndex,
+          path,
           0,
           taskCache.addressTransactionCache
         ).catch(() => {
@@ -267,13 +268,16 @@ var _utils3 = require('./utils');
  = []
 
     for (const format of walletFormats) {
-      const branches = _utils3.getFormatSupportedBranches.call(void 0, format)
+      const branches = _utils3.getFormatSupportedBranches.call(void 0, pluginInfo.engineInfo, format)
       for (const branch of branches) {
         const addressesToSubscribe = new Set()
-        const branchAddressCount = processor.numAddressesByFormatPath({
+        const changePath = {
           format,
           changeIndex: branch
-        })
+        }
+        const branchAddressCount = processor.numAddressesByFormatPath(
+          changePath
+        )
         // If the processor has not processed any addresses then the loop
         // condition will only iterate once when branchAddressCount is 0 for the
         // first address in the derivation path.
@@ -293,14 +297,16 @@ var _utils3 = require('./utils');
             )
           }
           const { address } = walletTools.scriptPubkeyToAddress({
-            scriptPubkey: processorAddress.scriptPubkey,
-            format
+            changePath,
+            scriptPubkey: processorAddress.scriptPubkey
           })
           addressesToSubscribe.add(address)
-          addressBalanceChanges.push({
-            scriptPubkey: processorAddress.scriptPubkey,
-            balance: processorAddress.balance
-          })
+          if (processorAddress.balance != null) {
+            addressBalanceChanges.push({
+              scriptPubkey: processorAddress.scriptPubkey,
+              balance: processorAddress.balance
+            })
+          }
         }
         addToAddressSubscribeCache(commonArgs.taskCache, addressesToSubscribe, {
           format,
@@ -467,8 +473,8 @@ var _utils3 = require('./utils');
             redeemScript
           } = walletTools.getScriptPubkeyFromWif(wif, format)
           const { address } = walletTools.scriptPubkeyToAddress({
-            scriptPubkey,
-            format: path.format
+            changePath: path,
+            scriptPubkey
           })
 
           // Make a new IAddress and save it
@@ -585,6 +591,7 @@ var _utils3 = require('./utils');
 
 
 
+
 
 
 const setLookAhead = async (common) => {
@@ -602,7 +609,7 @@ const setLookAhead = async (common) => {
 
   try {
     for (const format of walletFormats) {
-      const branches = _utils3.getFormatSupportedBranches.call(void 0, format)
+      const branches = _utils3.getFormatSupportedBranches.call(void 0, engineInfo, format)
       for (const branch of branches) {
         await deriveKeys({ format, changeIndex: branch })
       }
@@ -627,8 +634,8 @@ const setLookAhead = async (common) => {
 
       const { scriptPubkey, redeemScript } = walletTools.getScriptPubkey(path)
       const { address } = walletTools.scriptPubkeyToAddress({
-        scriptPubkey,
-        format: path.format
+        changePath: path,
+        scriptPubkey
       })
 
       // Make a new IAddress and save it
@@ -668,14 +675,13 @@ const addToAddressSubscribeCache = (
 }
 
 const addToAddressTransactionCache = async (
-  args,
+  common,
   address,
-  format,
-  branch,
+  changePath,
   blockHeight,
   addressTransactionCache
 ) => {
-  const { walletTools, processor } = args
+  const { walletTools, processor } = common
   // Fetch the blockHeight for the address from the database
   const scriptPubkey = walletTools.addressToScriptPubkey(address)
 
@@ -687,10 +693,7 @@ const addToAddressTransactionCache = async (
 
   addressTransactionCache[address] = {
     processing: false,
-    path: {
-      format,
-      changeIndex: branch
-    },
+    path: changePath,
     page: 1, // Page starts on 1
     blockHeight
   }
@@ -774,21 +777,25 @@ const addToAddressTransactionCache = async (
   }
 
   // Loop unparsed utxos, some require a network call to get the full tx data
-  for (const [utxoString, state] of Object.entries(rawUtxoCache)) {
-    const utxo = JSON.parse(utxoString)
+  for (const [utxoId, state] of Object.entries(rawUtxoCache)) {
+    const utxo = state.blockbookUtxo
     if (utxo == null) continue
     if (!state.processing) {
       // check if we need to fetch additional network content for legacy purpose type
-      const purposeType = _utils3.currencyFormatToPurposeType.call(void 0, state.path.format)
+      const purposeType = _utils3.pathToPurposeType.call(void 0, 
+        state.path,
+        pluginInfo.engineInfo.scriptTemplates
+      )
       if (
         purposeType === _keymanager.BIP43PurposeTypeEnum.Airbitz ||
-        purposeType === _keymanager.BIP43PurposeTypeEnum.Legacy
+        purposeType === _keymanager.BIP43PurposeTypeEnum.Legacy ||
+        purposeType === _keymanager.BIP43PurposeTypeEnum.ReplayProtection
       ) {
         // if we do need to make a network call, check with the serverState
         if (!serverStates.serverCanGetTx(uri, utxo.txid)) return
       }
       state.processing = true
-      _utils.removeItem.call(void 0, rawUtxoCache, utxoString)
+      _utils.removeItem.call(void 0, rawUtxoCache, utxoId)
       const wsTask = await processRawUtxo({
         ...args,
         ...state,
@@ -829,30 +836,38 @@ const addToAddressTransactionCache = async (
 
   // Check if there are any addresses pending to be subscribed
   if (Object.keys(addressSubscribeCache).length > 0) {
-    // These are addresse to which the server has not subscribed
-    const newAddress = []
+    // These are addresses to which the server has not subscribed
+    const newAddresses = []
     const blockHeight = serverStates.getBlockHeight(uri)
 
     // Loop each address in the cache
     for (const [address, state] of Object.entries(addressSubscribeCache)) {
+      const isAddressNewlySubscribed = !serverStates.serverIsAwareOfAddress(
+        uri,
+        address
+      )
+
       // Add address in the cache to the set of addresses to watch
-      if (!serverStates.serverIsAwareOfAddress(uri, address)) {
-        newAddress.push(address)
+      if (isAddressNewlySubscribed) {
+        newAddresses.push(address)
       }
 
       // Add to the addressTransactionCache if they're not yet added:
       // Only process newly watched addresses
       if (state.processing) continue
+
       // Add the newly watched addresses to the UTXO cache
-      addressUtxoCache[address] = {
-        processing: false,
-        path: state.path
+      if (isAddressNewlySubscribed) {
+        addressUtxoCache[address] = {
+          processing: false,
+          path: state.path
+        }
       }
+
       await addToAddressTransactionCache(
         args,
         address,
-        state.path.format,
-        state.path.changeIndex,
+        state.path,
         blockHeight,
         addressTransactionCache
       )
@@ -860,8 +875,8 @@ const addToAddressTransactionCache = async (
     }
 
     // Subscribe to any new addresses
-    if (newAddress.length > 0) {
-      serverStates.watchAddresses(uri, newAddress)
+    if (newAddresses.length > 0) {
+      serverStates.watchAddresses(uri, newAddresses)
       return true
     }
   }
@@ -1173,23 +1188,16 @@ const internalGetFreshAddress = async (
     path.addressIndex = forceIndex
   }
 
-  let nativeBalance = '0'
-  let scriptPubkey
   const iAddress = await processor.fetchAddress(path)
-  if (iAddress != null) {
-    nativeBalance = iAddress.balance
-    scriptPubkey = iAddress.scriptPubkey
-  } else {
-    const scriptPubKeyRet = await walletTools.getScriptPubkey(path)
-    scriptPubkey = scriptPubKeyRet.scriptPubkey
-  }
+  const nativeBalance = _nullishCoalesce(_optionalChain([iAddress, 'optionalAccess', _2 => _2.balance]), () => ( '0'))
+  const { scriptPubkey } = await _asyncNullishCoalesce(iAddress, async () => ( (await walletTools.getScriptPubkey(path))))
 
   if (scriptPubkey == null) {
     throw new Error('Unknown address path')
   }
   const address = walletTools.scriptPubkeyToAddress({
-    scriptPubkey,
-    format
+    changePath: path,
+    scriptPubkey
   })
 
   return {
@@ -1415,7 +1423,9 @@ const processAddressUtxos = async (
       }
 
       for (const utxo of utxos) {
-        rawUtxoCache[JSON.stringify(utxo)] = {
+        const utxoId = `${utxo.txid}_${utxo.vout}`
+        rawUtxoCache[utxoId] = {
+          blockbookUtxo: utxo,
           processing: false,
           requiredCount: utxos.length,
           path,
@@ -1557,6 +1567,7 @@ const processRawUtxo = async (
     utxo,
     id,
     address,
+    pluginInfo,
     processor,
     path,
     taskCache,
@@ -1566,7 +1577,11 @@ const processRawUtxo = async (
     log
   } = args
   const { rawUtxoCache, processorUtxoCache } = taskCache
-  let scriptType
+  const purposeType = _utils3.pathToPurposeType.call(void 0, 
+    path,
+    pluginInfo.engineInfo.scriptTemplates
+  )
+  const scriptType = _utils3.getScriptTypeFromPurposeType.call(void 0, purposeType)
   let script
   let redeemScript
 
@@ -1591,19 +1606,18 @@ const processRawUtxo = async (
       }
     )
 
-  switch (_utils3.currencyFormatToPurposeType.call(void 0, path.format)) {
+  switch (purposeType) {
     case _keymanager.BIP43PurposeTypeEnum.Airbitz:
     case _keymanager.BIP43PurposeTypeEnum.Legacy:
-      scriptType = _keymanager.ScriptTypeEnum.p2pkh
-      if (address.redeemScript != null) {
-        scriptType = _keymanager.ScriptTypeEnum.p2sh
-        redeemScript = address.redeemScript
-      }
+    case _keymanager.BIP43PurposeTypeEnum.ReplayProtection:
+      redeemScript = address.redeemScript
 
       // Legacy UTXOs need the previous transaction hex as the script
       // If we do not currently have it, add it to the queue to fetch it
       {
-        const [tx] = await processor.fetchTransactions({ txId: utxo.txid })
+        const [tx] = await processor.fetchTransactions({
+          txId: utxo.txid
+        })
         if (tx == null) {
           const queryTime = Date.now()
           const deferred = new _Deferred2.default()
@@ -1621,7 +1635,9 @@ const processRawUtxo = async (
             .catch(err => {
               // If something went wrong, add the UTXO back to the queue
               log('error in processRawUtxo:', err)
-              rawUtxoCache[JSON.stringify(utxo)] = {
+              const utxoId = `${utxo.txid}_${utxo.vout}`
+              rawUtxoCache[utxoId] = {
+                blockbookUtxo: utxo,
                 processing: false,
                 path,
                 address,
@@ -1639,7 +1655,6 @@ const processRawUtxo = async (
 
       break
     case _keymanager.BIP43PurposeTypeEnum.WrappedSegwit:
-      scriptType = _keymanager.ScriptTypeEnum.p2wpkhp2sh
       script = address.scriptPubkey
       if (address.redeemScript == null) {
         throw new Error(
@@ -1650,7 +1665,6 @@ const processRawUtxo = async (
 
       break
     case _keymanager.BIP43PurposeTypeEnum.Segwit:
-      scriptType = _keymanager.ScriptTypeEnum.p2wpkh
       script = address.scriptPubkey
 
       break

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

@@ -13,12 +13,18 @@
 
 
 
+
+
+
+
+
 var _keymanager = require('../keymanager/keymanager');
 
 
 
 
 
+
 var _utils = require('./utils');
 
 
@@ -91,7 +97,9 @@ var _utils = require('./utils');
  function makeUtxoWalletTools(
   config
 ) {
-  const { coin, publicKey } = config
+  const { pluginInfo, publicKey } = config
+  const { engineInfo } = pluginInfo
+  const { name: coin } = pluginInfo.coinInfo
 
   const xpubKeys = publicKey.publicKeys
 
@@ -112,10 +120,11 @@ var _utils = require('./utils');
     },
 
     getScriptPubkey(args) {
-      const purposeType = _utils.currencyFormatToPurposeType.call(void 0, args.format)
+      const purposeType = _utils.pathToPurposeType.call(void 0, args, engineInfo.scriptTemplates)
       const scriptType = _utils.getScriptTypeFromPurposeType.call(void 0, purposeType)
       return _keymanager.pubkeyToScriptPubkey.call(void 0, {
         pubkey: fns.getPubkey(args),
+        scriptTemplates: engineInfo.scriptTemplates,
         scriptType
       })
     },
@@ -147,12 +156,16 @@ var _utils = require('./utils');
       const pubkey = _keymanager.privateKeyEncodingToPubkey.call(void 0, privateKeyEncoding)
       return _keymanager.pubkeyToScriptPubkey.call(void 0, {
         pubkey: pubkey,
+        scriptTemplates: engineInfo.scriptTemplates,
         scriptType
       })
     },
 
     getAddress(args) {
-      const purposeType = _utils.currencyFormatToPurposeType.call(void 0, args.format)
+      const purposeType = _utils.pathToPurposeType.call(void 0, 
+        args,
+        pluginInfo.engineInfo.scriptTemplates
+      )
       const { scriptPubkey } = fns.getScriptPubkey(args)
       const addressType = _utils.getAddressTypeFromPurposeType.call(void 0, purposeType)
       return _keymanager.scriptPubkeyToAddress.call(void 0, {
@@ -167,8 +180,13 @@ var _utils = require('./utils');
     },
 
     scriptPubkeyToAddress(args) {
-      const purposeType = _utils.currencyFormatToPurposeType.call(void 0, args.format)
+      const { changePath } = args
+      const purposeType = _utils.pathToPurposeType.call(void 0, 
+        changePath,
+        pluginInfo.engineInfo.scriptTemplates
+      )
       const addressType = _utils.getAddressTypeFromPurposeType.call(void 0, purposeType)
+
       return _keymanager.scriptPubkeyToAddress.call(void 0, {
         scriptPubkey: args.scriptPubkey,
         addressType,

package/lib/common/utxobased/engine/util/getOwnUtxosFromTx.js

@@ -2,9 +2,6 @@
 
 
 var _keymanager = require('../../keymanager/keymanager');
-
-
-
 var _utils = require('../utils');
 
  const getOwnUtxosFromTx = async (
@@ -43,18 +40,15 @@ var _utils = require('../utils');
       const path = address.path
       if (path != null) {
         const redeemScript = address.redeemScript
-        const purposeType = _utils.currencyFormatToPurposeType.call(void 0, path.format)
+        const purposeType = _utils.pathToPurposeType.call(void 0, path, engineInfo.scriptTemplates)
 
         const isAirbitzOrLegacy = [
           _keymanager.BIP43PurposeTypeEnum.Airbitz,
-          _keymanager.BIP43PurposeTypeEnum.Legacy
+          _keymanager.BIP43PurposeTypeEnum.Legacy,
+          _keymanager.BIP43PurposeTypeEnum.ReplayProtection
         ].includes(purposeType)
 
-        const scriptType = _utils.getScriptTypeFromPurposeType.call(void 0, 
-          purposeType,
-          redeemScript,
-          engineInfo.scriptTemplates
-        )
+        const scriptType = _utils.getScriptTypeFromPurposeType.call(void 0, purposeType)
         const script = isAirbitzOrLegacy ? tx.hex : address.scriptPubkey
         const utxo = {
           id,

package/lib/common/utxobased/engine/utils.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 _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);
+"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);
 
 
 
@@ -18,6 +18,8 @@ var _cleaners = require('../keymanager/cleaners');
 
 
 
+
+
 var _keymanager = require('../keymanager/keymanager');
 
  const getCurrencyFormatFromPurposeType = (
@@ -32,6 +34,8 @@ var _keymanager = require('../keymanager/keymanager');
       return 'bip49'
     case _keymanager.BIP43PurposeTypeEnum.Segwit:
       return 'bip84'
+    case _keymanager.BIP43PurposeTypeEnum.ReplayProtection:
+      return 'bip44' // Only bip44 formatted wallets contain this purpose type (BCH)
   }
 }; exports.getCurrencyFormatFromPurposeType = getCurrencyFormatFromPurposeType
 
@@ -69,27 +73,18 @@ var _keymanager = require('../keymanager/keymanager');
 
     case _keymanager.BIP43PurposeTypeEnum.Segwit:
       return _keymanager.AddressTypeEnum.p2wpkh
+
+    case _keymanager.BIP43PurposeTypeEnum.ReplayProtection:
+      return _keymanager.AddressTypeEnum.p2sh
   }
 }; exports.getAddressTypeFromPurposeType = getAddressTypeFromPurposeType
 
  const getScriptTypeFromPurposeType = (
-  purpose,
-  redeemScript,
-  scriptTemplates
+  purpose
 ) => {
   switch (purpose) {
     case _keymanager.BIP43PurposeTypeEnum.Airbitz:
     case _keymanager.BIP43PurposeTypeEnum.Legacy:
-      if (redeemScript != null) {
-        if (_optionalChain([scriptTemplates, 'optionalAccess', _ => _.replayProtection]) != null) {
-          const replayProtectionPartialScript = scriptTemplates
-            .replayProtection('')
-            .slice(0, -4)
-          if (redeemScript.indexOf(replayProtectionPartialScript) === 0) {
-            return _keymanager.ScriptTypeEnum.replayProtection
-          }
-        }
-      }
       return _keymanager.ScriptTypeEnum.p2pkh
 
     case _keymanager.BIP43PurposeTypeEnum.WrappedSegwit:
@@ -97,6 +92,9 @@ var _keymanager = require('../keymanager/keymanager');
 
     case _keymanager.BIP43PurposeTypeEnum.Segwit:
       return _keymanager.ScriptTypeEnum.p2wpkh
+
+    case _keymanager.BIP43PurposeTypeEnum.ReplayProtection:
+      return _keymanager.ScriptTypeEnum.replayProtection
   }
 }; exports.getScriptTypeFromPurposeType = getScriptTypeFromPurposeType
 
@@ -109,15 +107,63 @@ var _keymanager = require('../keymanager/keymanager');
   }); exports.validScriptPubkeyFromAddress = validScriptPubkeyFromAddress
 
  const getFormatSupportedBranches = (
+  engineInfo,
   format
 ) => {
   const branches = [0]
   if (exports.currencyFormatToPurposeType.call(void 0, format) !== _keymanager.BIP43PurposeTypeEnum.Airbitz) {
     branches.push(1)
   }
+  if (engineInfo.scriptTemplates != null) {
+    if (engineInfo.scriptTemplates.replayProtection != null) {
+      branches.push(
+        _keymanager.derivationLevelScriptHash.call(void 0, engineInfo.scriptTemplates.replayProtection)
+      )
+    }
+  }
   return branches
 }; exports.getFormatSupportedBranches = getFormatSupportedBranches
 
+/**
+ * The reason for this function is to consider the address path for
+ * determining the purpose-type for the address. This is because some parts
+ * of the address such as the changeIndex have special meaning for the
+ * purpose-type. Specifically for scriptTemplates, the hash of the template
+ * is used to deterministically identify the changeIndex used constantly for
+ * the addresses spending to those scriptTemplates.
+ *
+ * In the future, we will want to strictly use only the format of the path
+ * in order to determine the purpose-type per the BIP43 spec. This will require
+ * a significant lift to reconsider the type for the path's format (currently
+ * CurrencyFormat). The scriptTemplates could define a format index and this
+ * could be used in address paths instead of a CurrencyType.
+ */
+ const pathToPurposeType = (
+  path,
+  scriptTemplates
+) => {
+  // Script Template Purpose Types
+  if (scriptTemplates != null) {
+    // TODO: Change ScriptTemplates map type to couple the key to the ScriptTypeEnum; make this algorithm generic and move it to key-manager
+    // Handle each hard-coded case for the supported script templates
+    if (
+      scriptTemplates.replayProtection != null &&
+      _keymanager.isPathUsingDerivationLevelScriptHash.call(void 0, 
+        scriptTemplates.replayProtection,
+        path
+      )
+    ) {
+      return _keymanager.BIP43PurposeTypeEnum.ReplayProtection
+    }
+  }
+  return exports.currencyFormatToPurposeType.call(void 0, path.format)
+}; exports.pathToPurposeType = pathToPurposeType
+
+/**
+ * Only use this function when needing to infer the purpose-type for a wallet
+ * format (CurrencyFormat). To get the purpose-type for an address use
+ * pathToPurposeType passing the address path.
+ */
  const currencyFormatToPurposeType = (
   format
 ) =>

package/lib/common/utxobased/info/bitcoincash.js

@@ -52,7 +52,7 @@ const currencyInfo = {
 
 const engineInfo = {
   formats: ['bip44', 'bip32'],
-  // forks: ['bitcoinsv'],
+  forks: ['bitcoinsv'],
   gapLimit: 10,
   defaultFee: 10000,
   feeUpdateInterval: 60000,

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

@@ -28,6 +28,7 @@ var BIP43PurposeTypeEnum; (function (BIP43PurposeTypeEnum) {
   const Legacy = 'legacy'; BIP43PurposeTypeEnum["Legacy"] = Legacy; // xpub/xprv tpub/tprv etc.
   const Segwit = 'segwit'; BIP43PurposeTypeEnum["Segwit"] = Segwit; // zpub/zprv vpub/vprv etc.
   const WrappedSegwit = 'wrappedSegwit'; BIP43PurposeTypeEnum["WrappedSegwit"] = WrappedSegwit; // ypub/yprv upub/uprv etc.
+  const ReplayProtection = 'replayProtection'; BIP43PurposeTypeEnum["ReplayProtection"] = ReplayProtection;
 })(BIP43PurposeTypeEnum || (exports.BIP43PurposeTypeEnum = BIP43PurposeTypeEnum = {}));
 
 // supported address types.
@@ -239,6 +240,7 @@ var VerifyAddressEnum; (function (VerifyAddressEnum) {
 
 
 
+
 
 
  function bip43PurposeNumberToTypeEnum(
@@ -510,12 +512,18 @@ const addressToScriptPubkeyInternal = (
     default:
       throw new Error('invalid address type in address to script pubkey')
   }
-  const scriptPubkey = payment({
-    address: args.address,
-    network: network,
-    bs58DecodeFunc: coin.bs58DecodeFunc,
-    bs58EncodeFunc: coin.bs58EncodeFunc
-  }).output
+  let scriptPubkey
+  try {
+    scriptPubkey = payment({
+      address: args.address,
+      network: network,
+      bs58DecodeFunc: coin.bs58DecodeFunc,
+      bs58EncodeFunc: coin.bs58EncodeFunc
+    }).output
+  } catch (error) {
+    console.trace(error)
+    throw error
+  }
   if (scriptPubkey == null) {
     throw new Error('failed converting address to scriptPubkey')
   }
@@ -621,23 +629,28 @@ const addressToScriptPubkeyInternal = (
     default:
       throw new Error('invalid address type in address to script pubkey')
   }
-  address =
-    _nullishCoalesce(address, () => (
-    payment({
-      output: Buffer.from(args.scriptPubkey, 'hex'),
-      network: network,
-      bs58DecodeFunc: coinClass.bs58DecodeFunc,
-      bs58EncodeFunc: coinClass.bs58EncodeFunc
-    }).address))
-
-  legacyAddress =
-    _nullishCoalesce(legacyAddress, () => (
-    payment({
-      output: Buffer.from(args.scriptPubkey, 'hex'),
-      network: legacyNetwork,
-      bs58DecodeFunc: coinClass.bs58DecodeFunc,
-      bs58EncodeFunc: coinClass.bs58EncodeFunc
-    }).address))
+  try {
+    address =
+      _nullishCoalesce(address, () => (
+      payment({
+        output: Buffer.from(args.scriptPubkey, 'hex'),
+        network: network,
+        bs58DecodeFunc: coinClass.bs58DecodeFunc,
+        bs58EncodeFunc: coinClass.bs58EncodeFunc
+      }).address))
+
+    legacyAddress =
+      _nullishCoalesce(legacyAddress, () => (
+      payment({
+        output: Buffer.from(args.scriptPubkey, 'hex'),
+        network: legacyNetwork,
+        bs58DecodeFunc: coinClass.bs58DecodeFunc,
+        bs58EncodeFunc: coinClass.bs58EncodeFunc
+      }).address))
+  } catch (error) {
+    console.trace(error)
+    throw error
+  }
 
   if (address == null || legacyAddress == null) {
     throw new Error('failed converting scriptPubkey to address')
@@ -666,10 +679,16 @@ const addressToScriptPubkeyInternal = (
     default:
       throw new Error('invalid address type in address to script pubkey')
   }
-  const scriptHash = payment({
-    output: Buffer.from(args.scriptPubkey, 'hex'),
-    network: network
-  }).hash
+  let scriptHash
+  try {
+    scriptHash = payment({
+      output: Buffer.from(args.scriptPubkey, 'hex'),
+      network: network
+    }).hash
+  } catch (error) {
+    console.trace(error)
+    throw error
+  }
   if (scriptHash == null) {
     throw new Error('failed converting scriptPubkey to address')
   }
@@ -693,13 +712,34 @@ const addressToScriptPubkeyInternal = (
       output: Buffer.from(scriptPubkey, 'hex')
     }
   })
-  if (p2sh.output == null || _optionalChain([p2sh, 'access', _ => _.redeem, 'optionalAccess', _2 => _2.output]) == null) {
+  const scriptPubkeyFromLib = _optionalChain([p2sh, 'access', _ => _.output, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3('hex')])
+  const redeemScript = _optionalChain([p2sh, 'access', _4 => _4.redeem, 'optionalAccess', _5 => _5.output, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7('hex')])
+  const scriptHash = _optionalChain([p2sh, 'access', _8 => _8.hash, 'optionalAccess', _9 => _9.toString, 'call', _10 => _10('hex')])
+
+  if (scriptPubkeyFromLib == null || redeemScript == null) {
     throw new Error('unable to convert script to p2sh')
   }
+
+  let address = p2sh.address
+
+  // Special cashaddr handling
+  if (coin != null && scriptHash != null) {
+    const coinClass = _coinmapper.getCoinFromString.call(void 0, coin)
+    const coinPrefixes = coinClass.prefixes
+    const standardPrefixes = selectedCoinPrefixes(coinPrefixes, 0)
+    if (standardPrefixes.cashaddr != null) {
+      address = _cashAddress.hashToCashAddress.call(void 0, 
+        scriptHash,
+        _cashAddress.CashaddrTypeEnum.scripthash,
+        standardPrefixes.cashaddr
+      )
+    }
+  }
+
   return {
-    scriptPubkey: p2sh.output.toString('hex'),
-    redeemScript: p2sh.redeem.output.toString('hex'),
-    address: p2sh.address
+    scriptPubkey: scriptPubkeyFromLib,
+    redeemScript: redeemScript,
+    address
   }
 } exports.scriptPubkeyToP2SH = scriptPubkeyToP2SH;
 
@@ -731,6 +771,14 @@ const addressToScriptPubkeyInternal = (
         throw new Error('failed converting pubkey to script pubkey')
       }
       return { scriptPubkey: payment.output.toString('hex') }
+    case ScriptTypeEnum.replayProtection: {
+      if (args.scriptTemplates == null)
+        throw new Error('Missing replayProtection script template')
+      const redeemScript = args.scriptTemplates.replayProtection(args.pubkey)
+      return scriptPubkeyToP2SH({
+        scriptPubkey: redeemScript
+      })
+    }
     default:
       throw new Error('invalid address type in pubkey to script pubkey')
   }
@@ -761,9 +809,9 @@ const xprivToPrivateKeyInternal = (
   const bip32FromBase58Func = _nullishCoalesce(coin.bip32FromBase58Func, () => ( bip32.fromBase58))
   const node = bip32FromBase58Func(args.xpriv, network)
   return _optionalChain([node
-, 'access', _3 => _3.derive, 'call', _4 => _4(args.bip44ChangeIndex)
-, 'access', _5 => _5.derive, 'call', _6 => _6(args.bip44AddressIndex)
-, 'access', _7 => _7.privateKey, 'optionalAccess', _8 => _8.toString, 'call', _9 => _9('hex')])
+, 'access', _11 => _11.derive, 'call', _12 => _12(args.bip44ChangeIndex)
+, 'access', _13 => _13.derive, 'call', _14 => _14(args.bip44AddressIndex)
+, 'access', _15 => _15.privateKey, 'optionalAccess', _16 => _16.toString, 'call', _17 => _17('hex')])
 }
 
  const xprivToPrivateKey = (args) => {
@@ -992,7 +1040,7 @@ const wifToPrivateKeyEncodingInternal = (
     psbt.addInputs(sortedInputs)
     psbt.addOutputs(sortedOutputs)
   } catch (error) {
-    _optionalChain([log, 'optionalAccess', _10 => _10.error, 'call', _11 => _11(`Failed makeTx: ${String(error)}`)])
+    _optionalChain([log, 'optionalAccess', _18 => _18.error, 'call', _19 => _19(`Failed makeTx: ${String(error)}`)])
     throw error
   }
 
@@ -1002,7 +1050,7 @@ const wifToPrivateKeyEncodingInternal = (
     changeUsed: result.changeUsed,
     fee: result.fee,
     psbtBase64: psbt.toBase64(),
-    hex: _optionalChain([psbt, 'access', _12 => _12.data, 'optionalAccess', _13 => _13.globalMap, 'optionalAccess', _14 => _14.unsignedTx, 'optionalAccess', _15 => _15.toBuffer, 'call', _16 => _16(), 'optionalAccess', _17 => _17.toString, 'call', _18 => _18('hex')])
+    hex: _optionalChain([psbt, 'access', _20 => _20.data, 'optionalAccess', _21 => _21.globalMap, 'optionalAccess', _22 => _22.unsignedTx, 'optionalAccess', _23 => _23.toBuffer, 'call', _24 => _24(), 'optionalAccess', _25 => _25.toString, 'call', _26 => _26('hex')])
   }
 } exports.makeTx = makeTx;
 
@@ -1126,6 +1174,8 @@ const bip43PurposeTypeEnumToNumber = (
       return 49
     case BIP43PurposeTypeEnum.Segwit:
       return 84
+    case BIP43PurposeTypeEnum.ReplayProtection:
+      return 44 // Only bip44 formatted wallets contain this purpose type (BCH)
   }
 }
 
@@ -1256,10 +1306,16 @@ const scriptHashToScriptPubkey = (
     default:
       throw new Error('invalid address type in address to script pubkey')
   }
-  const scriptPubkey = payment({
-    hash: Buffer.from(args.scriptHash, 'hex'),
-    network: network
-  }).output
+  let scriptPubkey
+  try {
+    scriptPubkey = payment({
+      hash: Buffer.from(args.scriptHash, 'hex'),
+      network: network
+    }).output
+  } catch (error) {
+    console.trace(error)
+    throw error
+  }
   if (scriptPubkey == null) {
     throw new Error('failed converting scriptPubkey to address')
   }

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

@@ -3,7 +3,7 @@ import { AddressByScriptPubkeyBaselet, LastUsedByFormatPathBaselet, ScriptPubkey
 interface MakeBaseletsConfig {
     disklet: Disklet;
 }
-declare type Executor<BaseletName extends keyof AllBaselets> = (tables: AllBaselets[BaseletName]) => Promise<unknown>;
+declare type Executor<BaseletName extends keyof AllBaselets, T> = (tables: AllBaselets[BaseletName]) => Promise<T>;
 interface AllBaselets {
     address: AddressBaselets;
     tx: TransactionBaselets;
@@ -24,9 +24,9 @@ interface UtxoBaselets {
     utxoIdsByScriptPubkey: UtxoIdsByScriptPubkeyBaselet;
 }
 export interface Baselets {
-    address: <E extends Executor<'address'>>(fn: E) => Promise<ReturnType<E>>;
-    tx: <E extends Executor<'tx'>>(fn: E) => Promise<ReturnType<E>>;
-    utxo: <E extends Executor<'utxo'>>(fn: E) => Promise<ReturnType<E>>;
+    address: <T>(fn: Executor<'address', T>) => Promise<T>;
+    tx: <T>(fn: Executor<'tx', T>) => Promise<T>;
+    utxo: <T>(fn: Executor<'utxo', T>) => Promise<T>;
     all: AddressBaselets & TransactionBaselets & UtxoBaselets;
 }
 export declare const makeBaselets: (config: MakeBaseletsConfig) => Promise<Baselets>;

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

@@ -9,7 +9,7 @@ export interface IAddress {
     lastQuery: number;
     lastTouched: number;
     used: boolean;
-    balance: string;
+    balance?: string;
 }
 export declare const makeIAddress: (addressFields: SoftPick<IAddress, 'scriptPubkey'>) => IAddress;
 export interface IUTXO {

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

@@ -5,6 +5,7 @@ import { ChangePath, CurrencyFormat, EngineConfig, PluginInfo } from '../../plug
 import { Processor } from '../db/makeProcessor';
 import { IAddress, IProcessorTransaction, IUTXO } from '../db/types';
 import { NumbWalletInfo } from '../keymanager/cleaners';
+import { BlockbookAccountUtxo } from '../network/BlockBookAPI';
 import { WsTask } from '../network/Socket';
 import AwaitLock from './await-lock';
 import { ServerStates } from './makeServerStates';
@@ -89,6 +90,7 @@ interface ProcessorUtxoCache {
 }
 interface RawUtxoCache {
     [key: string]: {
+        blockbookUtxo: BlockbookAccountUtxo;
         processing: boolean;
         path: ChangePath;
         address: IAddress;

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

@@ -1,11 +1,11 @@
-import { AddressPath, CurrencyFormat } from '../../plugin/types';
+import { AddressPath, ChangePath, CurrencyFormat, PluginInfo } from '../../plugin/types';
 import { ScriptTemplate } from '../info/scriptTemplates/types';
 import { PublicKey } from '../keymanager/cleaners';
 import { PrivateKeyEncoding } from '../keymanager/keymanager';
 import { CurrencyFormatKeys } from './utils';
 export interface WalletToolsConfig {
+    pluginInfo: PluginInfo;
     publicKey: PublicKey;
-    coin: string;
 }
 export interface UTXOPluginWalletTools {
     getPubkey: (args: AddressPath) => string;
@@ -24,8 +24,8 @@ interface ScriptPubkeyReturn {
     redeemScript?: string;
 }
 interface ScriptPubkeyToAddressArgs {
+    changePath: ChangePath;
     scriptPubkey: string;
-    format: CurrencyFormat;
 }
 interface GetPrivateKeyArgs {
     path: AddressPath;

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

@@ -1,6 +1,6 @@
 import { Disklet } from 'disklet';
 import { EdgeMemoRules, EdgeParsedUri } from 'edge-core-js/types';
-import { CurrencyFormat } from '../../plugin/types';
+import { ChangePath, CurrencyFormat, EngineInfo } from '../../plugin/types';
 import { IUTXO } from '../db/types';
 import { ScriptTemplates } from '../info/scriptTemplates/types';
 import { PrivateKey } from '../keymanager/cleaners';
@@ -9,12 +9,32 @@ export declare const getCurrencyFormatFromPurposeType: (purpose: BIP43PurposeTyp
 export declare const validateMemo: (memo: string) => EdgeMemoRules;
 export declare const getAddressTypeFromKeys: (privateKey: PrivateKey) => AddressTypeEnum;
 export declare const getAddressTypeFromPurposeType: (purpose: BIP43PurposeTypeEnum) => AddressTypeEnum;
-export declare const getScriptTypeFromPurposeType: (purpose: BIP43PurposeTypeEnum, redeemScript?: string | undefined, scriptTemplates?: ScriptTemplates | undefined) => ScriptTypeEnum;
+export declare const getScriptTypeFromPurposeType: (purpose: BIP43PurposeTypeEnum) => ScriptTypeEnum;
 export declare const validScriptPubkeyFromAddress: (args: {
     address: string;
     coin: string;
 }) => string;
-export declare const getFormatSupportedBranches: (format: CurrencyFormat) => number[];
+export declare const getFormatSupportedBranches: (engineInfo: EngineInfo, format: CurrencyFormat) => number[];
+/**
+ * The reason for this function is to consider the address path for
+ * determining the purpose-type for the address. This is because some parts
+ * of the address such as the changeIndex have special meaning for the
+ * purpose-type. Specifically for scriptTemplates, the hash of the template
+ * is used to deterministically identify the changeIndex used constantly for
+ * the addresses spending to those scriptTemplates.
+ *
+ * In the future, we will want to strictly use only the format of the path
+ * in order to determine the purpose-type per the BIP43 spec. This will require
+ * a significant lift to reconsider the type for the path's format (currently
+ * CurrencyFormat). The scriptTemplates could define a format index and this
+ * could be used in address paths instead of a CurrencyType.
+ */
+export declare const pathToPurposeType: (path: ChangePath, scriptTemplates?: ScriptTemplates | undefined) => BIP43PurposeTypeEnum;
+/**
+ * Only use this function when needing to infer the purpose-type for a wallet
+ * format (CurrencyFormat). To get the purpose-type for an address use
+ * pathToPurposeType passing the address path.
+ */
 export declare const currencyFormatToPurposeType: (format: CurrencyFormat) => BIP43PurposeTypeEnum;
 export declare type CurrencyFormatKeys = {
     [format in CurrencyFormat]?: string;

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

@@ -1,13 +1,14 @@
 import { EdgeLog } from 'edge-core-js/types';
-import { AddressPath } from '../../plugin/types';
+import { ChangePath } from '../../plugin/types';
 import { IUTXO } from '../db/types';
-import { ScriptTemplate } from '../info/scriptTemplates/types';
+import { ScriptTemplate, ScriptTemplates } from '../info/scriptTemplates/types';
 import * as utxopicker from './utxopicker';
 export declare enum BIP43PurposeTypeEnum {
     Airbitz = "airbitz",
     Legacy = "legacy",
     Segwit = "segwit",
-    WrappedSegwit = "wrappedSegwit"
+    WrappedSegwit = "wrappedSegwit",
+    ReplayProtection = "replayProtection"
 }
 export declare enum AddressTypeEnum {
     p2pkh = "p2pkh",
@@ -71,6 +72,7 @@ export interface AddressToScriptPubkeyArgs {
 }
 export interface PubkeyToScriptPubkeyArgs {
     pubkey: string;
+    scriptTemplates?: ScriptTemplates;
     scriptType: ScriptTypeEnum;
 }
 export interface PubkeyToScriptPubkeyReturn {
@@ -189,7 +191,7 @@ export declare const getAddressTypeFromAddress: (address: string, coinName: stri
 export declare function seedOrMnemonicToXPriv(args: SeedOrMnemonicToXPrivArgs): string;
 export declare const xprivToXPub: (args: XPrivToXPubArgs) => string;
 export declare function derivationLevelScriptHash(scriptTemplate: ScriptTemplate): number;
-export declare const isPathUsingDerivationLevelScriptHash: (scriptTemplate: ScriptTemplate, path: AddressPath) => boolean;
+export declare const isPathUsingDerivationLevelScriptHash: (scriptTemplate: ScriptTemplate, path: ChangePath) => boolean;
 export declare const xpubToPubkey: (args: XPubToPubkeyArgs) => string;
 export declare const addressToScriptPubkey: (args: AddressToScriptPubkeyArgs) => string;
 export declare function scriptPubkeyToAddress(args: ScriptPubkeyToAddressArgs): ScriptPubkeyToAddressReturn;

package/package.json

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