edge-currency-plugins 3.2.0 → 3.3.0

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

@@ -87,10 +87,6 @@ var _constants = require('./constants');
 
 
 
-
-
-
-
 
 
 
@@ -176,25 +172,6 @@ var _constants = require('./constants');
     addresses: new Set(),
     blockHeight: 0
   })
-  const setPickNextTaskCB = (
-    callback
-  ) => {
-    pickNextTaskCB = callback
-  }
-
-  const stop = async () => {
-    isEngineOn = false
-    log(`stopping server states`)
-    _socketQueue.removeIdFromQueue.call(void 0, walletInfo.id)
-    clearTimeout(reconnectTimer)
-    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)
-    }
-  }
 
   const reconnect = () => {
     if (isEngineOn) {
@@ -202,22 +179,11 @@ var _constants = require('./constants');
       const reconnectionDelay = Math.max(5, reconnectCounter++) * 1000
       reconnectTimer = setTimeout(() => {
         clearTimeout(reconnectTimer)
-        refillServers()
+        instance.refillServers()
       }, reconnectionDelay)
     }
   }
 
-  const refillServers = () => {
-    log(`refilling servers...`)
-    isEngineOn = true
-    _socketQueue.pushUpdate.call(void 0, {
-      id: walletInfo.id,
-      updateFunc: () => {
-        doRefillServers()
-      }
-    })
-  }
-
   const doRefillServers = () => {
     const includePatterns = ['wss:', 'ws:', 'electrumwss:', 'electrumws:']
     if (serverList.length === 0) {
@@ -256,6 +222,38 @@ var _constants = require('./constants');
       // Blockbook instance variable
       let blockbook
 
+      // Queue space callback
+      async function* taskGeneratorFn()
+
+
+ {
+        // Exit if the connection is no longer active
+        if (uri == null || !(uri in serverStatesCache)) return false
+
+        const generator = pickNextTaskCB(uri)
+        let nextValue
+        while (true) {
+          const result
+
+
+ = await generator.next(nextValue)
+
+          if (_optionalChain([result, 'optionalAccess', _ => _.done]) === true) {
+            return result.value
+          }
+
+          const task = result.value
+
+          if (typeof task !== 'boolean') {
+            const taskMessage = `${task.method} params: ${JSON.stringify(
+              task.params
+            )}`
+            log(`${uri} nextTask: ${taskMessage}`)
+          }
+          nextValue = yield task
+        }
+      }
+
       // Create a new blockbook instance based on the URI scheme
       if (['electrumwss', 'electrumws'].includes(parsed.scheme)) {
         // Electrum wrapper
@@ -263,22 +261,9 @@ var _constants = require('./constants');
           asAddress: pluginInfo.engineInfo.asBlockbookAddress,
           connectionUri: uri,
           engineEmitter,
+          initOptions,
           log,
-          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
-          },
+          taskGeneratorFn,
           pluginInfo,
           socketEmitter,
           walletId: walletInfo.id
@@ -289,22 +274,9 @@ var _constants = require('./constants');
           asAddress: pluginInfo.engineInfo.asBlockbookAddress,
           connectionUri: uri,
           engineEmitter,
+          initOptions,
           log,
-          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
-          },
+          taskGeneratorFn,
           socketEmitter,
           walletId: walletInfo.id
         })
@@ -338,304 +310,358 @@ var _constants = require('./constants');
     }
   }
 
