edge-currency-plugins 3.2.0 → 3.3.0

package/lib/common/utxobased/engine/{UtxoEngineState.js → UtxoEngineProcessor.js}

@@ -16,10 +16,9 @@ var _EngineEmitter = require('../../plugin/EngineEmitter');
 
 
 
-
 var _utils = require('../../plugin/utils');
-var _ProcessorTransaction = require('../db/Models/ProcessorTransaction');
 
+var _TransactionData = require('../db/Models/TransactionData');
 
 
 
@@ -39,7 +38,6 @@ var _keymanager = require('../keymanager/keymanager');
 
 
 
-var _Deferred = require('../network/Deferred'); var _Deferred2 = _interopRequireDefault(_Deferred);
 
 var _awaitlock = require('./await-lock'); var _awaitlock2 = _interopRequireDefault(_awaitlock);
 var _constants = require('./constants');
@@ -87,7 +85,7 @@ var _utils3 = require('./utils');
 
 
 
- function makeUtxoEngineState(
+ function makeUtxoEngineProcessor(
   config
 ) {
   const {
@@ -96,7 +94,7 @@ var _utils3 = require('./utils');
     options,
     pluginState,
     pluginInfo,
-    processor,
+    dataLayer,
     walletInfo,
     walletTools
   } = config
@@ -105,38 +103,36 @@ var _utils3 = require('./utils');
   const { walletFormats } = walletInfo.keys
 
   const taskCache = {
-    blockWatching: false,
+    addressForTransactionsCache: {},
+    addressForUtxosCache: {},
     addressSubscribeCache: {},
-    addressTransactionCache: {},
-    addressUtxoCache: {},
-    rawUtxoCache: {},
-    processorUtxoCache: {},
-    updateTransactionCache: {},
-    updateTransactionSpecificCache: {}
+    blockbookUtxoCache: {},
+    dataLayerUtxoCache: {},
+    transactionSpecificUpdateCache: {},
+    transactionUpdateCache: {}
   }
 
   const clearTaskCache = () => {
-    taskCache.blockWatching = false
-    for (const key of Object.keys(taskCache.addressSubscribeCache)) {
-      _utils.removeItem.call(void 0, taskCache.addressSubscribeCache, key)
+    for (const key of Object.keys(taskCache.addressForTransactionsCache)) {
+      _utils.removeItem.call(void 0, taskCache.addressForTransactionsCache, key)
     }
-    for (const key of Object.keys(taskCache.addressTransactionCache)) {
-      _utils.removeItem.call(void 0, taskCache.addressTransactionCache, key)
+    for (const key of Object.keys(taskCache.addressForUtxosCache)) {
+      _utils.removeItem.call(void 0, taskCache.addressForUtxosCache, key)
     }
-    for (const key of Object.keys(taskCache.addressUtxoCache)) {
-      _utils.removeItem.call(void 0, taskCache.addressUtxoCache, key)
+    for (const key of Object.keys(taskCache.addressSubscribeCache)) {
+      _utils.removeItem.call(void 0, taskCache.addressSubscribeCache, key)
     }
-    for (const key of Object.keys(taskCache.rawUtxoCache)) {
-      _utils.removeItem.call(void 0, taskCache.rawUtxoCache, key)
+    for (const key of Object.keys(taskCache.blockbookUtxoCache)) {
+      _utils.removeItem.call(void 0, taskCache.blockbookUtxoCache, key)
     }
-    for (const key of Object.keys(taskCache.processorUtxoCache)) {
-      _utils.removeItem.call(void 0, taskCache.processorUtxoCache, key)
+    for (const key of Object.keys(taskCache.dataLayerUtxoCache)) {
+      _utils.removeItem.call(void 0, taskCache.dataLayerUtxoCache, key)
     }
-    for (const key of Object.keys(taskCache.updateTransactionCache)) {
-      _utils.removeItem.call(void 0, taskCache.updateTransactionCache, key)
+    for (const key of Object.keys(taskCache.transactionSpecificUpdateCache)) {
+      _utils.removeItem.call(void 0, taskCache.transactionSpecificUpdateCache, key)
     }
-    for (const key of Object.keys(taskCache.updateTransactionSpecificCache)) {
-      _utils.removeItem.call(void 0, taskCache.updateTransactionSpecificCache, key)
+    for (const key of Object.keys(taskCache.transactionUpdateCache)) {
+      _utils.removeItem.call(void 0, taskCache.transactionUpdateCache, key)
     }
   }
 
@@ -184,24 +180,23 @@ var _utils3 = require('./utils');
     pluginState,
     walletInfo
   })
-  const commonArgs = {
+  const common = {
     pluginInfo,
     walletInfo,
     walletTools,
-    processor,
+    dataLayer,
     emitter,
     taskCache,
     updateProgressRatio,
     io,
     log,
     serverStates,
-    pluginState,
     walletFormats,
     lock
   }
 
-  serverStates.setPickNextTaskCB(async serverUri => {
-    return await exports.pickNextTask.call(void 0, commonArgs, serverUri)
+  serverStates.setPickNextTaskCB(serverUri => {
+    return pickNextTask(common, serverUri)
   })
 
   let running = false
@@ -210,18 +205,18 @@ var _utils3 = require('./utils');
     running = true
 
     await initializeAddressSubscriptions()
-    await setLookAhead(commonArgs)
+    await setLookAhead(common)
   }
 
   emitter.on(
     _EngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
     async (_uri, _blockHeight) => {
-      const txs = await processor.fetchTransactions({
+      const txs = await dataLayer.fetchTransactions({
         blockHeight: 0
       })
       for (const tx of txs) {
         if (tx == null) continue
-        taskCache.updateTransactionCache[tx.txid] = { processing: false }
+        taskCache.transactionUpdateCache[tx.txid] = { processing: false }
       }
     }
   )
@@ -232,20 +227,19 @@ var _utils3 = require('./utils');
       const state = taskCache.addressSubscribeCache[response.address]
       if (state != null) {
         const { path } = state
-        taskCache.addressUtxoCache[response.address] = {
+        taskCache.addressForUtxosCache[response.address] = {
           processing: false,
           path
         }
-        addToAddressTransactionCache(
-          commonArgs,
-          response.address,
-          path,
-          0,
-          taskCache.addressTransactionCache
-        ).catch(() => {
+        addToAddressForTransactionsCache(common, {
+          address: response.address,
+          changePath: path,
+          blockHeight: 0,
+          addressForTransactionsCache: taskCache.addressForTransactionsCache
+        }).catch(() => {
           throw new Error('failed to add to transaction cache')
         })
-        setLookAhead(commonArgs).catch(e => {
+        setLookAhead(common).catch(e => {
           log(e)
         })
       }
@@ -253,7 +247,7 @@ var _utils3 = require('./utils');
   )
 
   // Initialize the addressSubscribeCache with the existing addresses already
-  // processed by the processor. This happens only once before any call to
+  // processed by the DataLayer. This happens only once before any call to
   // setLookAhead.
   const initializeAddressSubscriptions = async () => {
     const addressBalanceChanges
@@ -269,10 +263,10 @@ var _utils3 = require('./utils');
           format,
           changeIndex: branch
         }
-        const branchAddressCount = processor.numAddressesByFormatPath(
+        const branchAddressCount = dataLayer.numAddressesByFormatPath(
           changePath
         )
-        // If the processor has not processed any addresses then the loop
+        // If the DataLayer 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.
         for (
@@ -280,29 +274,29 @@ var _utils3 = require('./utils');
           addressIndex < branchAddressCount;
           addressIndex++
         ) {
-          const processorAddress = await processor.fetchAddress({
+          const addressData = await dataLayer.fetchAddress({
             format,
             changeIndex: branch,
             addressIndex
           })
-          if (processorAddress == null) {
+          if (addressData == null) {
             throw new Error(
-              `Missing processor address ${format} ${branch} ${addressIndex} during initialization`
+              `Missing data-layer address with '${format}/${branch}/${addressIndex}' path during initialization`
             )
           }
           const { address } = walletTools.scriptPubkeyToAddress({
             changePath,
-            scriptPubkey: processorAddress.scriptPubkey
+            scriptPubkey: addressData.scriptPubkey
           })
           addressesToSubscribe.add(address)
-          if (processorAddress.balance != null) {
+          if (addressData.balance != null) {
             addressBalanceChanges.push({
-              scriptPubkey: processorAddress.scriptPubkey,
-              balance: processorAddress.balance
+              scriptPubkey: addressData.scriptPubkey,
+              balance: addressData.balance
             })
           }
         }
-        addToAddressSubscribeCache(commonArgs.taskCache, addressesToSubscribe, {
+        addToAddressSubscribeCache(common.taskCache, addressesToSubscribe, {
           format,
           changeIndex: branch
         })
@@ -348,11 +342,12 @@ var _utils3 = require('./utils');
         address: publicAddress,
         nativeBalance = '0',
         legacyAddress
-      } = await internalGetFreshAddress({
-        ...commonArgs,
-        format: privateKeyFormat,
+      } = await internalGetFreshAddress(common, {
         forceIndex,
-        changeIndex: branch
+        changePath: {
+          format: privateKeyFormat,
+          changeIndex: branch
+        }
       })
 
       const freshAddress = {
@@ -378,11 +373,12 @@ var _utils3 = require('./utils');
           const {
             address,
             nativeBalance = '0'
-          } = await internalGetFreshAddress({
-            ...commonArgs,
-            format,
+          } = await internalGetFreshAddress(common, {
             forceIndex,
-            changeIndex: branch
+            changePath: {
+              format,
+              changeIndex: branch
+            }
           })
 
           freshAddress.segwitAddress = address
@@ -395,10 +391,10 @@ var _utils3 = require('./utils');
 
     async deriveScriptAddress(script) {
       const { address } = await internalDeriveScriptAddress({
-        walletTools: commonArgs.walletTools,
-        engineInfo: commonArgs.pluginInfo.engineInfo,
-        processor: commonArgs.processor,
-        taskCache: commonArgs.taskCache,
+        walletTools: common.walletTools,
+        engineInfo: common.pluginInfo.engineInfo,
+        dataLayer: common.dataLayer,
+        taskCache: common.taskCache,
         format: walletInfo.keys.privateKeyFormat,
         script
       })
@@ -410,8 +406,8 @@ var _utils3 = require('./utils');
     async addGapLimitAddresses(addresses) {
       const promises = addresses.map(async address => {
         const scriptPubkey = walletTools.addressToScriptPubkey(address)
-        await processor.saveAddress(
-          _types5.makeIAddress.call(void 0, {
+        await dataLayer.saveAddress(
+          _types5.makeAddressData.call(void 0, {
             scriptPubkey,
             used: true
           })
@@ -457,8 +453,8 @@ var _utils3 = require('./utils');
           })
 
           // Make a new IAddress and save it
-          await processor.saveAddress(
-            _types5.makeIAddress.call(void 0, { scriptPubkey, redeemScript, path })
+          await dataLayer.saveAddress(
+            _types5.makeAddressData.call(void 0, { scriptPubkey, redeemScript, path })
           )
 
           taskCache.addressSubscribeCache[address] = {
@@ -469,7 +465,6 @@ var _utils3 = require('./utils');
       }
     },
     async processUtxos(utxos) {
-      // Map of scriptPubkey to IUTXOs
       const utxoMap = new Map()
       const utxoIds = new Set()
 
@@ -487,7 +482,7 @@ var _utils3 = require('./utils');
       // Process UTXO sets for each scriptPubkey in map
       for (const [scriptPubkey, utxos] of utxoMap.entries()) {
         // Get saved utxo set
-        const savedUtxos = await processor.fetchUtxos({ scriptPubkey })
+        const savedUtxos = await dataLayer.fetchUtxos({ scriptPubkey })
         // Filter UTXOs to de-duplicate (and undefined utxo as a type assert)
         const filteredUtxos = savedUtxos.filter(
           utxo => utxo != null && !utxoIds.has(_optionalChain([utxo, 'optionalAccess', _ => _.id]))
@@ -496,15 +491,62 @@ var _utils3 = require('./utils');
         // Add updated utxos to utxo set
         const combinedUtxos = [...filteredUtxos, ...utxos]
 
-        await processProcessorUtxos({
-          ...commonArgs,
+        await processDataLayerUtxos(common, {
           scriptPubkey,
           utxos: combinedUtxos
         })
       }
     }
   }
-} exports.makeUtxoEngineState = makeUtxoEngineState;
+} exports.makeUtxoEngineProcessor = makeUtxoEngineProcessor;
+
+const internalDeriveScriptAddress = async (args
+
+
+
+
+
+
+
+
+
+
+) => {
+  const { walletTools, engineInfo, dataLayer, format, taskCache, script } = args
+  if (engineInfo.scriptTemplates == null) {
+    throw new Error(
+      `cannot derive script address ${script} without defined script template`
+    )
+  }
+
+  const scriptTemplate = engineInfo.scriptTemplates[script]
+
+  const path = {
+    format,
+    changeIndex: _keymanager.derivationLevelScriptHash.call(void 0, scriptTemplate),
+    addressIndex: 0
+  }
+
+  // save the address to the dataLayer and add it to the cache
+  const { address, scriptPubkey, redeemScript } = walletTools.getScriptAddress({
+    path,
+    scriptTemplate
+  })
+  await dataLayer.saveAddress(
+    _types5.makeAddressData.call(void 0, { scriptPubkey, redeemScript, path })
+  )
+  const addresses = new Set()
+  addresses.add(address)
+  addToAddressSubscribeCache(taskCache, addresses, {
+    format: path.format,
+    changeIndex: path.changeIndex
+  })
+  return { address, scriptPubkey, redeemScript }
+}
+
+const internalGetFreshAddress = async (
+  common,
+  args
 
 
 
@@ -512,9 +554,42 @@ var _utils3 = require('./utils');
 
 
 
+) => {
+  const { changePath, forceIndex } = args
 
+  const numAddresses = common.dataLayer.numAddressesByFormatPath(changePath)
 
+  const path = {
+    format: changePath.format,
+    changeIndex: changePath.changeIndex,
+    // while syncing, we may hit negative numbers when only subtracting. Use the address at /0 in that case.
+    addressIndex: Math.max(
+      numAddresses - common.pluginInfo.engineInfo.gapLimit,
+      0
+    )
+  }
+  if (forceIndex != null) {
+    path.addressIndex = forceIndex
+  }
 
+  const iAddress = await common.dataLayer.fetchAddress(path)
+  const nativeBalance = _nullishCoalesce(_optionalChain([iAddress, 'optionalAccess', _2 => _2.balance]), () => ( '0'))
+  const { scriptPubkey } =
+    await _asyncNullishCoalesce(iAddress, async () => ( (await common.walletTools.getScriptPubkey(path))))
+
+  if (scriptPubkey == null) {
+    throw new Error('Unknown address path')
+  }
+  const address = common.walletTools.scriptPubkeyToAddress({
+    changePath: path,
+    scriptPubkey
+  })
+
+  return {
+    ...address,
+    nativeBalance
+  }
+}
 
 
 
@@ -573,37 +648,41 @@ var _utils3 = require('./utils');
 
 
 
-const setLookAhead = async (common) => {
-  const {
-    pluginInfo: { engineInfo },
-    lock,
-    processor,
-    walletFormats,
-    walletTools
-  } = common
 
+
+
+
+
+const setLookAhead = async (common) => {
   // Wait for the lock to be released before continuing invocation.
   // This is to ensure that setLockAhead is not called while the lock is held.
-  await lock.acquireAsync()
+  await common.lock.acquireAsync()
 
   try {
-    for (const format of walletFormats) {
-      const branches = _utils3.getFormatSupportedBranches.call(void 0, engineInfo, format)
+    for (const format of common.walletFormats) {
+      const branches = _utils3.getFormatSupportedBranches.call(void 0, 
+        common.pluginInfo.engineInfo,
+        format
+      )
       for (const branch of branches) {
         await deriveKeys({ format, changeIndex: branch })
       }
     }
   } finally {
-    lock.release()
+    common.lock.release()
   }
 
   async function deriveKeys(changePath) {
     const addressesToSubscribe = new Set()
-    const totalAddressCount = processor.numAddressesByFormatPath(changePath)
-    let lastUsedIndex = await processor.lastUsedIndexByFormatPath(changePath)
+    const totalAddressCount = common.dataLayer.numAddressesByFormatPath(
+      changePath
+    )
+    let lastUsedIndex = await common.dataLayer.lastUsedIndexByFormatPath(
+      changePath
+    )
 
     // Loop until the total address count equals the lookahead count
-    let lookAheadIndex = lastUsedIndex + engineInfo.gapLimit
+    let lookAheadIndex = lastUsedIndex + common.pluginInfo.engineInfo.gapLimit
     let nextAddressIndex = totalAddressCount
     while (nextAddressIndex <= lookAheadIndex) {
       const path = {
@@ -611,24 +690,28 @@ const setLookAhead = async (common) => {
         addressIndex: nextAddressIndex
       }
 
-      const { scriptPubkey, redeemScript } = walletTools.getScriptPubkey(path)
-      const { address } = walletTools.scriptPubkeyToAddress({
+      const { scriptPubkey, redeemScript } = common.walletTools.getScriptPubkey(
+        path
+      )
+      const { address } = common.walletTools.scriptPubkeyToAddress({
         changePath: path,
         scriptPubkey
       })
 
       // Make a new IAddress and save it
-      await processor.saveAddress(
-        _types5.makeIAddress.call(void 0, { scriptPubkey, redeemScript, path })
+      await common.dataLayer.saveAddress(
+        _types5.makeAddressData.call(void 0, { scriptPubkey, redeemScript, path })
       )
 
       // Add the displayAddress to the set of addresses to subscribe to after loop
       addressesToSubscribe.add(address)
 
       // Update the state for the loop
-      lastUsedIndex = await processor.lastUsedIndexByFormatPath(changePath)
-      lookAheadIndex = lastUsedIndex + engineInfo.gapLimit
-      nextAddressIndex = processor.numAddressesByFormatPath(changePath)
+      lastUsedIndex = await common.dataLayer.lastUsedIndexByFormatPath(
+        changePath
+      )
+      lookAheadIndex = lastUsedIndex + common.pluginInfo.engineInfo.gapLimit
+      nextAddressIndex = common.dataLayer.numAddressesByFormatPath(changePath)
     }
 
     // Add all the addresses to the subscribe cache for registering subscriptions later
@@ -653,24 +736,27 @@ const addToAddressSubscribeCache = (
   })
 }
 
-const addToAddressTransactionCache = async (
+const addToAddressForTransactionsCache = async (
   common,
-  address,
-  changePath,
-  blockHeight,
-  addressTransactionCache
+  args
+
+
+
+
+
 ) => {
-  const { walletTools, processor } = common
+  const { address, changePath, addressForTransactionsCache } = args
+  let { blockHeight } = args
   // Fetch the blockHeight for the address from the database
-  const scriptPubkey = walletTools.addressToScriptPubkey(address)
+  const scriptPubkey = common.walletTools.addressToScriptPubkey(address)
 
   if (blockHeight === 0) {
     const { lastQueriedBlockHeight = 0 } =
-      await _asyncNullishCoalesce((await processor.fetchAddress(scriptPubkey)), async () => ( {}))
+      await _asyncNullishCoalesce((await common.dataLayer.fetchAddress(scriptPubkey)), async () => ( {}))
     blockHeight = lastQueriedBlockHeight
   }
 
-  addressTransactionCache[address] = {
+  addressForTransactionsCache[address] = {
     processing: false,
     path: changePath,
     page: 1, // Page starts on 1
@@ -678,88 +764,96 @@ const addToAddressTransactionCache = async (
   }
 }
 
+ const transactionChanged = async (args
 
 
 
 
 
 
-
-
-
- const transactionChanged = async (
-  args
 ) => {
-  const { emitter, walletTools, processor, pluginInfo, tx, walletId } = args
+  const { dataLayer, emitter, pluginInfo, tx, walletTools, walletId } = args
   emitter.emit(_EngineEmitter.EngineEvent.TRANSACTIONS_CHANGED, [
-    await _ProcessorTransaction.toEdgeTransaction.call(void 0, {
+    await _TransactionData.toEdgeTransaction.call(void 0, {
       walletId,
       tx,
       walletTools,
-      processor,
+      dataLayer,
       pluginInfo
     })
   ])
 }; exports.transactionChanged = transactionChanged
 
- const pickNextTask = async (
-  args,
-  serverUri
-) => {
-  const { pluginInfo, taskCache, serverStates } = args
+/**
+ * Some currencies require an additional blockbook payload 'getTransactionSpecific' in order
+ * to provide all relevant transaction data. Since this is currency-specific, we can limit
+ * the usage to currencies that require it.
+ **/
+const needsTxSpecific = (common) => {
+  return common.pluginInfo.engineInfo.txSpecificHandling != null
+}
+
+/**
+ * The pickNextTask generator is responsible for selecting the next WsTask
+ * to be done by the network layer. It will yield WsTasks or booleans for early
+ * exit, and it will return a boolean when it's done.
+ */
+
+
+
 
+
+
+
+ async function* pickNextTask(
+  common,
+  serverUri
+) {
   const {
+    addressForTransactionsCache,
+    addressForUtxosCache,
     addressSubscribeCache,
-    addressUtxoCache,
-    rawUtxoCache,
-    processorUtxoCache,
-    addressTransactionCache,
-    updateTransactionCache,
-    updateTransactionSpecificCache
-  } = taskCache
+    blockbookUtxoCache,
+    dataLayerUtxoCache,
+    transactionSpecificUpdateCache,
+    transactionUpdateCache
+  } = common.taskCache
 
-  /**
-   * Some currencies require an additional blockbook payload 'getTransactionSpecific' in order
-   * to provide all relevant transaction data. Since this is currency-specific, we can limit
-   * the useage to currencies that require it.
-   **/
-  const needsTxSpecific = pluginInfo.engineInfo.txSpecificHandling != null
-
-  const serverState = serverStates.getServerState(serverUri)
-  if (serverState == null) return
+  const serverState = common.serverStates.getServerState(serverUri)
+  if (serverState == null) return false
 
   // subscribe all servers to new blocks
   if (serverState.blockSubscriptionStatus === 'unsubscribed') {
-    serverStates.watchBlocks(serverUri)
+    common.serverStates.watchBlocks(serverUri)
     return true
   }
 
   // Loop processed utxos, these are just database ops, triggers setLookAhead
-  if (Object.keys(processorUtxoCache).length > 0) {
-    for (const [scriptPubkey, state] of Object.entries(processorUtxoCache)) {
+  if (Object.keys(dataLayerUtxoCache).length > 0) {
+    for (const [scriptPubkey, cacheItem] of Object.entries(
+      dataLayerUtxoCache
+    )) {
       // Only process when all utxos for a specific address have been gathered
-      if (!state.processing && state.full) {
-        state.processing = true
-        await processProcessorUtxos({
-          ...args,
+      if (!cacheItem.processing && cacheItem.full) {
+        cacheItem.processing = true
+        await processDataLayerUtxos(common, {
           scriptPubkey,
-          utxos: state.utxos
+          utxos: cacheItem.utxos
         })
-        _utils.removeItem.call(void 0, processorUtxoCache, scriptPubkey)
+        _utils.removeItem.call(void 0, dataLayerUtxoCache, scriptPubkey)
         return true
       }
     }
   }
 
   // Loop unparsed utxos, some require a network call to get the full tx data
-  for (const [utxoId, state] of Object.entries(rawUtxoCache)) {
-    const utxo = state.blockbookUtxo
-    if (utxo == null) continue
-    if (!state.processing) {
+  for (const [utxoId, cacheItem] of Object.entries(blockbookUtxoCache)) {
+    const utxo = cacheItem.blockbookUtxo
+    if (!cacheItem.processing) {
       // check if we need to fetch additional network content for legacy purpose type
       const purposeType = _utils3.pathToPurposeType.call(void 0, 
-        state.path,
-        pluginInfo.engineInfo.scriptTemplates
+        cacheItem.path,
+        common.pluginInfo.engineInfo.scriptTemplates
       )
       if (
         purposeType === _keymanager.BIP43PurposeTypeEnum.Airbitz ||
@@ -767,50 +861,36 @@ const addToAddressTransactionCache = async (
         purposeType === _keymanager.BIP43PurposeTypeEnum.ReplayProtection
       ) {
         // if we do need to make a network call, check with the serverState
-        if (!serverStates.serverCanGetTx(serverUri, utxo.txid)) return
+        if (!common.serverStates.serverCanGetTx(serverUri, utxo.txid))
+          return false
       }
-      state.processing = true
-      _utils.removeItem.call(void 0, rawUtxoCache, utxoId)
-      const wsTask = await processRawUtxo({
-        ...args,
-        ...state,
-        address: state.address,
+      cacheItem.processing = true
+      _utils.removeItem.call(void 0, blockbookUtxoCache, utxoId)
+      yield* processBlockbookUtxo(common, {
         serverUri,
-        utxo,
-        id: `${utxo.txid}_${utxo.vout}`
+        cacheItem
       })
-      return _nullishCoalesce(wsTask, () => ( true))
     }
   }
 
   // Loop to process addresses to utxos
-  for (const [address, state] of Object.entries(addressUtxoCache)) {
+  for (const [address, cacheItem] of Object.entries(addressForUtxosCache)) {
     // Check if we need to fetch address UTXOs
     if (
-      !state.processing &&
-      serverStates.serverCanGetAddress(serverUri, address)
+      !cacheItem.processing &&
+      common.serverStates.serverCanGetAddress(serverUri, address)
     ) {
-      state.processing = true
+      cacheItem.processing = true
 
-      _utils.removeItem.call(void 0, addressUtxoCache, address)
+      _utils.removeItem.call(void 0, addressForUtxosCache, address)
 
-      // Fetch and process address UTXOs
-      const wsTask = await processAddressUtxos({
-        ...args,
-        ...state,
+      // Fetch and process address for UTXOs
+      yield* processAddressForUtxos(common, {
         address,
+        cacheItem,
+        serverState,
         serverUri
       })
-      wsTask.deferred.promise
-        .then(() => {
-          serverState.addresses.add(address)
-        })
-        .catch(err => {
-          addressUtxoCache[address] = state
-          console.error(err)
-          args.log('error in addressUtxoCache:', err)
-        })
-      return wsTask
     }
   }
 
@@ -818,11 +898,11 @@ const addToAddressTransactionCache = async (
   if (Object.keys(addressSubscribeCache).length > 0) {
     // These are addresses to which the server has not subscribed
     const newAddresses = []
-    const blockHeight = serverStates.getBlockHeight(serverUri)
+    const blockHeight = common.serverStates.getBlockHeight(serverUri)
 
     // Loop each address in the cache
-    for (const [address, state] of Object.entries(addressSubscribeCache)) {
-      const isAddressNewlySubscribed = !serverStates.serverIsAwareOfAddress(
+    for (const [address, cacheItem] of Object.entries(addressSubscribeCache)) {
+      const isAddressNewlySubscribed = !common.serverStates.serverIsAwareOfAddress(
         serverUri,
         address
       )
@@ -832,61 +912,52 @@ const addToAddressTransactionCache = async (
         newAddresses.push(address)
       }
 
-      // Add to the addressTransactionCache if they're not yet added:
+      // Add to the addressForTransactionsCache if they're not yet added:
       // Only process newly watched addresses
-      if (state.processing) continue
+      if (cacheItem.processing) continue
 
       // Add the newly watched addresses to the UTXO cache
       if (isAddressNewlySubscribed) {
-        addressUtxoCache[address] = {
+        addressForUtxosCache[address] = {
           processing: false,
-          path: state.path
+          path: cacheItem.path
         }
       }
 
-      await addToAddressTransactionCache(
-        args,
+      await addToAddressForTransactionsCache(common, {
         address,
-        state.path,
+        changePath: cacheItem.path,
         blockHeight,
-        addressTransactionCache
-      )
-      state.processing = true
+        addressForTransactionsCache
+      })
+      cacheItem.processing = true
     }
 
     // Subscribe to any new addresses
     if (newAddresses.length > 0) {
-      serverStates.watchAddresses(serverUri, newAddresses)
+      common.serverStates.watchAddresses(serverUri, newAddresses)
       return true
     }
   }
 
   // filled when transactions potentially changed (e.g. through new block notification)
-  if (Object.keys(updateTransactionSpecificCache).length > 0) {
+  if (Object.keys(transactionSpecificUpdateCache).length > 0) {
     let hasProcessedAtLeastOnce = false
-    for (const [txId, state] of Object.entries(
-      updateTransactionSpecificCache
+    for (const [txId, cacheItem] of Object.entries(
+      transactionSpecificUpdateCache
     )) {
-      if (!state.processing && serverStates.serverCanGetTx(serverUri, txId)) {
+      if (
+        !cacheItem.processing &&
+        common.serverStates.serverCanGetTx(serverUri, txId)
+      ) {
         hasProcessedAtLeastOnce = true
-        state.processing = true
-        _utils.removeItem.call(void 0, updateTransactionSpecificCache, txId)
-        const updateTransactionSpecificTask = updateTransactionsSpecific({
-          ...args,
+        cacheItem.processing = true
+        _utils.removeItem.call(void 0, transactionSpecificUpdateCache, txId)
+        yield* processTransactionsSpecificUpdate(common, {
+          serverState,
           serverUri,
           txId
         })
-        // once resolved, add the txid to the server cache
-        updateTransactionSpecificTask.deferred.promise
-          .then(() => {
-            serverState.txids.add(txId)
-          })
-          .catch(err => {
-            updateTransactionSpecificCache[txId] = state
-            console.error(err)
-            args.log('error in updateTransactionSpecificCache:', err)
-          })
-        return updateTransactionSpecificTask
       }
     }
     // This condition prevents infinite loops
@@ -894,30 +965,21 @@ const addToAddressTransactionCache = async (
   }
 
   // filled when transactions potentially changed (e.g. through new block notification)
-  if (Object.keys(updateTransactionCache).length > 0) {
+  if (Object.keys(transactionUpdateCache).length > 0) {
     let hasProcessedAtLeastOnce = false
-    for (const [txId, state] of Object.entries(updateTransactionCache)) {
-      if (!state.processing && serverStates.serverCanGetTx(serverUri, txId)) {
+    for (const [txId, cacheItem] of Object.entries(transactionUpdateCache)) {
+      if (
+        !cacheItem.processing &&
+        common.serverStates.serverCanGetTx(serverUri, txId)
+      ) {
         hasProcessedAtLeastOnce = true
-        state.processing = true
-        _utils.removeItem.call(void 0, updateTransactionCache, txId)
-        const updateTransactionTask = updateTransactions({
-          ...args,
+        cacheItem.processing = true
+        _utils.removeItem.call(void 0, transactionUpdateCache, txId)
+        yield* processTransactionUpdate(common, {
+          serverState,
           serverUri,
-          needsTxSpecific,
           txId
         })
-        // once resolved, add the txid to the server cache
-        updateTransactionTask.deferred.promise
-          .then(() => {
-            serverState.txids.add(txId)
-          })
-          .catch(err => {
-            updateTransactionCache[txId] = state
-            console.error(err)
-            args.log('error in updateTransactionCache:', err)
-          })
-        return updateTransactionTask
       }
     }
     // This condition prevents infinite loops
@@ -925,399 +987,276 @@ const addToAddressTransactionCache = async (
   }
 
   // loop to get and process transaction history of single addresses, triggers setLookAhead
-  for (const [address, state] of Object.entries(addressTransactionCache)) {
+  for (const [address, cacheItem] of Object.entries(
+    addressForTransactionsCache
+  )) {
     if (
-      !state.processing &&
-      serverStates.serverCanGetAddress(serverUri, address)
+      !cacheItem.processing &&
+      common.serverStates.serverCanGetAddress(serverUri, address)
     ) {
-      state.processing = true
+      cacheItem.processing = true
 
-      _utils.removeItem.call(void 0, addressTransactionCache, address)
+      _utils.removeItem.call(void 0, addressForTransactionsCache, address)
 
       // Fetch and process address UTXOs
-      const wsTask = await processAddressTransactions({
-        ...args,
-        addressTransactionState: state,
+      yield* processAddressForTransactions(common, {
         address,
-        needsTxSpecific,
+        cacheItem,
+        serverState,
         serverUri
       })
-      wsTask.deferred.promise
-        .then(() => {
-          serverState.addresses.add(address)
-        })
-        .catch(err => {
-          addressTransactionCache[address] = state
-          console.error(err)
-          args.log('error in updateTransactionCache:', err)
-        })
-      return wsTask
     }
   }
-}; exports.pickNextTask = pickNextTask
-
-
 
+  // Nothing to do
+  return false
+} exports.pickNextTask = pickNextTask;
 
-
-
-const updateTransactionsSpecific = (
+/**
+ * Process a transaction specific update from the TransactionSpecificUpdateCache
+ * by querying the network for the transaction data using the specific handling
+ * query and processing the data into the DataLayer.
+ */
+async function* processTransactionsSpecificUpdate(
+  common,
   args
-) => {
-  const {
-    walletInfo,
-    emitter,
-    walletTools,
-    pluginInfo,
-    processor,
-    serverUri,
-    txId,
-    taskCache
-  } = args
-  const deferred = new _Deferred2.default()
-  deferred.promise
-    .then(async (txResponse) => {
-      // Grab tx to update it
-      const txs = await processor.fetchTransactions({ txId })
-      let tx = txs[0]
-      if (tx == null) return
-
-      if (pluginInfo.engineInfo.txSpecificHandling != null) {
-        // Do coin-specific things to it
-        tx = pluginInfo.engineInfo.txSpecificHandling(tx, txResponse)
-      }
-
-      // Process and save new tx
-      const processedTx = await processor.saveTransaction({
-        tx
-      })
-
-      await exports.transactionChanged.call(void 0, {
-        walletId: walletInfo.id,
-        emitter,
-        walletTools,
-        processor,
-        pluginInfo,
-        tx: processedTx
-      })
-    })
-    .catch(err => {
-      console.error(err)
-      args.log('error in updateTransactionsSpecific:', err)
-      taskCache.updateTransactionSpecificCache[txId] = { processing: false }
-    })
-
-  return args.serverStates.transactionSpecialQueryTask(
-    serverUri,
-    txId,
-    deferred
-  )
-}
-
 
 
 
 
+) {
+  const { serverState, serverUri, txId } = args
+  try {
+    const txResponse = yield* common.serverStates.transactionSpecialQueryTask(
+      serverUri,
+      txId
+    )
+    // Grab tx to update it
+    const txs = await common.dataLayer.fetchTransactions({ txId })
+    let tx = txs[0]
+    if (tx == null) return true
+
+    if (common.pluginInfo.engineInfo.txSpecificHandling != null) {
+      // Do coin-specific things to it
+      tx = common.pluginInfo.engineInfo.txSpecificHandling(tx, txResponse)
+    }
 
-
-const updateTransactions = (
-  args
-) => {
-  const {
-    walletInfo,
-    emitter,
-    walletTools,
-    txId,
-    needsTxSpecific,
-    pluginInfo,
-    processor,
-    serverUri,
-    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 })
-      // Remove any existing input utxos from the processor
-      for (const input of tx.inputs) {
-        await processor.removeUtxos([`${input.txId}_${input.outputIndex}`])
-      }
-      // Update output utxos's blockHeight any existing input utxos from the processor
-      const utxoIds = tx.outputs.map(output => `${tx.txid}_${output.n}`)
-      const utxos = await processor.fetchUtxos({
-        utxoIds
-      })
-      for (const utxo of utxos) {
-        if (utxo == null) continue
-        utxo.blockHeight = tx.blockHeight
-        await processor.saveUtxo(utxo)
-      }
-      // Process and save new tx
-      const processedTx = await processor.saveTransaction({
-        tx
-      })
-
-      await exports.transactionChanged.call(void 0, {
-        walletId: walletInfo.id,
-        emitter,
-        walletTools,
-        processor,
-        pluginInfo,
-        tx: processedTx
-      })
-
-      if (needsTxSpecific) {
-        // Add task to grab transactionSpecific payload
-        taskCache.updateTransactionSpecificCache[txId] = {
-          processing: false
-        }
-      }
-    })
-    .catch(err => {
-      console.error(err)
-      args.log('error in updateTransactions:', err)
-      taskCache.updateTransactionCache[txId] = { processing: false }
+    // Process and save new tx
+    const processedTx = await common.dataLayer.saveTransaction({
+      tx
     })
 
-  return args.serverStates.transactionQueryTask(serverUri, txId, deferred)
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-const internalDeriveScriptAddress = async ({
-  walletTools,
-  engineInfo,
-  processor,
-  format,
-  taskCache,
-  script
-}) => {
-  if (engineInfo.scriptTemplates == null) {
-    throw new Error(
-      `cannot derive script address ${script} without defined script template`
-    )
-  }
+    await exports.transactionChanged.call(void 0, {
+      walletId: common.walletInfo.id,
+      emitter: common.emitter,
+      walletTools: common.walletTools,
+      dataLayer: common.dataLayer,
+      pluginInfo: common.pluginInfo,
+      tx: processedTx
+    })
 
-  const scriptTemplate = engineInfo.scriptTemplates[script]
+    // Add the txid to the server cache
+    serverState.txids.add(txId)
 
-  const path = {
-    format,
-    changeIndex: _keymanager.derivationLevelScriptHash.call(void 0, scriptTemplate),
-    addressIndex: 0
+    return true
+  } catch (err) {
+    console.error(err)
+    common.log('error while processing transaction specific update:', err)
+    common.taskCache.transactionSpecificUpdateCache[txId] = {
+      processing: false
+    }
+    return false
   }
-
-  // save the address to the processor and add it to the cache
-  const { address, scriptPubkey, redeemScript } = walletTools.getScriptAddress({
-    path,
-    scriptTemplate
-  })
-  await processor.saveAddress(
-    _types5.makeIAddress.call(void 0, { scriptPubkey, redeemScript, path })
-  )
-  const addresses = new Set()
-  addresses.add(address)
-  addToAddressSubscribeCache(taskCache, addresses, {
-    format: path.format,
-    changeIndex: path.changeIndex
-  })
-  return { address, scriptPubkey, redeemScript }
 }
 
+/**
+ * Processes a transaction update from the TransactionUpdateCache by querying
+ * the network for the transaction data and processing it into the DataLayer.
+ */
+async function* processTransactionUpdate(
+  common,
+  args
 
 
 
 
+) {
+  const { serverState, serverUri, txId } = args
 
-
-
-
-
-
-const internalGetFreshAddress = async (
-  args
-) => {
-  const {
-    format,
-    changeIndex: branch,
-    walletTools,
-    processor,
-    forceIndex
-  } = args
-
-  const numAddresses = processor.numAddressesByFormatPath({
-    format,
-    changeIndex: branch
-  })
-
-  const path = {
-    format,
-    changeIndex: branch,
-    // while syncing, we may hit negative numbers when only subtracting. Use the address at /0 in that case.
-    addressIndex: Math.max(
-      numAddresses - args.pluginInfo.engineInfo.gapLimit,
-      0
+  try {
+    const txResponse = yield* common.serverStates.transactionQueryTask(
+      serverUri,
+      txId
     )
-  }
-  if (forceIndex != null) {
-    path.addressIndex = forceIndex
-  }
+    // check if blockbook tx is still not confirmed, if so, don't change anything
+    if (txResponse.blockHeight < 1) return false
+    // Create new tx from raw tx
+    const tx = processTransactionResponse(common, { txResponse })
+    // Remove any existing input utxos from the dataLayer
+    for (const input of tx.inputs) {
+      await common.dataLayer.removeUtxos([`${input.txId}_${input.outputIndex}`])
+    }
+    // Update output utxos's blockHeight any existing input utxos from the dataLayer
+    const utxoIds = tx.outputs.map(output => `${tx.txid}_${output.n}`)
+    const utxos = await common.dataLayer.fetchUtxos({
+      utxoIds
+    })
+    for (const utxo of utxos) {
+      if (utxo == null) continue
+      utxo.blockHeight = tx.blockHeight
+      await common.dataLayer.saveUtxo(utxo)
+    }
+    // Process and save new tx
+    const processedTx = await common.dataLayer.saveTransaction({
+      tx
+    })
 
-  const iAddress = await processor.fetchAddress(path)
-  const nativeBalance = _nullishCoalesce(_optionalChain([iAddress, 'optionalAccess', _2 => _2.balance]), () => ( '0'))
-  const { scriptPubkey } = await _asyncNullishCoalesce(iAddress, async () => ( (await walletTools.getScriptPubkey(path))))
+    await exports.transactionChanged.call(void 0, {
+      walletId: common.walletInfo.id,
+      emitter: common.emitter,
+      walletTools: common.walletTools,
+      dataLayer: common.dataLayer,
+      pluginInfo: common.pluginInfo,
+      tx: processedTx
+    })
 
-  if (scriptPubkey == null) {
-    throw new Error('Unknown address path')
-  }
-  const address = walletTools.scriptPubkeyToAddress({
-    changePath: path,
-    scriptPubkey
-  })
+    if (needsTxSpecific(common)) {
+      // Add task to grab transactionSpecific payload
+      common.taskCache.transactionSpecificUpdateCache[txId] = {
+        processing: false
+      }
+    }
 
-  return {
-    ...address,
-    nativeBalance
+    // Add the txid to the server cache
+    serverState.txids.add(txId)
+
+    return true
+  } catch (err) {
+    console.error(err)
+    common.log('error while processing transaction update:', err)
+    common.taskCache.transactionUpdateCache[txId] = { processing: false }
+    return false
   }
 }
 
+/**
+ * Processes an address for transactions by querying the network for the
+ * transaction data.
+ */
+async function* processAddressForTransactions(
+  common,
+  args
 
 
 
 
 
+) {
+  const { address, cacheItem, serverState, serverUri } = args
+  const { page = 1, blockHeight } = cacheItem
+  const addressForTransactionsCache =
+    common.taskCache.addressForTransactionsCache
 
-
-const processAddressTransactions = async (
-  args
-) => {
-  const {
-    walletInfo,
-    address,
-    addressTransactionState,
-    emitter,
-    needsTxSpecific,
-    pluginInfo,
-    processor,
-    walletTools,
-    taskCache,
-    pluginState,
-    serverUri
-  } = args
-  const { page = 1, blockHeight } = addressTransactionState
-  const addressTransactionCache = taskCache.addressTransactionCache
-
-  const scriptPubkey = walletTools.addressToScriptPubkey(address)
-  const addressData = await processor.fetchAddress(scriptPubkey)
+  const scriptPubkey = common.walletTools.addressToScriptPubkey(address)
+  const addressData = await common.dataLayer.fetchAddress(scriptPubkey)
   if (addressData == null) {
     throw new Error(`could not find address with script pubkey ${scriptPubkey}`)
   }
 
-  const queryTime = Date.now()
-  const deferred = new _Deferred2.default()
-  deferred.promise
-    .then(async (value) => {
-      pluginState.serverScoreUp(serverUri, Date.now() - queryTime)
-      const { transactions = [], txs, unconfirmedTxs, totalPages } = value
-
-      // If address is used and previously not marked as used, mark as used.
-      const used = txs > 0 || unconfirmedTxs > 0
-      if (!addressData.used && used && page === 1) {
-        addressData.used = true
+  try {
+    const addressResponse = yield* common.serverStates.addressQueryTask(
+      serverUri,
+      address,
+      {
+        lastQueriedBlockHeight: addressData.lastQueriedBlockHeight,
+        page
       }
+    )
+    const {
+      transactions = [],
+      txs,
+      unconfirmedTxs,
+      totalPages
+    } = addressResponse
+
+    // If address is used and previously not marked as used, mark as used.
+    const used = txs > 0 || unconfirmedTxs > 0
+    if (!addressData.used && used && page === 1) {
+      addressData.used = true
+    }
 
-      // Process and save the address's transactions
-      for (const txResponse of transactions) {
-        const tx = processTransactionResponse({ ...args, txResponse })
-        const processedTx = await processor.saveTransaction({
-          tx,
-          scriptPubkeys: [scriptPubkey]
-        })
-        await exports.transactionChanged.call(void 0, {
-          walletId: walletInfo.id,
-          emitter,
-          walletTools,
-          processor,
-          pluginInfo,
-          tx: processedTx
-        })
+    // Process and save the address's transactions
+    for (const txResponse of transactions) {
+      const tx = processTransactionResponse(common, { txResponse })
+      const processedTx = await common.dataLayer.saveTransaction({
+        tx,
+        scriptPubkeys: [scriptPubkey]
+      })
+      await exports.transactionChanged.call(void 0, {
+        walletId: common.walletInfo.id,
+        emitter: common.emitter,
+        walletTools: common.walletTools,
+        dataLayer: common.dataLayer,
+        pluginInfo: common.pluginInfo,
+        tx: processedTx
+      })
 
-        if (needsTxSpecific) {
-          // Add task to grab transactionSpecific payload
-          taskCache.updateTransactionSpecificCache[tx.txid] = {
-            processing: false
-          }
+      if (needsTxSpecific(common)) {
+        // Add task to grab transactionSpecific payload
+        common.taskCache.transactionSpecificUpdateCache[tx.txid] = {
+          processing: false
         }
       }
+    }
 
-      // Halt on finishing the processing of address transaction until
-      // we have progressed through all of the blockbook pages
-      if (page < totalPages) {
-        // Add the address back to the cache, incrementing the page
-        addressTransactionCache[address] = {
-          ...addressTransactionState,
-          processing: false,
-          page: page + 1
-        }
-        return
+    // Halt on finishing the processing of address transaction until
+    // we have progressed through all of the blockbook pages
+    if (page < totalPages) {
+      // Add the address back to the cache, incrementing the page
+      addressForTransactionsCache[address] = {
+        ...cacheItem,
+        processing: false,
+        page: page + 1
       }
+      return true
+    }
 
-      // Update the lastQueriedBlockHeight for the address
-      addressData.lastQueriedBlockHeight = blockHeight
-
-      // Save/update the fully-processed address
-      await processor.saveAddress(addressData)
-
-      // Update the progress now that the transactions for an address have processed
-      await args.updateProgressRatio()
+    // Update the lastQueriedBlockHeight for the address
+    addressData.lastQueriedBlockHeight = blockHeight
 
-      // Call setLookAhead to update the lookahead
-      await setLookAhead(args)
-    })
-    .catch(err => {
-      // Log the error for debugging purposes without crashing the engine
-      // This will cause frozen wallet syncs
-      console.error(err)
-      addressTransactionCache[address] = addressTransactionState
-    })
-
-  return args.serverStates.addressQueryTask(
-    serverUri,
-    address,
-    {
-      lastQueriedBlockHeight: addressData.lastQueriedBlockHeight,
-      page
-    },
-    deferred
-  )
-}
+    // Save/update the fully-processed address
+    await common.dataLayer.saveAddress(addressData)
 
+    // Update the progress now that the transactions for an address have processed
+    await common.updateProgressRatio()
 
+    // Call setLookAhead to update the lookahead
+    await setLookAhead(common)
 
+    // Add the address to the server cache
+    serverState.addresses.add(address)
 
+    return true
+  } catch (err) {
+    // Log the error for debugging purposes without crashing the engine
+    // This will cause frozen wallet syncs
+    console.error(err)
+    common.log('error while processing address for transactions:', err)
+    addressForTransactionsCache[address] = { ...cacheItem, processing: false }
+    return false
+  }
+}
 
+/**
+ * Processes a blockbook transaction response object (a blockbook transaction).
+ * It will simply convert the blockbook transaction into a TransactionData
+ * object to be saved in the DataLayer
+ */
 const processTransactionResponse = (
+  common,
   args
 ) => {
-  const {
-    txResponse,
-    pluginInfo: { coinInfo }
-  } = args
+  const { txResponse } = args
   const inputs = txResponse.vin.map(vin => {
     const scriptPubkey =
       // Note: Blockbook has empirically not sent a hex value as the
@@ -1328,7 +1267,7 @@ const processTransactionResponse = (
         'unknown'
       )({
         address: vin.addresses[0],
-        coin: coinInfo.name
+        coin: common.pluginInfo.coinInfo.name
       })
     return {
       txId: vin.txid,
@@ -1347,7 +1286,7 @@ const processTransactionResponse = (
         'unknown'
       )({
         address: vout.addresses[0],
-        coin: coinInfo.name
+        coin: common.pluginInfo.coinInfo.name
       })))
     return {
       n: vout.n,
@@ -1370,87 +1309,88 @@ const processTransactionResponse = (
   }
 }
 
+/**
+ * Process a given address for UTXO data by querying the network for UTXO data
+ * and processing it into the `blockbookUtxoCache` to later be processed by
+ * `processBlockbookUtxo`.
+ */
+async function* processAddressForUtxos(
+  common,
+  args
 
 
 
 
 
-
-
-const processAddressUtxos = async (
-  args
-) => {
+) {
+  const { address, cacheItem, serverState, serverUri } = args
   const {
-    address,
-    walletTools,
-    processor,
-    taskCache,
-    path,
-    pluginState,
-    serverUri
-  } = args
-  const { addressUtxoCache, rawUtxoCache, processorUtxoCache } = taskCache
-  const queryTime = Date.now()
-  const deferred = new _Deferred2.default()
-  deferred.promise
-    .then(async (utxos) => {
-      pluginState.serverScoreUp(serverUri, Date.now() - queryTime)
-      const scriptPubkey = walletTools.addressToScriptPubkey(address)
-      const addressData = await processor.fetchAddress(scriptPubkey)
-      if (addressData == null || addressData.path == null) {
-        return
-      }
+    addressForUtxosCache,
+    blockbookUtxoCache,
+    dataLayerUtxoCache
+  } = common.taskCache
+  try {
+    const utxos = yield* common.serverStates.utxoListQueryTask(
+      serverUri,
+      address
+    )
+    const scriptPubkey = common.walletTools.addressToScriptPubkey(address)
+    const addressData = await common.dataLayer.fetchAddress(scriptPubkey)
+    if (addressData == null || addressData.path == null) {
+      return true
+    }
 
-      if (utxos.length === 0) {
-        addToProcessorUtxoCache(processorUtxoCache, path, scriptPubkey, 0)
-        return
-      }
+    if (utxos.length === 0) {
+      addToDataLayerUtxoCache(
+        dataLayerUtxoCache,
+        cacheItem.path,
+        scriptPubkey,
+        0
+      )
+      return true
+    }
 
-      for (const utxo of utxos) {
-        const utxoId = `${utxo.txid}_${utxo.vout}`
-        rawUtxoCache[utxoId] = {
-          blockbookUtxo: utxo,
-          processing: false,
-          requiredCount: utxos.length,
-          path,
-          // TypeScript yells otherwise
-          address: { ...addressData, path: addressData.path }
-        }
+    for (const utxo of utxos) {
+      const utxoId = `${utxo.txid}_${utxo.vout}`
+      blockbookUtxoCache[utxoId] = {
+        blockbookUtxo: utxo,
+        processing: false,
+        requiredCount: utxos.length,
+        path: cacheItem.path,
+        // TypeScript yells otherwise
+        address: { ...addressData, path: addressData.path }
       }
-    })
-    .catch(() => {
-      args.processing = false
-      addressUtxoCache[address] = {
-        processing: args.processing,
-        path
-      }
-    })
-
-  return args.serverStates.utxoListQueryTask(serverUri, address, deferred)
-}
+    }
 
+    serverState.addresses.add(address)
 
+    return true
+  } catch (err) {
+    console.error(err)
+    common.log('error while processing address for UTXOs:', err)
+    addressForUtxosCache[address] = { ...cacheItem, processing: false }
+    return false
+  }
+}
 
+/**
+ * Processes UtxoData from the DataLayerUtxoCache by saving/removing UTXOs
+ * to/from the DataLayer and updating the address balance.
+ */
+const processDataLayerUtxos = async (
+  common,
+  args
 
 
 
-const processProcessorUtxos = async (
-  args
 ) => {
-  const {
-    utxos,
-    processor,
-    scriptPubkey,
-    log,
-    emitter,
-    pluginInfo: { currencyInfo }
-  } = args
+  const { utxos, scriptPubkey } = args
 
   const updatedUtxos = Object.fromEntries(
     [...utxos].map(utxo => [utxo.id, utxo])
   )
   const utxoIdsToRemove = []
-  const currentUtxos = await processor.fetchUtxos({ scriptPubkey })
+  const currentUtxos = await common.dataLayer.fetchUtxos({ scriptPubkey })
 
   //
   // Modify existing UTXO set
@@ -1475,7 +1415,7 @@ const processProcessorUtxos = async (
   }
 
   // Remove any spent UTXOs that have confirmations
-  await processor.removeUtxos(utxoIdsToRemove)
+  await common.dataLayer.removeUtxos(utxoIdsToRemove)
 
   //
   // Save updated UTXO set
@@ -1488,7 +1428,7 @@ const processProcessorUtxos = async (
       newBalance = _biggystring.add.call(void 0, utxo.value, newBalance)
     }
     // Save new UTXOs
-    await processor.saveUtxo(utxo)
+    await common.dataLayer.saveUtxo(utxo)
   }
 
   //
@@ -1497,10 +1437,14 @@ const processProcessorUtxos = async (
 
   // Address balance and emit address balance change event
   if (newBalance !== oldBalance) {
-    log('address balance changed:', { scriptPubkey, oldBalance, newBalance })
-    emitter.emit(
+    common.log('address balance changed:', {
+      scriptPubkey,
+      oldBalance,
+      newBalance
+    })
+    common.emitter.emit(
       _EngineEmitter.EngineEvent.ADDRESS_BALANCE_CHANGED,
-      currencyInfo.currencyCode,
+      common.pluginInfo.currencyInfo.currencyCode,
       [
         {
           scriptPubkey,
@@ -1510,13 +1454,13 @@ const processProcessorUtxos = async (
     )
 
     // Update balances for address that have this scriptPubkey
-    const address = await processor.fetchAddress(scriptPubkey)
+    const address = await common.dataLayer.fetchAddress(scriptPubkey)
 
     if (address == null) {
       throw new Error('address not found when processing UTXO transactions')
     }
 
-    await processor.saveAddress({
+    await common.dataLayer.saveAddress({
       ...address,
       balance: newBalance,
       used: true
@@ -1524,43 +1468,32 @@ const processProcessorUtxos = async (
   }
 
   // Update the progress now that the UTXOs for an address have been processed
-  await args.updateProgressRatio()
+  await common.updateProgressRatio()
 
-  await setLookAhead(args).catch(err => {
-    log.error(err)
+  await setLookAhead(common).catch(err => {
+    common.log.error(err)
     throw err
   })
 }
 
+/**
+ * Process a blockbook UTXO from the cache by querying the network for
+ * the UTXO's transaction data to get its script for legacy addresses.
+ * After the network fetching, the UTXO is processed into a UtxoData object
+ * to be later processed into the DataLayer.
+ */
+async function* processBlockbookUtxo(
+  common,
+  args
 
 
 
-
-
-
-
-
-
-const processRawUtxo = async (
-  args
-) => {
-  const {
-    utxo,
-    id,
-    address,
-    pluginInfo,
-    processor,
-    path,
-    taskCache,
-    requiredCount,
-    pluginState,
-    serverUri,
-    log
-  } = args
-  const { rawUtxoCache, processorUtxoCache } = taskCache
+) {
+  const { serverUri, cacheItem } = args
+  const { blockbookUtxoCache, dataLayerUtxoCache } = common.taskCache
   const purposeType = _utils3.pathToPurposeType.call(void 0, 
-    path,
-    pluginInfo.engineInfo.scriptTemplates
+    cacheItem.path,
+    common.pluginInfo.engineInfo.scriptTemplates
   )
   const scriptType = _utils3.getScriptTypeFromPurposeType.call(void 0, purposeType)
   let script
@@ -1568,24 +1501,24 @@ const processRawUtxo = async (
 
   // Function to call once we are finished
   const done = () => {
-    const processorUtxo = {
-      id,
-      txid: utxo.txid,
-      vout: utxo.vout,
-      value: utxo.value,
-      scriptPubkey: address.scriptPubkey,
+    const utxoData = {
+      id: `${cacheItem.blockbookUtxo.txid}_${cacheItem.blockbookUtxo.vout}`,
+      txid: cacheItem.blockbookUtxo.txid,
+      vout: cacheItem.blockbookUtxo.vout,
+      value: cacheItem.blockbookUtxo.value,
+      scriptPubkey: cacheItem.address.scriptPubkey,
       script,
       redeemScript,
       scriptType,
-      blockHeight: _nullishCoalesce(utxo.height, () => ( -1)),
+      blockHeight: _nullishCoalesce(cacheItem.blockbookUtxo.height, () => ( -1)),
       spent: false
     }
-    addToProcessorUtxoCache(
-      processorUtxoCache,
-      path,
-      address.scriptPubkey,
-      requiredCount,
-      processorUtxo
+    addToDataLayerUtxoCache(
+      dataLayerUtxoCache,
+      cacheItem.path,
+      cacheItem.address.scriptPubkey,
+      cacheItem.requiredCount,
+      utxoData
     )
   }
 
@@ -1593,46 +1526,42 @@ const processRawUtxo = async (
     case _keymanager.BIP43PurposeTypeEnum.Airbitz:
     case _keymanager.BIP43PurposeTypeEnum.Legacy:
     case _keymanager.BIP43PurposeTypeEnum.ReplayProtection:
-      redeemScript = address.redeemScript
+      redeemScript = cacheItem.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 common.dataLayer.fetchTransactions({
+          txId: cacheItem.blockbookUtxo.txid
         })
         if (tx == null) {
-          const queryTime = Date.now()
-          const deferred = new _Deferred2.default()
-          deferred.promise
-            .then((txResponse) => {
-              pluginState.serverScoreUp(serverUri, Date.now() - queryTime)
-              const processedTx = processTransactionResponse({
-                ...args,
-                txResponse
-              })
-              script = processedTx.hex
-              // Only after we have successfully fetched the tx, set our script and call done
-              done()
-            })
-            .catch(err => {
-              // If something went wrong, add the UTXO back to the queue
-              log('error in processRawUtxo:', err)
-              const utxoId = `${utxo.txid}_${utxo.vout}`
-              rawUtxoCache[utxoId] = {
-                blockbookUtxo: utxo,
-                processing: false,
-                path,
-                address,
-                requiredCount
-              }
-            })
+          try {
+            const txResponse = yield* common.serverStates.transactionQueryTask(
+              serverUri,
+              cacheItem.blockbookUtxo.txid
+            )
 
-          return args.serverStates.transactionQueryTask(
-            serverUri,
-            utxo.txid,
-            deferred
-          )
+            const processedTx = processTransactionResponse(common, {
+              txResponse
+            })
+            script = processedTx.hex
+            // Only after we have successfully fetched the tx, set our script and call done
+            done()
+
+            return true
+          } catch (err) {
+            // If something went wrong, add the UTXO back to the queue
+            common.log('error while processing Blockbook UTXO:', err)
+            const utxoId = `${cacheItem.blockbookUtxo.txid}_${cacheItem.blockbookUtxo.vout}`
+            blockbookUtxoCache[utxoId] = {
+              blockbookUtxo: cacheItem.blockbookUtxo,
+              processing: false,
+              path: cacheItem.path,
+              address: cacheItem.address,
+              requiredCount: cacheItem.requiredCount
+            }
+            return false
+          }
         } else {
           script = tx.hex
         }
@@ -1640,39 +1569,46 @@ const processRawUtxo = async (
 
       break
     case _keymanager.BIP43PurposeTypeEnum.WrappedSegwit:
-      script = address.scriptPubkey
-      if (address.redeemScript == null) {
+      script = cacheItem.address.scriptPubkey
+      if (cacheItem.address.redeemScript == null) {
         throw new Error(
           'Address redeem script not defined, but required for p2sh wrapped segwit utxo processing'
         )
       }
-      redeemScript = address.redeemScript
+      redeemScript = cacheItem.address.redeemScript
 
       break
     case _keymanager.BIP43PurposeTypeEnum.Segwit:
-      script = address.scriptPubkey
+      script = cacheItem.address.scriptPubkey
 
       break
   }
 
   // Since we have everything, call done
   done()
+
+  return true
 }
 
-const addToProcessorUtxoCache = (
-  processorUtxoCache,
+/**
+ * This adds a UtxoData object to the DataLayerUtxoCache. It will mark the cache
+ * with processing and full flags which tell the pickNextTask routine when to
+ * process the UtxoData into the data-later.
+ */
+const addToDataLayerUtxoCache = (
+  dataLayerUtxoCache,
   path,
   scriptPubkey,
   requiredCount,
   utxo
 ) => {
-  const processorUtxos = _nullishCoalesce(processorUtxoCache[scriptPubkey], () => ( {
+  const dataLayerUtxos = _nullishCoalesce(dataLayerUtxoCache[scriptPubkey], () => ( {
     utxos: [],
     processing: false,
     path,
     full: false
   }))
-  if (utxo != null) processorUtxos.utxos.push(utxo)
-  processorUtxoCache[scriptPubkey] = processorUtxos
-  processorUtxos.full = processorUtxos.utxos.length >= requiredCount
+  if (utxo != null) dataLayerUtxos.utxos.push(utxo)
+  dataLayerUtxoCache[scriptPubkey] = dataLayerUtxos
+  dataLayerUtxos.full = dataLayerUtxos.utxos.length >= requiredCount
 }