edge-currency-plugins 3.2.0 → 3.2.1

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

@@ -176,25 +176,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 +183,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) {
@@ -338,240 +308,257 @@ 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 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
+        }
 
-    for (const state of Object.values(serverStatesCache)) {
-      if (state.txids.has(txid)) return false
-    }
-    return true
-  }
+        // 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 serverCanGetAddress = (uri, address) => {
-    const serverState = serverStatesCache[uri]
-    if (serverState == null) return false
-    if (serverState.addresses.has(address)) 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
+          }
+
+          // If there is no key for the NowNode servers:
+          if (nowNodeApiKey == 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': 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)
+                }
+              })
+          }
+        }
+      })
+    },
 
-    for (const state of Object.values(serverStatesCache)) {
-      if (state.addresses.has(address)) return false
-    }
-    return true
-  }
+    getBlockHeight(uri) {
+      return serverStatesCache[uri].blockHeight
+    },
 
-  const serverIsAwareOfAddress = (uri, address) => {
-    const serverState = serverStatesCache[uri]
-    if (serverState == null) return false
-    if (serverState.addresses.has(address)) return true
-    return false
-  }
+    getServerList() {
+      return serverList
+    },
 
-  const getServerState = (uri) => {
-    return serverStatesCache[uri]
-  }
+    getServerState(uri) {
+      return serverStatesCache[uri]
+    },
 
-  const getServerList = () => {
-    return serverList
-  }
+    refillServers() {
+      log(`refilling servers...`)
+      isEngineOn = true
+      _socketQueue.pushUpdate.call(void 0, {
+        id: walletInfo.id,
+        updateFunc: () => {
+          doRefillServers()
+        }
+      })
+    },
 
-  const setServerList = (updatedServerList) => {
-    serverList = updatedServerList
-  }
+    setPickNextTaskCB(
+      callback
+    ) {
+      pickNextTaskCB = callback
+    },
 
-  const broadcastTx = async (transaction) => {
-    return await new Promise((resolve, reject) => {
-      let resolved = false
-      let bad = 0
+    setServerList(updatedServerList) {
+      serverList = updatedServerList
+    },
 
-      const wsUris = Object.keys(serverStatesCache).filter(
-        uri => serverStatesCache[uri].blockbook != null
-      )
+    serverCanGetTx(uri, txid) {
+      const serverState = serverStatesCache[uri]
+      if (serverState == null) return false
+      if (serverState.txids.has(txid)) return true
 
-      // 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
+      for (const state of Object.values(serverStatesCache)) {
+        if (state.txids.has(txid)) return false
       }
+      return true
+    },
 
-      // Determine if there are any connected blockbook instances
-      const isAnyBlockbookConnected = wsUris.some(
-        uri => serverStatesCache[uri].blockbook.isConnected
-      )
+    serverCanGetAddress(uri, address) {
+      const serverState = serverStatesCache[uri]
+      if (serverState == null) return false
+      if (serverState.addresses.has(address)) return true
 
-      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)
-              }
-            })
-        }
+      for (const state of Object.values(serverStatesCache)) {
+        if (state.addresses.has(address)) 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
-        }
-
-        // If there is no key for the NowNode servers:
-        if (nowNodeApiKey == null) {
-          reject(new Error('Missing connection key for fallback servers.'))
-          return
-        }
+    serverIsAwareOfAddress(uri, address) {
+      const serverState = serverStatesCache[uri]
+      if (serverState == null) return false
+      if (serverState.addresses.has(address)) return true
+      return false
+    },
 
-        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': 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}`)
-
-    const { blockbook } = serverState
+    },
 
-    // Add new addresses to the set of known addresses
-    for (const address of addresses) {
-      serverState.addresses.add(address)
-    }
+    watchAddresses(
+      uri,
+      addresses,
+      deferredAddressSub
+    ) {
+      const serverState = serverStatesCache[uri]
+      if (serverState == null)
+        throw new Error(`No blockbook connection with ${uri}`)
 
-    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(serverState.addresses), deferred)
-  }
+      const { blockbook } = serverState
 
-  const watchBlocks = (uri) => {
-    const serverState = serverStatesCache[uri]
-    if (serverState == null)
-      throw new Error(`No blockbook connection with ${uri}`)
+      // Add new addresses to the set of known addresses
+      for (const address of addresses) {
+        serverState.addresses.add(address)
+      }
 
-    const { blockbook } = serverState
+      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(serverState.addresses), deferred)
+    },
 