-  const serverCanGetTx = (uri, txid) => {
-    const serverState = serverStatesCache[uri]
-    if (serverState == null) return false
-    if (serverState.txids.has(txid)) return true
+  const deferredWithServerScoring = (
+    serverUri,
+    deferred
+  ) => {
+    const serverState = serverStatesCache[serverUri]
+    if (serverState == null)
+      throw new Error(`No blockbook connection with ${serverUri}`)
 
-    for (const state of Object.values(serverStatesCache)) {
-      if (state.txids.has(txid)) return false
-    }
-    return true
+    const queryTime = Date.now()
+    const deferredWithScoring = new _Deferred2.default()
+    deferredWithScoring.promise.then(
+      (value) => {
+        pluginState.serverScoreUp(serverUri, Date.now() - queryTime)
+        deferred.resolve(value)
+      },
+      (err) => {
+        pluginState.serverScoreDown(serverUri)
+        deferred.reject(err)
+      }
+    )
+
+    return deferredWithScoring
   }
 
-  const serverCanGetAddress = (uri, address) => {
-    const serverState = serverStatesCache[uri]
-    if (serverState == null) return false
-    if (serverState.addresses.has(address)) return true
+  function* withServerScoring(
+    serverUri,
+    generator
+  ) {
+    const serverState = serverStatesCache[serverUri]
+    if (serverState == null)
+      throw new Error(`No blockbook connection with ${serverUri}`)
 
-    for (const state of Object.values(serverStatesCache)) {
-      if (state.addresses.has(address)) return false
+    const queryTime = Date.now()
+    let result
+    try {
+      result = yield* generator
+      pluginState.serverScoreUp(serverUri, Date.now() - queryTime)
+    } catch (error) {
+      pluginState.serverScoreDown(serverUri)
+      throw error
     }
-    return true
+    return result
   }
 
-  const serverIsAwareOfAddress = (uri, address) => {
-    const serverState = serverStatesCache[uri]
-    if (serverState == null) return false
-    if (serverState.addresses.has(address)) return true
-    return false
-  }
+  const instance = {
+    async broadcastTx(transaction) {
+      return await new Promise((resolve, reject) => {
+        let resolved = false
+        let bad = 0
+
+        const wsUris = Object.keys(serverStatesCache).filter(
+          uri => serverStatesCache[uri].blockbook != null
+        )
+
+        // If there are no blockbook instances, reject the promise
+        if (wsUris.length < 1) {
+          reject(new Error('Unexpected error. Missing WebSocket connections.'))
+          // Exit early if there are blockbook instances
+          return
+        }
 
-  const getServerState = (uri) => {
-    return serverStatesCache[uri]
-  }
+        // Determine if there are any connected blockbook instances
+        const isAnyBlockbookConnected = wsUris.some(
+          uri => serverStatesCache[uri].blockbook.isConnected
+        )
+
+        if (isAnyBlockbookConnected) {
+          for (const uri of wsUris) {
+            const { blockbook } = serverStatesCache[uri]
+            if (blockbook == null) continue
+            blockbook
+              .broadcastTx(transaction)
+              .then(response => {
+                if (!resolved) {
+                  resolved = true
+                  resolve(response.result)
+                }
+              })
+              .catch((e) => {
+                if (++bad === wsUris.length) {
+                  const msg = e != null ? `With error ${e.message}` : ''
+                  log.error(
+                    `broadcastTx fail: ${JSON.stringify(transaction)}\n${msg}`
+                  )
+                  reject(e)
+                }
+              })
+          }
+        }
 
-  const getServerList = () => {
-    return serverList
-  }
+        // Broadcast through any HTTP URI that may be configured, only if no
+        // blockbook instances are connected.
+        if (!isAnyBlockbookConnected) {
+          // This is for the future when we want to get HTTP servers from the user
+          // settings:
+          // const httpUris = pluginState.getLocalServers(Infinity, [
+          //   /^http(?:s)?:/i
+          // ])
+
+          const { nowNodesApiKey } = initOptions
+          const nowNodeUris = serverConfigs
+            .filter(config => config.type === 'blockbook-nownode')
+            .map(config => config.uris)
+            .flat(1)
+
+          // If there are no HTTP servers, reject the promise
+          if (nowNodeUris.length < 1) {
+            // If no HTTP servers are available, and we had no connected blockbook
+            // instances, reject the promise with a message indicating no
+            // available connections. It's clear we have some connection instances
+            // if we gotten to this point, but we just don't have any of those
+            // instances connected at this time.
+            reject(
+              new Error('No available connections. Check your internet signal.')
+            )
+            return
+          }
+
+          // If there is no key for the NowNode servers:
+          if (nowNodesApiKey == null) {
+            reject(new Error('Missing connection key for fallback servers.'))
+            return
+          }
+
+          for (const uri of nowNodeUris) {
+            log.warn('Falling back to NOWNode server broadcast over HTTP:', uri)
+
+            // HTTP Fallback
+            io.fetchCors(`${uri}/api/v2/sendtx/`, {
+              method: 'POST',
+              headers: {
+                'api-key': nowNodesApiKey
+              },
+              body: transaction.signedTx
+            })
+              .then(async response => {
+                if (!response.ok) {
+                  throw new Error(
+                    `Failed to broadcast transaction via Blockbook: HTTP ${response.status}`
+                  )
+                }
+                const json = await response.json()
+                return _blockbookApi.asBlockbookResponse.call(void 0, (0, _blockbookApi.asBroadcastTxResponse))(json)
+              })
+              .then(response => {
+                if (!resolved) {
+                  resolved = true
+                  resolve(response.result)
+                }
+              })
+              .catch((e) => {
+                if (++bad === nowNodeUris.length) {
+                  const msg = e != null ? `With error ${e.message}` : ''
+                  log.error(
+                    `broadcastTx fail: ${JSON.stringify(transaction)}\n${msg}`
+                  )
+                  reject(e)
+                }
+              })
+          }
+        }
+      })
+    },
 
-  const setServerList = (updatedServerList) => {
-    serverList = updatedServerList
-  }
+    getBlockHeight(uri) {
+      return serverStatesCache[uri].blockHeight
+    },
 
-  const broadcastTx = async (transaction) => {
-    return await new Promise((resolve, reject) => {
-      let resolved = false
-      let bad = 0
+    getServerList() {
+      return serverList
+    },
 
-      const wsUris = Object.keys(serverStatesCache).filter(
-        uri => serverStatesCache[uri].blockbook != null
-      )
+    getServerState(uri) {
+      return serverStatesCache[uri]
+    },
 
-      // If there are no blockbook instances, reject the promise
-      if (wsUris.length < 1) {
-        reject(new Error('Unexpected error. Missing WebSocket connections.'))
-        // Exit early if there are blockbook instances
-        return
-      }
+    refillServers() {
+      log(`refilling servers...`)
+      isEngineOn = true
+      _socketQueue.pushUpdate.call(void 0, {
+        id: walletInfo.id,
+        updateFunc: () => {
+          doRefillServers()
+        }
+      })
+    },
 
-      // Determine if there are any connected blockbook instances
-      const isAnyBlockbookConnected = wsUris.some(
-        uri => serverStatesCache[uri].blockbook.isConnected
-      )
+    setPickNextTaskCB(callback) {
+      pickNextTaskCB = callback
+    },
 
-      if (isAnyBlockbookConnected) {
-        for (const uri of wsUris) {
-          const { blockbook } = serverStatesCache[uri]
-          if (blockbook == null) continue
-          blockbook
-            .broadcastTx(transaction)
-            .then(response => {
-              if (!resolved) {
-                resolved = true
-                resolve(response.result)
-              }
-            })
-            .catch((e) => {
-              if (++bad === wsUris.length) {
-                const msg = e != null ? `With error ${e.message}` : ''
-                log.error(
-                  `broadcastTx fail: ${JSON.stringify(transaction)}\n${msg}`
-                )
-                reject(e)
-              }
-            })
-        }
+    setServerList(updatedServerList) {
+      serverList = updatedServerList
+    },
+
+    serverCanGetTx(uri, txid) {
+      const serverState = serverStatesCache[uri]
+      if (serverState == null) return false
+      if (serverState.txids.has(txid)) return true
+
+      for (const state of Object.values(serverStatesCache)) {
+        if (state.txids.has(txid)) return false
       }
+      return true
+    },
 
-      // Broadcast through any HTTP URI that may be configured, only if no
-      // blockbook instances are connected.
-      if (!isAnyBlockbookConnected) {
-        // This is for the future when we want to get HTTP servers from the user
-        // settings:
-        // const httpUris = pluginState.getLocalServers(Infinity, [
-        //   /^http(?:s)?:/i
-        // ])
-
-        const { nowNodeApiKey } = initOptions
-        const nowNodeUris = serverConfigs
-          .filter(config => config.type === 'blockbook-nownode')
-          .map(config => config.uris)
-          .flat(1)
-
-        // If there are no HTTP servers, reject the promise
-        if (nowNodeUris.length < 1) {
-          // If no HTTP servers are available, and we had no connected blockbook
-          // instances, reject the promise with a message indicating no
-          // available connections. It's clear we have some connection instances
-          // if we gotten to this point, but we just don't have any of those
-          // instances connected at this time.
-          reject(
-            new Error('No available connections. Check your internet signal.')
-          )
-          return
-        }
+    serverCanGetAddress(uri, address) {
+      const serverState = serverStatesCache[uri]
+      if (serverState == null) return false
+      if (serverState.addresses.has(address)) return true
 
-        // If there is no key for the NowNode servers:
-        if (nowNodeApiKey == null) {
-          reject(new Error('Missing connection key for fallback servers.'))
-          return
-        }
+      for (const state of Object.values(serverStatesCache)) {
+        if (state.addresses.has(address)) return false
+      }
+      return true
+    },
 
-        for (const uri of nowNodeUris) {
-          log.warn('Falling back to NOWNode server broadcast over HTTP:', uri)
+    serverIsAwareOfAddress(uri, address) {
+      const serverState = serverStatesCache[uri]
+      if (serverState == null) return false
+      if (serverState.addresses.has(address)) return true
+      return false
+    },
 
-          // HTTP Fallback
-          io.fetchCors(`${uri}/api/v2/sendtx/`, {
-            method: 'POST',
-            headers: {
-              'api-key': nowNodeApiKey
-            },
-            body: transaction.signedTx
-          })
-            .then(async response => {
-              if (!response.ok) {
-                throw new Error(
-                  `Failed to broadcast transaction via Blockbook: HTTP ${response.status}`
-                )
-              }
-              const json = await response.json()
-              return _blockbookApi.asBlockbookResponse.call(void 0, (0, _blockbookApi.asBroadcastTxResponse))(json)
-            })
-            .then(response => {
-              if (!resolved) {
-                resolved = true
-                resolve(response.result)
-              }
-            })
-            .catch((e) => {
-              if (++bad === nowNodeUris.length) {
-                const msg = e != null ? `With error ${e.message}` : ''
-                log.error(
-                  `broadcastTx fail: ${JSON.stringify(transaction)}\n${msg}`
-                )
-                reject(e)
-              }
-            })
-        }
+    async stop() {
+      isEngineOn = false
+      log(`stopping server states`)
+      _socketQueue.removeIdFromQueue.call(void 0, walletInfo.id)
+      clearTimeout(reconnectTimer)
+      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)
       }
-    })
-  }
+    },
 
-  const watchAddresses = (
-    uri,
-    addresses,
-    deferredAddressSub
-  ) => {
-    const serverState = serverStatesCache[uri]
-    if (serverState == null)
-      throw new Error(`No blockbook connection with ${uri}`)
+    watchAddresses(
+      serverUri,
+      addresses,
+      deferredAddressSub
+    ) {
+      const serverState = serverStatesCache[serverUri]
+      if (serverState == null)
+        throw new Error(`No blockbook connection with ${serverUri}`)
 
-    const { blockbook } = serverState
+      const { blockbook } = serverState
 
-    // Add new addresses to the set of known addresses
-    for (const address of addresses) {
-      serverState.addresses.add(address)
-    }
+      // 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(() => {
+      const deferred = new _Deferred2.default()
+      deferred.promise.catch((err) => {
         // 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()])
+        // Reject the deferredAddressSub promise if provided
+        _optionalChain([deferredAddressSub, 'optionalAccess', _2 => _2.reject, 'call', _3 => _3(err)])
       })
-    blockbook.watchAddresses(Array.from(serverState.addresses), deferred)
-  }
-
-  const watchBlocks = (uri) => {
-    const serverState = serverStatesCache[uri]
-    if (serverState == null)
-      throw new Error(`No blockbook connection with ${uri}`)
 
-    const { blockbook } = serverState
+      blockbook.watchAddresses(
+        Array.from(serverState.addresses),
+        deferredWithServerScoring(serverUri, deferred)
+      )
+    },
 
-    serverState.blockSubscriptionStatus = 'subscribing'
+    watchBlocks(serverUri) {
+      const serverState = serverStatesCache[serverUri]
+      if (serverState == null)
+        throw new Error(`No blockbook connection with ${serverUri}`)
 
-    const queryTime = Date.now()
-    const deferred = new (0, _Deferred2.default)()
-    deferred.promise
-      .then(() => {
-        serverState.blockSubscriptionStatus = 'subscribed'
-        pluginState.serverScoreUp(uri, Date.now() - queryTime)
-      })
-      .catch(() => {
-        serverState.blockSubscriptionStatus = 'unsubscribed'
-      })
-    blockbook.watchBlocks(deferred)
-  }
+      const { blockbook } = serverState
 
-  const getBlockHeight = (uri) => {
-    return serverStatesCache[uri].blockHeight
-  }
+      serverState.blockSubscriptionStatus = 'subscribing'
 
-  const instance = {
-    setPickNextTaskCB,
-    stop,
-    serverCanGetTx,
-    serverCanGetAddress,
-    serverIsAwareOfAddress,
-    getServerState,
-    refillServers,
-    getServerList,
-    setServerList,
-    broadcastTx,
-    watchAddresses,
-    watchBlocks,
-    getBlockHeight,
+      const deferred = new (0, _Deferred2.default)()
+      deferred.promise
+        .then(() => {
+          serverState.blockSubscriptionStatus = 'subscribed'
+        })
+        .catch(() => {
+          serverState.blockSubscriptionStatus = 'unsubscribed'
+        })
+      blockbook.watchBlocks(deferredWithServerScoring(serverUri, deferred))
+    },
 
     //
     // Task Methods:
     //
 
-    addressQueryTask(
+    addressQueryTask: function* (
       serverUri,
       address,
-      params,
-      deferred
+      params
     ) {
       const serverState = serverStatesCache[serverUri]
       if (serverState == null)
         throw new Error(`No blockbook connection with ${serverUri}`)
 
-      return serverState.blockbook.addressQueryTask(
-        address,
-        {
-          asBlockbookAddress: pluginInfo.engineInfo.asBlockbookAddress,
-          lastQueriedBlockHeight: params.lastQueriedBlockHeight,
-          page: params.page
-        },
-        deferred
+      return yield* withServerScoring(
+        serverUri,
+        (function* () {
+          return yield* serverState.blockbook.addressQueryTask(address, {
+            asBlockbookAddress: pluginInfo.engineInfo.asBlockbookAddress,
+            lastQueriedBlockHeight: params.lastQueriedBlockHeight,
+            page: params.page
+          })
+        })()
       )
     },
 
-    transactionQueryTask(
-      serverUri,
-      txId,
-      deferred
-    ) {
+    transactionQueryTask: function* (serverUri, txId) {
       const serverState = serverStatesCache[serverUri]
       if (serverState == null)
         throw new Error(`No blockbook connection with ${serverUri}`)
 
-      return serverState.blockbook.transactionQueryTask(txId, deferred)
+      return yield* withServerScoring(
+        serverUri,
+        (function* () {
+          return yield* serverState.blockbook.transactionQueryTask(txId)
+        })()
+      )
     },
 
-    transactionSpecialQueryTask(
-      serverUri,
-      txId,
-      deferred
-    ) {
+    transactionSpecialQueryTask: function* (serverUri, txId) {
       const serverState = serverStatesCache[serverUri]
       if (serverState == null)
         throw new Error(`No blockbook connection with ${serverUri}`)
 
-      return serverState.blockbook.transactionSpecialQueryTask(txId, deferred)
+      return yield* withServerScoring(
+        serverUri,
+        (function* () {
+          return serverState.blockbook.transactionSpecialQueryTask(txId)
+        })()
+      )
     },
-    utxoListQueryTask(
-      serverUri,
-      address,
-      deferred
-    ) {
+    utxoListQueryTask: function* (serverUri, address) {
       const serverState = serverStatesCache[serverUri]
       if (serverState == null)
         throw new Error(`No blockbook connection with ${serverUri}`)
 
-      return serverState.blockbook.utxoListQueryTask(
-        address,
-        {
-          asBlockbookAddress: pluginInfo.engineInfo.asBlockbookAddress
-        },
-        deferred
+      return yield* withServerScoring(
+        serverUri,
+        (function* () {
+          return yield* serverState.blockbook.utxoListQueryTask(address, {
+            asBlockbookAddress: pluginInfo.engineInfo.asBlockbookAddress
+          })
+        })()
       )
     }
   }