edge-currency-plugins 3.2.0 → 3.2.1

package/lib/common/plugin/PluginState.js

@@ -66,21 +66,26 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
     pluginDisklet,
     log
   } = settings
-  const builtInServers = defaultSettings.blockbookServers
-  let customServers = []
-  let enableCustomServers = defaultSettings.enableCustomServers
+
   let engines = []
   const memlet = _memlet.makeMemlet.call(void 0, pluginDisklet)
 
   let serverCache = {
     customServers: {},
+    enableCustomServers: defaultSettings.enableCustomServers,
     internalServers: {}
   }
   let serverCacheDirty = false
-  let knownServers = {}
+
+  const getSelectedServerList = () => {
+    const serverCacheIndex = serverCache.enableCustomServers
+      ? 'customServers'
+      : 'internalServers'
+    return serverCache[serverCacheIndex]
+  }
 
   const saveServerCache = async () => {
-    serverScores.printServers(knownServers)
+    serverScores.printServers(getSelectedServerList())
     if (serverCacheDirty) {
       await memlet.setJson(SERVER_CACHE_FILE, serverCache).catch(e => {
         log(`${pluginId} - ${JSON.stringify(e.toString())}`)
@@ -133,30 +138,7 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
     }
   }
 
-  const refreshServers = async () => {
-    let newServers
-    if (enableCustomServers) {
-      newServers = customServers
-    } else {
-      const fetchedServers = await fetchServers()
-      newServers = fetchedServers.length > 0 ? fetchedServers : builtInServers
-    }
-
-    const serverCacheIndex = enableCustomServers
-      ? 'customServers'
-      : 'internalServers'
-
-    knownServers = serverCache[serverCacheIndex]
-    serverScores.serverScoresLoad(knownServers, newServers)
-    await saveServerCache()
-
-    // Tell the engines about the new servers:
-    for (const engine of engines) {
-      engine.refillServers()
-    }
-  }
-
-  return {
+  const instance = {
     /**
      * Begins notifying the engine of state changes. Used at connection time.
      */
@@ -173,7 +155,7 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
 
     dumpData() {
       return {
-        'pluginState.servers_': knownServers
+        'pluginState.servers_': getSelectedServerList()
       }
     },
 
@@ -185,7 +167,7 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
       }
 
       // Fetch servers in the background:
-      refreshServers().catch(e => {
+      instance.refreshServers().catch(e => {
         log(`${pluginId} - ${JSON.stringify(e.toString())}`)
       })
 
@@ -193,16 +175,15 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
     },
 
     serverScoreDown(uri) {
-      serverScores.serverScoreDown(knownServers, uri)
+      serverScores.serverScoreDown(getSelectedServerList(), uri)
     },
 
     serverScoreUp(uri, score) {
-      serverScores.serverScoreUp(knownServers, uri, score)
+      serverScores.serverScoreUp(getSelectedServerList(), uri, score)
     },
 
     async clearCache() {
       serverScores.clearServerScoreTimes()
-      knownServers = {}
       serverCacheDirty = true
       await memlet.delete(SERVER_CACHE_FILE)
     },
@@ -212,18 +193,63 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
       includePatterns = []
     ) {
       return serverScores.getServers(
-        knownServers,
+        getSelectedServerList(),
         numServersWanted,
         includePatterns
       )
     },
 
-    refreshServers,
+    async refreshServers(updatedCustomServers) {
+      let newServers
+      if (serverCache.enableCustomServers) {
+        newServers =
+          // Use the updated custom servers if provided
+          _nullishCoalesce(_nullishCoalesce(updatedCustomServers, () => (
+          // Use the existing custom servers from cache
+          Object.keys(serverCache.customServers))), () => (
+          // Use the default servers from info file as final fallback
+          defaultSettings.blockbookServers))
+      } else {
+        const fetchedServers = await fetchServers()
+        newServers =
+          fetchedServers.length > 0
+            ? // Use the servers from the network query
+              fetchedServers
+            : // Use the default servers from info file as final fallback
+              defaultSettings.blockbookServers
+      }
+
+      serverScores.serverScoresLoad(getSelectedServerList(), newServers)
+      await saveServerCache()
+
+      // Tell the engines about the new servers:
+      for (const engine of engines) {
+        engine.refillServers()
+      }
+    },
 
     async updateServers(settings) {
-      enableCustomServers = settings.enableCustomServers
-      customServers = settings.blockbookServers
+      const hasServerListChanged = () => {
+        const currentCustomServers = Object.keys(serverCache.customServers)
+        const newServers = new Set(settings.blockbookServers)
+        const existingServers = new Set(currentCustomServers)
+        if (newServers.size !== existingServers.size) return true
+        for (const server of settings.blockbookServers) {
+          if (existingServers.has(server)) continue
+          return true
+        }
+        return false
+      }
 
+      // If no changes to the user settings, then exit early
+      if (
+        settings.enableCustomServers === serverCache.enableCustomServers &&
+        !hasServerListChanged()
+      ) {
+        return
+      }
+
+      // Stop all engines and clear the server list:
       const enginesToBeStarted = []
       const disconnects = []
       for (const engine of engines) {
@@ -233,18 +259,22 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
       }
       await Promise.all(disconnects)
       serverScores.clearServerScoreTimes()
+
       // We must always clear custom servers in order to enforce a policy of
       // only using the exact customServers provided.
       serverCache = {
         ...serverCache,
+        enableCustomServers: settings.enableCustomServers,
         customServers: {}
       }
       serverCacheDirty = true
       await saveServerCache()
-      await refreshServers()
+      await instance.refreshServers(settings.blockbookServers)
       for (const engine of enginesToBeStarted) {
         await engine.start()
       }
     }
   }
+
+  return instance
 } exports.makePluginState = makePluginState;

package/lib/common/plugin/ServerScores.js

@@ -16,6 +16,7 @@ var _cleaners = require('cleaners');
 
  const asServerCache = _cleaners.asObject.call(void 0, {
   customServers: exports.asServerList,
+  enableCustomServers: _cleaners.asMaybe.call(void 0, _cleaners.asBoolean, false),
   internalServers: exports.asServerList
 }); exports.asServerCache = asServerCache