-    serverState.blockSubscriptionStatus = 'subscribing'
+    watchBlocks(uri) {
+      const serverState = serverStatesCache[uri]
+      if (serverState == null)
+        throw new Error(`No blockbook connection with ${uri}`)
 
-    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 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)
+    },
 
     //
     // Task Methods:

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

@@ -126,11 +126,11 @@ const asResponseDefault = (raw) => [
   let connected = false
   let cancelConnect = false
   const timeout = 1000 * (_nullishCoalesce(config.timeout, () => ( 30)))
-  let error
+  let trackedError
   let timer
 
   const handleError = (e) => {
-    if (error == null) error = e
+    if (trackedError == null) trackedError = e
     if (connected && socket != null && socket.readyState === _types3.ReadyState.OPEN)
       disconnect()
     else cancelConnect = true
@@ -146,22 +146,28 @@ const asResponseDefault = (raw) => [
   }
 
   const onSocketClose = () => {
-    const err = _nullishCoalesce(error, () => ( new Error('Socket close')))
-    log.warn(`onSocketClose due to ${err.message} with server ${uri}`)
+    const errObj =
+      trackedError != null
+        ? trackedError instanceof Error
+          ? trackedError
+          : new Error(String(trackedError))
+        : new Error('Socket closed without error')
+    log.warn(`onSocketClose with server ${uri}: ${errObj.message}`)
     clearTimeout(timer)
     connected = false
     socket = null
     cancelConnect = false
+    trackedError = undefined
     for (const request of Object.values(pendingRequests)) {
       try {
-        request.task.deferred.reject(err)
+        request.task.deferred.reject(errObj)
       } catch (e) {
         log.error(e.message)
       }
     }
     pendingRequests = {}
     try {
-      emitter.emit(_SocketEmitter.SocketEvent.CONNECTION_CLOSE, uri, err)
+      emitter.emit(_SocketEmitter.SocketEvent.CONNECTION_CLOSE, uri, errObj)
     } catch (e) {
       log.error(e.message)
     }
@@ -267,7 +273,7 @@ const asResponseDefault = (raw) => [
         .then(() => {
           emitter.emit(_SocketEmitter.SocketEvent.CONNECTION_TIMER, uri, now)
         })
-        .catch((e) => handleError(e))
+        .catch(e => handleError(e))
     }
 
     for (const [id, request] of Object.entries(pendingRequests)) {
@@ -384,8 +390,8 @@ const asResponseDefault = (raw) => [
             resolve()
           },
           onMessage: onMessage,
-          onError: event => {
-            error = new Error(JSON.stringify(event))
+          onError: err => {
+            trackedError = new Error(String(err))
           },
           onClose: onSocketClose
         }

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

@@ -14,8 +14,8 @@
   socket.onmessage = (message) => {
     callbacks.onMessage(message.data.toString())
   }
-  socket.onerror = () => {
-    callbacks.onError()
+  socket.onerror = event => {
+    callbacks.onError(event)
   }
   socket.onclose = () => {
     callbacks.onClose()

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

@@ -27,7 +27,7 @@ export interface PluginState {
     serverScoreUp: (uri: string, score: number) => void;
     clearCache: () => Promise<void>;
     getLocalServers: (numServersWanted: number, includePatterns?: Array<string | RegExp>) => string[];
-    refreshServers: () => Promise<void>;
+    refreshServers: (updatedCustomServers?: string[]) => Promise<void>;
     updateServers: (settings: UtxoUserSettings) => Promise<void>;
 }
 export declare function makePluginState(settings: PluginStateSettings): PluginState;

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

@@ -25,6 +25,7 @@ export declare const asServerCache: import("cleaners").ObjectCleaner<{
             numResponseTimes: any;
         };
     };
+    enableCustomServers: boolean;
     internalServers: {
         [keys: string]: {
             serverUrl: any;

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

@@ -1,5 +1,5 @@
 export interface InnerSocketCallbacks {
-    onError: (error?: Error) => void;
+    onError: (error?: unknown) => void;
     onMessage: (message: string) => void;
     onClose: (error?: Error) => void;
     onOpen: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-currency-plugins",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "Edge currency plugins to fetch and process wallet accounts, balances and transactions.",
   "homepage": "https://edge.app/",
   "repository": "https://github.com/EdgeApp/edge-currency-plugins",