edge-currency-plugins 1.0.0-rc.1 → 1.0.0-rc.2

package/lib/common/plugin/makeCurrencyPlugin.js

@@ -22,7 +22,7 @@ var _pluginState = require('./pluginState');
   const { io, log, pluginDisklet } = pluginOptions
   const currencyTools = _makeCurrencyTools.makeCurrencyTools.call(void 0, io, pluginInfo)
   const { defaultSettings, pluginId, currencyCode } = currencyInfo
-  const state = _pluginState.makePluginState.call(void 0, {
+  const pluginState = _pluginState.makePluginState.call(void 0, {
     io,
     currencyCode,
     pluginId,
@@ -49,7 +49,7 @@ var _pluginState = require('./pluginState');
           ...engineOptions,
           emitter
         },
-        pluginState: state
+        pluginState
       }
       const engine = await _makeUtxoEngine.makeUtxoEngine.call(void 0, engineConfig)
 
@@ -57,7 +57,7 @@ var _pluginState = require('./pluginState');
     },
 
     async makeCurrencyTools() {
-      state.load().catch(e => {
+      pluginState.load().catch(e => {
         throw e
       })
       return currencyTools

package/lib/common/plugin/makeEngineEmitter.js

@@ -95,6 +95,12 @@ var EngineEvent; (function (EngineEvent) {
 
   emitter.on(EngineEvent.TRANSACTIONS_CHANGED, callbacks.onTransactionsChanged)
   emitter.on(EngineEvent.WALLET_BALANCE_CHANGED, callbacks.onBalanceChanged)
+  emitter.on(
+    EngineEvent.BLOCK_HEIGHT_CHANGED,
+    (_uri, height) => {
+      callbacks.onBlockHeightChanged(height)
+    }
+  )
   emitter.on(EngineEvent.ADDRESSES_CHECKED, callbacks.onAddressesChecked)
   emitter.on(EngineEvent.TXIDS_CHANGED, callbacks.onTxidsChanged)
 

package/lib/common/plugin/pluginState.js

@@ -227,10 +227,10 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
       enableCustomServers = settings.enableCustomServers
       customServers = settings.blockbookServers
 
-      const enginesToBeStopped = []
+      const enginesToBeStarted = []
       const disconnects = []
       for (const engine of engines) {
-        enginesToBeStopped.push(engine)
+        enginesToBeStarted.push(engine)
         engine.setServerList([])
         disconnects.push(engine.stop())
       }
@@ -245,8 +245,8 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
       serverCacheDirty = true
       await saveServerCache()
       await refreshServers()
-      for (const engine of enginesToBeStopped) {
-        await engine.stop()
+      for (const engine of enginesToBeStarted) {
+        await engine.start()
       }
     }
   }

package/lib/common/plugin/types.js

@@ -17,7 +17,6 @@ var _cleaners = require('cleaners');
 
 
 
-
  const asCurrencyFormat = _cleaners.asValue.call(void 0, 'bip32', 'bip44', 'bip49', 'bip84'); exports.asCurrencyFormat = asCurrencyFormat
 
 // Path up to changeIndex
@@ -125,12 +124,6 @@ var _cleaners = require('cleaners');
 
 
 
-
-
-
-
-
-
 
 
 

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

@@ -3,7 +3,6 @@
 
 
 
-var _defaultValidateConfirmations = require('../../engine/util/defaultValidateConfirmations');
 var _keymanager = require('../../keymanager/keymanager');
 
 
@@ -58,14 +57,10 @@ var _keymanager = require('../../keymanager/keymanager');
 
 
 
-
  const toEdgeTransaction = async (
   args
 ) => {
-  const { tx, processor, walletBlockHeight, walletTools, pluginInfo } = args
-  const { currencyInfo, engineInfo } = pluginInfo
-  const { validateConfirmations = _defaultValidateConfirmations.defaultValidateConfirmations } = engineInfo
-  const { requiredConfirmations } = currencyInfo
+  const { tx, processor, walletTools, engineInfo } = args
 
   const ourReceiveAddresses = []
   for (const out of tx.ourOuts) {
@@ -73,7 +68,7 @@ var _keymanager = require('../../keymanager/keymanager');
     const address = await processor.fetchAddress(scriptPubkey)
 
     /*
-    Hack to set replay protection tx to the correct script type through the
+    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
@@ -100,16 +95,9 @@ var _keymanager = require('../../keymanager/keymanager');
     }
   }
 
-  const confirmations = validateConfirmations(
-    tx,
-    walletBlockHeight,
-    requiredConfirmations
-  )
-
-  const edgeTx = {
+  return {
     currencyCode: args.currencyCode,
     txid: args.tx.txid,
-    confirmations,
     blockHeight: args.tx.blockHeight,
     date: args.tx.date,
     nativeAmount: args.tx.ourAmount,
@@ -117,6 +105,4 @@ var _keymanager = require('../../keymanager/keymanager');
     signedTx: args.tx.hex,
     ourReceiveAddresses
   }
-
-  return edgeTx
 }; exports.toEdgeTransaction = toEdgeTransaction

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

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _urijs = require('uri-js');
 
 var _makeEngineEmitter = require('../../plugin/makeEngineEmitter');
@@ -54,8 +54,6 @@ var _constants = require('./constants');
 
 
 
-
-
 
 
 
@@ -63,9 +61,8 @@ var _constants = require('./constants');
   const { engineEmitter, log, pluginInfo, pluginState, walletInfo } = config
   log('Making server states')
 
-  let serverStates = {}
+  const serverStatesCache = {}
   let isEngineOn = true
-  let connections = {}
   let serverList = []
   let reconnectCounter = 0
   let reconnectTimer = setTimeout(() => {
@@ -81,8 +78,7 @@ var _constants = require('./constants');
   socketEmitter.on(
     _MakeSocketEmitter.SocketEvent.CONNECTION_CLOSE,
     (uri, error) => {
-      _utils.removeItem.call(void 0, connections, uri)
-      _utils.removeItem.call(void 0, serverStates, uri)
+      _utils.removeItem.call(void 0, serverStatesCache, uri)
 
       const msg =
         error != null ? ` !! Connection ERROR !! ${error.message}` : ''
@@ -107,7 +103,7 @@ var _constants = require('./constants');
       log(
         `${uri} received received new transaction with id ${newTx.tx.txid} to address ${newTx.address}`
       )
-      const serverState = serverStates[uri]
+      const serverState = serverStatesCache[uri]
       if (serverState != null) {
         serverState.txids.add(newTx.tx.txid)
       }
@@ -117,7 +113,7 @@ var _constants = require('./constants');
     _makeEngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
     (uri, blockHeight) => {
       log(`${uri} block height changed to ${blockHeight}`)
-      serverStates[uri].blockHeight = blockHeight
+      serverStatesCache[uri].blockHeight = blockHeight
     }
   )
 
@@ -126,7 +122,8 @@ var _constants = require('./constants');
 
 
 
-  const makeServerState = () => ({
+  const makeServerStatesCacheEntry = (blockbook) => ({
+    blockbook,
     blockSubscriptionStatus: 'unsubscribed',
     txids: new Set(),
     addresses: new Set(),
@@ -144,13 +141,13 @@ var _constants = require('./constants');
     log(`stopping server states`)
     _socketQueue.removeIdFromQueue.call(void 0, walletInfo.id)
     clearTimeout(reconnectTimer)
-    for (const uri of Object.keys(connections)) {
-      const blockBook = connections[uri]
-      if (blockBook == null) continue
-      await blockBook.disconnect()
+    for (const uri of Object.keys(serverStatesCache)) {
+      const serverState = serverStatesCache[uri]
+      const { blockbook } = serverState
+      if (blockbook == null) continue
+      await blockbook.disconnect()
+      _utils.removeItem.call(void 0, serverStatesCache, uri)
     }
-    connections = {}
-    serverStates = {}
   }
 
   const reconnect = () => {
@@ -166,6 +163,7 @@ var _constants = require('./constants');
 
   const refillServers = () => {
     log(`refilling servers...`)
+    isEngineOn = true
     _socketQueue.pushUpdate.call(void 0, {
       id: walletInfo.id,
       updateFunc: () => {
@@ -181,16 +179,17 @@ var _constants = require('./constants');
     }
     log(`refillServers: Top ${_constants.NEW_CONNECTIONS} servers:`, serverList)
     let chanceToBePicked = 1.25
-    while (Object.keys(connections).length < _constants.MAX_CONNECTIONS) {
+    while (Object.keys(serverStatesCache).length < _constants.MAX_CONNECTIONS) {
       if (serverList.length === 0) break
       const uri = serverList.shift()
       if (uri == null) {
         reconnect()
         break
       }
-      if (connections[uri] != null) {
-        continue
-      }
+
+      // Skip reconnecting to an existing connection
+      if (serverStatesCache[uri] != null) continue
+
       // Validate the URI of server to make sure it is valid
       const parsed = _urijs.parse.call(void 0, uri)
       if (
@@ -200,56 +199,54 @@ var _constants = require('./constants');
       ) {
         continue
       }
+
+      // Ranomize the URI picking
       chanceToBePicked -= chanceToBePicked > 0.5 ? 0.25 : 0
       if (Math.random() > chanceToBePicked) {
         serverList.push(uri)
         continue
       }
 
-      serverStates[uri] = makeServerState()
-
-      const onQueueSpaceCB = async (
-
-
-) => {
-        const blockBook = connections[uri]
-        if (blockBook == null) {
-          return
-        }
-        const task = await pickNextTaskCB(uri)
-        if (task != null && typeof task !== 'boolean') {
-          const taskMessage = `${task.method} params: ${JSON.stringify(
-            task.params
-          )}`
-          log(`${uri} nextTask: ${taskMessage}`)
-        }
-        return task
-      }
-
-      connections[uri] = _BlockBook.makeBlockBook.call(void 0, {
+      // Make new Blockbook instance
+      const blockbook = _BlockBook.makeBlockBook.call(void 0, {
         wsAddress: uri,
         socketEmitter,
         engineEmitter,
         log,
-        onQueueSpaceCB,
+        onQueueSpaceCB: async (
+
+
+) => {
+          // Exit if the connection is no longer active
+          if (!(uri in serverStatesCache)) return
+
+          const task = await pickNextTaskCB(uri)
+          if (task != null && typeof task !== 'boolean') {
+            const taskMessage = `${task.method} params: ${JSON.stringify(
+              task.params
+            )}`
+            log(`${uri} nextTask: ${taskMessage}`)
+          }
+          return task
+        },
         walletId: walletInfo.id,
         asAddress: pluginInfo.engineInfo.asBlockbookAddress
       })
 
-      const blockBook = connections[uri]
-      if (blockBook == null) continue
+      // Make new ServerStates instance
+      serverStatesCache[uri] = makeServerStatesCacheEntry(blockbook)
 
       // Initialize blockbook connection for server
-      blockBook
+      blockbook
         .connect()
         .then(async () => {
           // Fetch block height from blockbook server
           const startTime = Date.now()
-          const { bestHeight: blockHeight } = await blockBook.fetchInfo()
+          const { bestHeight: blockHeight } = await blockbook.fetchInfo()
           log('height:', blockHeight)
 
           // Update server state
-          serverStates[uri].blockHeight = blockHeight
+          serverStatesCache[uri].blockHeight = blockHeight
 
           // Emit initial BLOCK_HEIGHT_CHANGED event
           engineEmitter.emit(_makeEngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED, uri, blockHeight)
@@ -265,33 +262,36 @@ var _constants = require('./constants');
   }
 
   const serverCanGetTx = (uri, txid) => {
-    const serverState = serverStates[uri]
+    const serverState = serverStatesCache[uri]
     if (serverState == null) return false
     if (serverState.txids.has(txid)) return true
 
-    for (const state of Object.values(serverStates)) {
+    for (const state of Object.values(serverStatesCache)) {
       if (state.txids.has(txid)) return false
     }
     return true
   }
 
   const serverCanGetAddress = (uri, address) => {
-    const serverState = serverStates[uri]
+    const serverState = serverStatesCache[uri]
     if (serverState == null) return false
     if (serverState.addresses.has(address)) return true
 
-    for (const state of Object.values(serverStates)) {
+    for (const state of Object.values(serverStatesCache)) {
       if (state.addresses.has(address)) return false
     }
     return true
   }
 
-  const serverScoreUp = (uri, score) => {
-    pluginState.serverScoreUp(uri, score)
+  const serverIsAwareOfAddress = (uri, address) => {
+    const serverState = serverStatesCache[uri]
+    if (serverState == null) return false
+    if (serverState.addresses.has(address)) return true
+    return false
   }
 
   const getServerState = (uri) => {
-    return serverStates[uri]
+    return serverStatesCache[uri]
   }
 
   const getServerList = () => {
@@ -304,10 +304,10 @@ var _constants = require('./constants');
 
   const broadcastTx = async (transaction) => {
     return await new Promise((resolve, reject) => {
-      const uris = Object.keys(connections).filter(uri => {
-        const blockBook = connections[uri]
-        if (blockBook == null) return false
-        return blockBook.isConnected
+      const uris = Object.keys(serverStatesCache).filter(uri => {
+        const { blockbook } = serverStatesCache[uri]
+        if (blockbook == null) return false
+        return blockbook.isConnected
       })
       if (uris == null || uris.length < 1) {
         reject(
@@ -317,9 +317,9 @@ var _constants = require('./constants');
       let resolved = false
       let bad = 0
       for (const uri of uris) {
-        const blockBook = connections[uri]
-        if (blockBook == null) continue
-        blockBook
+        const { blockbook } = serverStatesCache[uri]
+        if (blockbook == null) continue
+        blockbook
           .broadcastTx(transaction)
           .then(response => {
             if (!resolved) {
@@ -345,18 +345,42 @@ var _constants = require('./constants');
     addresses,
     deferredAddressSub
   ) => {
-    const blockbook = connections[uri]
-    if (blockbook == null)
+    const serverState = serverStatesCache[uri]
+    if (serverState == null)
       throw new Error(`No blockbook connection with ${uri}`)
-    blockbook.watchAddresses(addresses, deferredAddressSub)
+
+    const { blockbook } = serverState
+
+    // Add new addresses to the set of known addresses
+    for (const address of addresses) {
+      serverState.addresses.add(address)
+    }
+
+    const queryTime = Date.now()
+    const deferred = new _Deferred2.default()
+    deferred.promise
+      .then((value) => {
+        pluginState.serverScoreUp(uri, Date.now() - queryTime)
+        _optionalChain([deferredAddressSub, 'optionalAccess', _ => _.resolve, 'call', _2 => _2(value)])
+      })
+      .catch(() => {
+        // Remove new addresses to the set of known addresses
+        for (const address of addresses) {
+          serverState.addresses.delete(address)
+        }
+        pluginState.serverScoreDown(uri)
+        _optionalChain([deferredAddressSub, 'optionalAccess', _3 => _3.reject, 'call', _4 => _4()])
+      })
+    blockbook.watchAddresses(Array.from(addresses), deferred)
   }
 
   const watchBlocks = (uri) => {
-    const blockbook = connections[uri]
-    if (blockbook == null)
+    const serverState = serverStatesCache[uri]
+    if (serverState == null)
       throw new Error(`No blockbook connection with ${uri}`)
 
-    const serverState = _nullishCoalesce(serverStates[uri], () => ( makeServerState()))
+    const { blockbook } = serverState
+
     serverState.blockSubscriptionStatus = 'subscribing'
 
     const queryTime = Date.now()
@@ -364,7 +388,7 @@ var _constants = require('./constants');
     deferred.promise
       .then(() => {
         serverState.blockSubscriptionStatus = 'subscribed'
-        serverScoreUp(uri, Date.now() - queryTime)
+        pluginState.serverScoreUp(uri, Date.now() - queryTime)
       })
       .catch(() => {
         serverState.blockSubscriptionStatus = 'unsubscribed'
@@ -373,7 +397,7 @@ var _constants = require('./constants');
   }
 
   const getBlockHeight = (uri) => {
-    return serverStates[uri].blockHeight
+    return serverStatesCache[uri].blockHeight
   }
 
   return {
@@ -381,7 +405,7 @@ var _constants = require('./constants');
     stop,
     serverCanGetTx,
     serverCanGetAddress,
-    serverScoreUp,
+    serverIsAwareOfAddress,
     getServerState,
     refillServers,
     getServerList,

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

@@ -254,10 +254,9 @@ var _utils = require('./utils');
             await _ProcessorTransaction.toEdgeTransaction.call(void 0, {
               tx,
               currencyCode: currencyInfo.currencyCode,
-              pluginInfo,
+              walletTools,
               processor,
-              walletBlockHeight: metadata.lastSeenBlockHeight,
-              walletTools
+              engineInfo
             })
         )
       )
@@ -421,7 +420,6 @@ var _utils = require('./utils');
         currencyCode: currencyInfo.currencyCode,
         txid: '',
         date: _unixTime.unixTime.call(void 0, ),
-        confirmations: 'unconfirmed',
         blockHeight: 0,
         nativeAmount,
         networkFee,
@@ -454,12 +452,11 @@ var _utils = require('./utils');
     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
+        pluginInfo,
+        emitter,
+        walletTools,
+        processor
       })
       await processor.saveTransaction({
         tx,

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

@@ -15,6 +15,7 @@ var _makeEngineEmitter = require('../../plugin/makeEngineEmitter');
 
 
 
+
 var _utils = require('../../plugin/utils');
 
 var _ProcessorTransaction = require('../db/Models/ProcessorTransaction');
@@ -99,7 +100,6 @@ var _utils3 = require('./utils');
   const { walletFormats } = walletInfo.keys
 
   const taskCache = {
-    addressWatching: false,
     blockWatching: false,
     addressSubscribeCache: {},
     addressTransactionCache: {},
@@ -110,14 +110,25 @@ var _utils3 = require('./utils');
   }
 
   const clearTaskCache = () => {
-    taskCache.addressWatching = false
     taskCache.blockWatching = false
-    taskCache.addressSubscribeCache = {}
-    taskCache.addressTransactionCache = {}
-    taskCache.addressUtxoCache = {}
-    taskCache.rawUtxoCache = {}
-    taskCache.processorUtxoCache = {}
-    taskCache.updateTransactionCache = {}
+    for (const key of Object.keys(taskCache.addressSubscribeCache)) {
+      _utils.removeItem.call(void 0, taskCache.addressSubscribeCache, key)
+    }
+    for (const key of Object.keys(taskCache.addressTransactionCache)) {
+      _utils.removeItem.call(void 0, taskCache.addressTransactionCache, key)
+    }
+    for (const key of Object.keys(taskCache.addressUtxoCache)) {
+      _utils.removeItem.call(void 0, taskCache.addressUtxoCache, key)
+    }
+    for (const key of Object.keys(taskCache.rawUtxoCache)) {
+      _utils.removeItem.call(void 0, taskCache.rawUtxoCache, key)
+    }
+    for (const key of Object.keys(taskCache.processorUtxoCache)) {
+      _utils.removeItem.call(void 0, taskCache.processorUtxoCache, key)
+    }
+    for (const key of Object.keys(taskCache.updateTransactionCache)) {
+      _utils.removeItem.call(void 0, taskCache.updateTransactionCache, key)
+    }
   }
 
   /**
@@ -170,11 +181,10 @@ var _utils3 = require('./utils');
     io: config.io,
     log,
     serverStates,
+    pluginState,
     walletFormats,
     lock
   }
-  const { currencyInfo } = pluginInfo
-  const { requiredConfirmations = 1 } = currencyInfo
 
   const pickNextTaskCB = async (
     uri
@@ -196,32 +206,14 @@ var _utils3 = require('./utils');
 
   emitter.on(
     _makeEngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
-    async (_uri, walletBlockHeight) => {
-      // Check if unconfirmed transaction have been confirmed.
-      const unconfirmedTxs = await processor.fetchTransactions({
+    async (_uri, _blockHeight) => {
+      const txs = await processor.fetchTransactions({
         blockHeight: 0
       })
-      for (const tx of unconfirmedTxs) {
+      for (const tx of txs) {
         if (tx == null) continue
         taskCache.updateTransactionCache[tx.txid] = { processing: false }
       }
-
-      // Trigger transactions change event to update its confirmation status
-      const pendingTxs = await processor.fetchTransactions({
-        blockHeight: walletBlockHeight - requiredConfirmations,
-        blockHeightMax: walletBlockHeight
-      })
-      for (const tx of pendingTxs) {
-        if (tx == null) continue
-        await exports.transactionChanged.call(void 0, {
-          emitter,
-          processor,
-          pluginInfo,
-          tx,
-          walletBlockHeight,
-          walletTools
-        })
-      }
     }
   )
 
@@ -448,7 +440,6 @@ var _utils3 = require('./utils');
           }
         }
       }
-      taskCache.addressWatching = false
     }
   }
 } exports.makeUtxoEngineState = makeUtxoEngineState;
@@ -592,7 +583,6 @@ const addToAddressSubscribeCache = (
       path,
       processing: false
     }
-    taskCache.addressWatching = false
   })
 }
 
@@ -633,28 +623,23 @@ const addToAddressTransactionCache = async (
 
 
 
-
  const transactionChanged = async (
   args
 ) => {
   const {
     emitter,
-    walletBlockHeight,
     walletTools,
     processor,
-    pluginInfo,
+    pluginInfo: { currencyInfo, engineInfo },
     tx
   } = args
-  const { currencyInfo } = pluginInfo
-
   emitter.emit(_makeEngineEmitter.EngineEvent.TRANSACTIONS_CHANGED, [
     await _ProcessorTransaction.toEdgeTransaction.call(void 0, {
       tx,
       currencyCode: currencyInfo.currencyCode,
-      pluginInfo,
+      walletTools,
       processor,
-      walletBlockHeight: walletBlockHeight,
-      walletTools
+      engineInfo
     })
   ])
 }; exports.transactionChanged = transactionChanged
@@ -705,8 +690,6 @@ const addToAddressTransactionCache = async (
     }
   }
 
-  const blockHeight = serverStates.getBlockHeight(uri)
-
   // 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)
@@ -726,6 +709,7 @@ const addToAddressTransactionCache = async (
       const wsTask = await processRawUtxo({
         ...args,
         ...state,
+        address: state.address,
         utxo,
         id: `${utxo.txid}_${utxo.vout}`
       })
@@ -751,62 +735,52 @@ const addToAddressTransactionCache = async (
         .then(() => {
           serverState.addresses.add(address)
         })
-        .catch(e => {
-          throw e
+        .catch(err => {
+          addressUtxoCache[address] = state
+          console.error(err)
+          args.log('error in addressUtxoCache:', err)
         })
       return wsTask
     }
   }
 
   // Check if there are any addresses pending to be subscribed
-  if (
-    Object.keys(addressSubscribeCache).length > 0 &&
-    !taskCache.addressWatching
-  ) {
-    // Loop each address that needs to be subscribed
+  if (Object.keys(addressSubscribeCache).length > 0) {
+    // These are addresse to which the server has not subscribed
+    const newAddress = []
+    const blockHeight = serverStates.getBlockHeight(uri)
+
+    // Loop each address in the cache
     for (const [address, state] of Object.entries(addressSubscribeCache)) {
       // Add address in the cache to the set of addresses to watch
-      const { path, processing: subscribed } = state
-      // only process newly watched addresses
-      if (subscribed) continue
-      if (path != null) {
-        // Add the newly watched addresses to the UTXO cache
-        addressUtxoCache[address] = {
-          processing: false,
-          path
-        }
-        await addToAddressTransactionCache(
-          args,
-          address,
-          path.format,
-          path.changeIndex,
-          blockHeight,
-          addressTransactionCache
-        )
+      if (!serverStates.serverIsAwareOfAddress(uri, address)) {
+        newAddress.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
       }
+      await addToAddressTransactionCache(
+        args,
+        address,
+        state.path.format,
+        state.path.changeIndex,
+        blockHeight,
+        addressTransactionCache
+      )
       state.processing = true
     }
 
-    taskCache.addressWatching = true
-
-    const queryTime = Date.now()
-    const deferred = new _Deferred2.default()
-    deferred.promise
-      .then(() => {
-        serverStates.serverScoreUp(uri, Date.now() - queryTime)
-      })
-      .catch(() => {
-        taskCache.addressWatching = false
-      })
-    deferred.promise.catch(() => {
-      taskCache.addressWatching = false
-    })
-    serverStates.watchAddresses(
-      uri,
-      Array.from(Object.keys(addressSubscribeCache)),
-      deferred
-    )
-    return true
+    // Subscribe to any new addresses
+    if (newAddress.length > 0) {
+      serverStates.watchAddresses(uri, newAddress)
+      return true
+    }
   }
 
   // filled when transactions potentially changed (e.g. through new block notification)
@@ -817,18 +791,16 @@ const addToAddressTransactionCache = async (
         hasProcessedAtLeastOnce = true
         state.processing = true
         _utils.removeItem.call(void 0, updateTransactionCache, txId)
-        const updateTransactionTask = updateTransactions({
-          ...args,
-          walletBlockHeight: blockHeight,
-          txId
-        })
+        const updateTransactionTask = updateTransactions({ ...args, txId })
         // once resolved, add the txid to the server cache
         updateTransactionTask.deferred.promise
           .then(() => {
             serverState.txids.add(txId)
           })
-          .catch(e => {
-            throw e
+          .catch(err => {
+            updateTransactionCache[txId] = state
+            console.error(err)
+            args.log('error in updateTransactionCache:', err)
           })
         return updateTransactionTask
       }
@@ -847,15 +819,17 @@ const addToAddressTransactionCache = async (
       // Fetch and process address UTXOs
       const wsTask = await processAddressTransactions({
         ...args,
-        ...state,
+        addressTransactionState: state,
         address
       })
       wsTask.deferred.promise
         .then(() => {
           serverState.addresses.add(address)
         })
-        .catch(e => {
-          throw e
+        .catch(err => {
+          addressTransactionCache[address] = state
+          console.error(err)
+          args.log('error in updateTransactionCache:', err)
         })
       return wsTask
     }
@@ -866,29 +840,17 @@ const addToAddressTransactionCache = async (
 
 
 
-
 const updateTransactions = (
   args
 ) => {
-  const {
-    walletBlockHeight,
-    emitter,
-    walletTools,
-    txId,
-    pluginInfo,
-    processor,
-    taskCache
-  } = args
+  const { emitter, walletTools, txId, pluginInfo, processor, taskCache } = args
   const deferred = new _Deferred2.default()
   deferred.promise
     .then(async (txResponse) => {
       // check if raw tx is still not confirmed, if so, don't change anything
       if (txResponse.blockHeight < 1) return
       // Create new tx from raw tx
-      const tx = processTransactionResponse({
-        ...args,
-        txResponse
-      })
+      const tx = processTransactionResponse({ ...args, txResponse })
       // Remove any existing input utxos from the processor
       for (const input of tx.inputs) {
         await processor.removeUtxos([`${input.txId}_${input.outputIndex}`])
@@ -909,14 +871,15 @@ const updateTransactions = (
       })
       await exports.transactionChanged.call(void 0, {
         emitter,
+        walletTools,
         processor,
         pluginInfo,
-        tx: processedTx,
-        walletBlockHeight,
-        walletTools
+        tx: processedTx
       })
     })
-    .catch(() => {
+    .catch(err => {
+      console.error(err)
+      args.log('error in updateTransactions:', err)
       taskCache.updateTransactionCache[txId] = { processing: false }
     })
   return {
@@ -1023,25 +986,21 @@ const internalGetFreshAddress = async (
 
 
 
-
-
-
 const processAddressTransactions = async (
   args
 ) => {
   const {
     address,
-    page = 1,
-    blockHeight: walletBlockHeight,
+    addressTransactionState,
     emitter,
     pluginInfo,
     processor,
     walletTools,
-    path,
     taskCache,
-    serverStates,
+    pluginState,
     uri
   } = args
+  const { page = 1, blockHeight } = addressTransactionState
   const {
     engineInfo: { asBlockbookAddress }
   } = pluginInfo
@@ -1057,7 +1016,7 @@ const processAddressTransactions = async (
   const deferred = new _Deferred2.default()
   deferred.promise
     .then(async (value) => {
-      serverStates.serverScoreUp(uri, Date.now() - queryTime)
+      pluginState.serverScoreUp(uri, Date.now() - queryTime)
       const { transactions = [], txs, unconfirmedTxs, totalPages } = value
 
       // If address is used and previously not marked as used, mark as used.
@@ -1068,21 +1027,17 @@ const processAddressTransactions = async (
 
       // Process and save the address's transactions
       for (const txResponse of transactions) {
-        const tx = processTransactionResponse({
-          ...args,
-          txResponse
-        })
+        const tx = processTransactionResponse({ ...args, txResponse })
         const processedTx = await processor.saveTransaction({
           tx,
           scriptPubkeys: [scriptPubkey]
         })
         await exports.transactionChanged.call(void 0, {
           emitter,
+          walletTools,
           processor,
           pluginInfo,
-          tx: processedTx,
-          walletBlockHeight,
-          walletTools
+          tx: processedTx
         })
       }
 
@@ -1091,16 +1046,15 @@ const processAddressTransactions = async (
       if (page < totalPages) {
         // Add the address back to the cache, incrementing the page
         addressTransactionCache[address] = {
-          path,
+          ...addressTransactionState,
           processing: false,
-          blockHeight: walletBlockHeight,
           page: page + 1
         }
         return
       }
 
       // Update the lastQueriedBlockHeight for the address
-      addressData.lastQueriedBlockHeight = walletBlockHeight
+      addressData.lastQueriedBlockHeight = blockHeight
 
       // Save/update the fully-processed address
       await processor.saveAddress(addressData)
@@ -1114,8 +1068,8 @@ const processAddressTransactions = async (
     .catch(err => {
       // Log the error for debugging purposes without crashing the engine
       // This will cause frozen wallet syncs
-      console.error(err.toString())
-      console.log(err.stack)
+      console.error(err)
+      addressTransactionCache[address] = addressTransactionState
     })
 
   return {
@@ -1136,9 +1090,10 @@ const processAddressTransactions = async (
 const processTransactionResponse = (
   args
 ) => {
-  const { txResponse, pluginInfo } = args
-  const { coinInfo } = pluginInfo
-
+  const {
+    txResponse,
+    pluginInfo: { coinInfo }
+  } = args
   return {
     txid: txResponse.txid,
     hex: txResponse.hex,
@@ -1189,7 +1144,7 @@ const processAddressUtxos = async (
     taskCache,
     path,
     pluginInfo,
-    serverStates,
+    pluginState,
     uri
   } = args
   const {
@@ -1200,7 +1155,7 @@ const processAddressUtxos = async (
   const deferred = new _Deferred2.default()
   deferred.promise
     .then(async (utxos) => {
-      serverStates.serverScoreUp(uri, Date.now() - queryTime)
+      pluginState.serverScoreUp(uri, Date.now() - queryTime)
       const scriptPubkey = walletTools.addressToScriptPubkey(address)
       const addressData = await processor.fetchAddress(scriptPubkey)
       if (addressData == null || addressData.path == null) {
@@ -1325,7 +1280,7 @@ const processRawUtxo = async (
     path,
     taskCache,
     requiredCount,
-    serverStates,
+    pluginState,
     uri,
     log
   } = args
@@ -1373,7 +1328,7 @@ const processRawUtxo = async (
           const deferred = new _Deferred2.default()
           deferred.promise
             .then((txResponse) => {
-              serverStates.serverScoreUp(uri, Date.now() - queryTime)
+              pluginState.serverScoreUp(uri, Date.now() - queryTime)
               const processedTx = processTransactionResponse({
                 ...args,
                 txResponse
@@ -1382,9 +1337,9 @@ const processRawUtxo = async (
               // Only after we have successfully fetched the tx, set our script and call done
               done()
             })
-            .catch(e => {
+            .catch(err => {
               // If something went wrong, add the UTXO back to the queue
-              log('error in processed utxos cache, re-adding utxo to cache:', e)
+              log('error in processRawUtxo:', err)
               rawUtxoCache[JSON.stringify(utxo)] = {
                 processing: false,
                 path,

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

@@ -1,9 +1,15 @@
 "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 _cleaners = require('cleaners');
 
 
 var _constants = require('../../constants');
 
 
+
+
+
+var _keymanager = require('../keymanager/keymanager');
+
 const currencyInfo = {
   pluginId: 'bitcoinsv',
   walletType: 'wallet:bitcoinsv',
@@ -18,7 +24,10 @@ const currencyInfo = {
   // Configuration options:
   defaultSettings: {
     customFeeSettings: ['satPerByte'],
-    blockbookServers: ['wss://bsv-bbwrap1.edge.app'],
+    blockbookServers: [
+      'wss://bsv-bbwrap1.edge.app',
+      'wss://blockbook.siftbitcoin.com:9146'
+    ],
     enableCustomServers: false
   },
   customFeeTemplate: [
@@ -54,7 +63,35 @@ const engineInfo = {
     standardFeeHigh: '10',
     standardFeeLowAmount: '1000000',
     standardFeeHighAmount: '65000000'
-  }
+  },
+  /*
+  This is to support cashaddr and 1-addresses coming from the network.
+  We always convert to a 1-address for internal use.
+  We send 1-address to the network because all servers should support legacy 
+  address (this is the uncleaner).
+  */
+  asBlockbookAddress: _cleaners.asCodec.call(void 0, 
+    raw => {
+      const networkAddress = _cleaners.asString.call(void 0, raw)
+      try {
+        // cashaddr
+        const address = networkAddress.replace('bitcoincash:', '')
+        const scriptPubkey = _keymanager.addressToScriptPubkey.call(void 0, {
+          address,
+          coin: 'bitcoincash'
+        })
+        return _keymanager.scriptPubkeyToAddress.call(void 0, {
+          scriptPubkey,
+          coin: 'bitcoinsv',
+          addressType: _keymanager.AddressTypeEnum.p2pkh
+        }).address
+      } catch (err) {
+        // 1address
+        return networkAddress
+      }
+    },
+    address => address
+  )
 }
 
  const coinInfo = {

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

@@ -2,8 +2,8 @@
 import { bip32 } from 'altcoin-js';
 import { Cleaner } from 'cleaners';
 import { Disklet } from 'disklet';
-import { EdgeCurrencyEngineOptions, EdgeCurrencyInfo, EdgeCurrencyTools, EdgeIo, EdgeParsedUri, EdgeTransaction, EdgeWalletInfo } from 'edge-core-js/types';
-import { IProcessorTransaction, IUTXO } from '../utxobased/db/types';
+import { EdgeCurrencyEngineOptions, EdgeCurrencyInfo, EdgeCurrencyTools, EdgeIo, EdgeParsedUri, EdgeWalletInfo } from 'edge-core-js/types';
+import { IUTXO } from '../utxobased/db/types';
 import { ScriptTemplates } from '../utxobased/info/scriptTemplates/types';
 import { UtxoPicker } from '../utxobased/keymanager/utxopicker';
 import { EngineEmitter } from './makeEngineEmitter';
@@ -41,7 +41,6 @@ export interface EngineInfo {
     simpleFeeSettings: SimpleFeeSettings;
     scriptTemplates?: ScriptTemplates;
     asBlockbookAddress?: Cleaner<string>;
-    validateConfirmations?: (txResponse: IProcessorTransaction, blockHeight: number, requiredConfirmations: number | undefined) => EdgeTransaction['confirmations'];
 }
 /**
  * Coin Info

package/lib/src/common/utxobased/db/Models/ProcessorTransaction.d.ts

@@ -1,5 +1,5 @@
 import { EdgeTransaction } from 'edge-core-js/types';
-import { PluginInfo } from '../../../plugin/types';
+import { EngineInfo } from '../../../plugin/types';
 import { UTXOPluginWalletTools } from '../../engine/makeUtxoWalletTools';
 import { Processor } from '../makeProcessor';
 import { IProcessorTransaction } from '../types';
@@ -7,10 +7,9 @@ export declare const fromEdgeTransaction: (tx: EdgeTransaction) => IProcessorTra
 interface ToEdgeTransactionArgs {
     tx: IProcessorTransaction;
     currencyCode: string;
-    pluginInfo: PluginInfo;
-    processor: Processor;
-    walletBlockHeight: number;
     walletTools: UTXOPluginWalletTools;
+    processor: Processor;
+    engineInfo: EngineInfo;
 }
 export declare const toEdgeTransaction: (args: ToEdgeTransactionArgs) => Promise<EdgeTransaction>;
 export {};

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

@@ -3,9 +3,11 @@ import { EngineEmitter } from '../../plugin/makeEngineEmitter';
 import { PluginState } from '../../plugin/pluginState';
 import { PluginInfo } from '../../plugin/types';
 import { NumbWalletInfo } from '../keymanager/cleaners';
+import { BlockBook } from '../network/BlockBook';
 import Deferred from '../network/Deferred';
 import { WsTask } from '../network/Socket';
 interface ServerState {
+    blockbook: BlockBook;
     blockSubscriptionStatus: 'unsubscribed' | 'subscribing' | 'subscribed';
     blockHeight: number;
     txids: Set<string>;
@@ -23,13 +25,13 @@ export interface ServerStates {
     stop: () => void;
     serverCanGetTx: (uri: string, txid: string) => boolean;
     serverCanGetAddress: (uri: string, address: string) => boolean;
-    serverScoreUp: (uri: string, score: number) => void;
+    serverIsAwareOfAddress: (uri: string, address: string) => boolean;
     getServerState: (uri: string) => ServerState | undefined;
     refillServers: () => void;
     getServerList: () => string[];
     setServerList: (updatedServerList: string[]) => void;
     broadcastTx: (transaction: EdgeTransaction) => Promise<string>;
-    watchAddresses: (uri: string, addresses: string[], deferredAddressSub: Deferred<unknown>) => void;
+    watchAddresses: (uri: string, addresses: string[], deferredAddressSub?: Deferred<unknown>) => void;
     watchBlocks: (uri: string) => void;
     getBlockHeight: (uri: string) => number;
 }

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

@@ -1,5 +1,6 @@
 import { EdgeFreshAddress, EdgeIo, EdgeLog, EdgeTransaction } from 'edge-core-js/types';
 import { EngineEmitter } from '../../plugin/makeEngineEmitter';
+import { PluginState } from '../../plugin/pluginState';
 import { ChangePath, CurrencyFormat, EngineConfig, PluginInfo } from '../../plugin/types';
 import { Processor } from '../db/makeProcessor';
 import { IAddress, IProcessorTransaction, IUTXO } from '../db/types';
@@ -38,18 +39,18 @@ interface CommonArgs {
     io: EdgeIo;
     log: EdgeLog;
     serverStates: ServerStates;
+    pluginState: PluginState;
     walletFormats: CurrencyFormat[];
     lock: AwaitLock;
 }
 interface TaskCache {
-    addressWatching: boolean;
     blockWatching: boolean;
-    addressSubscribeCache: AddressSubscribeCache;
-    addressUtxoCache: AddressUtxoCache;
-    rawUtxoCache: RawUtxoCache;
-    processorUtxoCache: ProcessorUtxoCache;
-    addressTransactionCache: AddressTransactionCache;
-    updateTransactionCache: UpdateTransactionCache;
+    readonly addressSubscribeCache: AddressSubscribeCache;
+    readonly addressUtxoCache: AddressUtxoCache;
+    readonly rawUtxoCache: RawUtxoCache;
+    readonly processorUtxoCache: ProcessorUtxoCache;
+    readonly addressTransactionCache: AddressTransactionCache;
+    readonly updateTransactionCache: UpdateTransactionCache;
 }
 interface UpdateTransactionCache {
     [key: string]: {
@@ -95,7 +96,6 @@ interface AddressTransactionCache {
 interface TransactionChangedArgs {
     tx: IProcessorTransaction;
     emitter: EngineEmitter;
-    walletBlockHeight: number;
     walletTools: UTXOPluginWalletTools;
     pluginInfo: PluginInfo;
     processor: Processor;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "edge-currency-plugins",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.2",
   "description": "Edge currency plugins to fetch and process wallet accounts, balances and transactions.",
-  "repository": "https://github.app/EdgeApp/edge-currency-plugins",
+  "repository": "https://github.com/EdgeApp/edge-currency-plugins",
   "license": "MIT",
   "author": "Airbitz, Inc.",
   "main": "./lib/index.js",

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

@@ -1,19 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
- const defaultValidateConfirmations = (
-  tx,
-  blockHeight,
-  requiredConfirmations = 1
-) => {
-  const blockConfirmations =
-    tx.blockHeight === 0 ? 0 : 1 + blockHeight - tx.blockHeight
-  const confirmations =
-    blockConfirmations >= requiredConfirmations
-      ? 'confirmed'
-      : blockConfirmations <= 0
-      ? 'unconfirmed'
-      : blockConfirmations
-  return confirmations
-}; exports.defaultValidateConfirmations = defaultValidateConfirmations

package/lib/src/common/utxobased/engine/util/defaultValidateConfirmations.d.ts

@@ -1,3 +0,0 @@
-import { EdgeTransaction } from 'edge-core-js';
-import { IProcessorTransaction } from '../../db/types';
-export declare const defaultValidateConfirmations: (tx: IProcessorTransaction, blockHeight: number, requiredConfirmations?: number) => EdgeTransaction['confirmations'];