edge-currency-plugins 3.2.0 → 3.3.0

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,47 +138,24 @@ 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.
      */
-    addEngine(engineState) {
-      engines.push(engineState)
+    addEngine(engineProcessor) {
+      engines.push(engineProcessor)
     },
 
     /**
      * Stops notifying the engine of state changes. Used at disconnection time.
      */
-    removeEngine(engineState) {
-      engines = engines.filter(engine => engine !== engineState)
+    removeEngine(engineProcessor) {
+      engines = engines.filter(engine => engine !== engineProcessor)
     },
 
     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

@@ -3,6 +3,8 @@
 var _cleaners = require('cleaners');
 
 
+var _uriKeyParams = require('../../util/uriKeyParams');
+
 
  const asServerInfo = _cleaners.asObject.call(void 0, {
   serverUrl: _cleaners.asString,
@@ -16,6 +18,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
 
@@ -100,6 +103,14 @@ const RE_ADDED_SERVER_SCORE = -10
         knownServer.responseTime = RESPONSE_TIME_UNINITIALIZED
       }
 
+      const hasKeyParams = _uriKeyParams.getUriKeyParams.call(void 0, knownServerUrl).length > 0
+      if (hasKeyParams) {
+        // Lower the score on servers which require key params (e.g. NOWNodes).
+        // This is because public, non-authenticated nodes are more affordable.
+        // Decrease score by half (or decrease by 50%).
+        serverScore = serverScore - (MAX_SCORE + MIN_SCORE)
+      }
+
       knownServer.serverScore = serverScore
       this.onDirtyServer(knownServerUrl)
     }

package/lib/common/plugin/types.js

@@ -50,7 +50,7 @@ var _types3 = require('../utxobased/db/types');
 
 
  const asTxOptions = _cleaners.asObject({
-  utxos: _cleaners.asOptional.call(void 0, _cleaners.asArray.call(void 0, _types3.asIUTXO)),
+  utxos: _cleaners.asOptional.call(void 0, _cleaners.asArray.call(void 0, _types3.asUtxoData)),
   subtractFee: _cleaners.asOptional.call(void 0, _cleaners.asBoolean),
   CPFP: _cleaners.asOptional.call(void 0, _cleaners.asString)
 }); exports.asTxOptions = asTxOptions

package/lib/common/utxobased/db/{Processor.js → DataLayer.js}

@@ -113,7 +113,13 @@ const BASELET_DIR = 'tables'
 
 
 
- async function makeProcessor(
+
+
+
+
+
+
+ async function makeDataLayer(
   config
 ) {
   const disklet = _disklet.navigateDisklet.call(void 0, config.disklet, BASELET_DIR)
@@ -126,7 +132,7 @@ const BASELET_DIR = 'tables'
   /**
    * Calculates the transaction value supplied (negative) or received (positive). In order to calculate
    * a value, the `ourIns` and `ourOuts` of the object must be populated with indices.
-   * @param tx {IProcessorTransaction} A transaction object with `ourIns` and `ourOuts` populated
+   * @param tx {TransactionData} A transaction object with `ourIns` and `ourOuts` populated
    */
   const calculateTxAmount = (tx) => {
     
@@ -152,7 +158,7 @@ const BASELET_DIR = 'tables'
     return ourAmount
   }
 
-  const processor = {
+  const dataLayer = {
     async clearAll() {
       await memlet.onFlush.next().value
       await _baselet.clearMemletCache.call(void 0, )
@@ -261,19 +267,17 @@ const BASELET_DIR = 'tables'
       })
     },
 
-    async saveTransaction(
-      args
-    ) {
+    async saveTransaction(args) {
       const { scriptPubkeys = [], tx } = args
       return await baselets.tx(async tables => {
         // Check if the transaction already exists
-        const processorTx = await tables.txById
+        const transactionData = await tables.txById
           .query('', [tx.txid])
           .then(transactions => transactions[0])
           .catch(_ => undefined)
 
         // Use the existing transaction if it does exist.
-        const transaction = _nullishCoalesce(processorTx, () => ( tx))
+        const transaction = _nullishCoalesce(transactionData, () => ( tx))
 
         // Mark the used inputs with the provided script pubkey
         for (const scriptPubkey of scriptPubkeys) {
@@ -325,7 +329,7 @@ const BASELET_DIR = 'tables'
         await tables.txById.insert('', transaction.txid, transaction)
 
         // Save index entry only for first transaction insert
-        if (processorTx == null) {
+        if (transactionData == null) {
           await tables.txIdsByDate.insert('', {
             txid: tx.txid,
             date: tx.date
@@ -594,5 +598,5 @@ const BASELET_DIR = 'tables'
       })
     }
   }
-  return processor
-} exports.makeProcessor = makeProcessor;
+  return dataLayer
+} exports.makeDataLayer = makeDataLayer;

package/lib/common/utxobased/db/Models/{ProcessorTransaction.js → TransactionData.js}

@@ -9,9 +9,7 @@ var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
 
 
 
- const fromEdgeTransaction = (
-  tx
-) => {
+ const fromEdgeTransaction = (tx) => {
   const otherParams = tx.otherParams 
   if (otherParams == null) throw new Error('Invalid transaction data')
   if (otherParams.psbt == null)
@@ -44,7 +42,7 @@ var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
     inputs: inputs,
     outputs: outputs,
     // We can leave ourIns/ourOuts blank because they'll be updated by the
-    // processor when receiving the transaction from blockbook.
+    // DataLayer when receiving the transaction from blockbook.
     // We may want to calculate these preemptively, but for now this will work.
     ourIns: [],
     ourOuts: [],
@@ -63,12 +61,12 @@ var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
  const toEdgeTransaction = async (
   args
 ) => {
-  const { tx, processor, walletTools, pluginInfo, walletId } = args
+  const { tx, dataLayer, walletTools, pluginInfo, walletId } = args
   const { currencyInfo } = pluginInfo
   const ourReceiveAddresses = []
   for (const out of tx.ourOuts) {
     const { scriptPubkey } = tx.outputs[parseInt(out)]
-    const address = await processor.fetchAddress(scriptPubkey)
+    const address = await dataLayer.fetchAddress(scriptPubkey)
 
     if (_optionalChain([address, 'optionalAccess', _ => _.path]) != null) {
       const { address: addrStr } = walletTools.scriptPubkeyToAddress({

package/lib/common/utxobased/db/types.js

@@ -15,7 +15,7 @@ var _keymanager = require('../keymanager/keymanager');
 
 
 
- const makeIAddress = (
+ const makeAddressData = (
   addressFields
 ) => {
   const { scriptPubkey, used = false, ...rest } = addressFields
@@ -28,7 +28,7 @@ var _keymanager = require('../keymanager/keymanager');
     lastTouched: 0,
     ...rest
   }
-}; exports.makeIAddress = makeIAddress
+}; exports.makeAddressData = makeAddressData
 
 
 
@@ -42,7 +42,7 @@ var _keymanager = require('../keymanager/keymanager');
 
 
 
- const asIUTXO = _cleaners.asObject({
+ const asUtxoData = _cleaners.asObject({
   id: _cleaners.asString,
   txid: _cleaners.asString,
   vout: _cleaners.asNumber,
@@ -53,7 +53,7 @@ var _keymanager = require('../keymanager/keymanager');
   scriptType: _keymanager.asScriptTypeEnum,
   blockHeight: _cleaners.asNumber,
   spent: _cleaners.asBoolean
-}); exports.asIUTXO = asIUTXO
+}); exports.asUtxoData = asUtxoData
 
 
 

package/lib/common/utxobased/db/util/utxo.js

@@ -6,14 +6,14 @@ var _keymanager = require('../../keymanager/keymanager');
 
 
 
- const utxoFromProcessorTransactionInput = async (
-  processor,
-  processorTransaction,
+ const utxoFromTransactionDataInput = async (
+  dataLayer,
+  transactionData,
   inputIndex
 ) => {
-  const input = processorTransaction.inputs[inputIndex]
+  const input = transactionData.inputs[inputIndex]
   const { scriptPubkey } = input
-  const address = await processor.fetchAddress(scriptPubkey)
+  const address = await dataLayer.fetchAddress(scriptPubkey)
 
   if (address == null)
     throw new Error(`Cannot find address for ${scriptPubkey}`)
@@ -34,7 +34,7 @@ var _keymanager = require('../../keymanager/keymanager');
       case _keymanager.BIP43PurposeTypeEnum.Airbitz:
       case _keymanager.BIP43PurposeTypeEnum.Legacy: {
         return {
-          script: processorTransaction.hex,
+          script: transactionData.hex,
           scriptType:
             redeemScript != null ? _keymanager.ScriptTypeEnum.p2sh : _keymanager.ScriptTypeEnum.p2pkh
         }
@@ -64,7 +64,7 @@ var _keymanager = require('../../keymanager/keymanager');
     script,
     redeemScript,
     scriptType,
-    blockHeight: processorTransaction.blockHeight,
+    blockHeight: transactionData.blockHeight,
     spent: true
   }
-}; exports.utxoFromProcessorTransactionInput = utxoFromProcessorTransactionInput
+}; exports.utxoFromTransactionDataInput = utxoFromTransactionDataInput