edge-currency-plugins 3.2.1 → 3.3.0

package/lib/common/plugin/PluginState.js

@@ -142,15 +142,15 @@ const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call
     /**
      * 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() {

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,
@@ -101,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

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

@@ -87,10 +87,6 @@ var _constants = require('./constants');
 
 
 
-
-
-
-
 
 
 
@@ -226,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
@@ -233,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
@@ -259,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
         })
@@ -308,6 +310,50 @@ var _constants = require('./constants');
     }
   }
 
+  const deferredWithServerScoring = (
+    serverUri,
+    deferred
+  ) => {
+    const serverState = serverStatesCache[serverUri]
+    if (serverState == null)
+      throw new Error(`No blockbook connection with ${serverUri}`)
+
+    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
+  }
+
+  function* withServerScoring(
+    serverUri,
+    generator
+  ) {
+    const serverState = serverStatesCache[serverUri]
+    if (serverState == null)
+      throw new Error(`No blockbook connection with ${serverUri}`)
+
+    const queryTime = Date.now()
+    let result
+    try {
+      result = yield* generator
+      pluginState.serverScoreUp(serverUri, Date.now() - queryTime)
+    } catch (error) {
+      pluginState.serverScoreDown(serverUri)
+      throw error
+    }
+    return result
+  }
+
   const instance = {
     async broadcastTx(transaction) {
       return await new Promise((resolve, reject) => {
@@ -363,7 +409,7 @@ var _constants = require('./constants');
           //   /^http(?:s)?:/i
           // ])
 
-          const { nowNodeApiKey } = initOptions
+          const { nowNodesApiKey } = initOptions
           const nowNodeUris = serverConfigs
             .filter(config => config.type === 'blockbook-nownode')
             .map(config => config.uris)
@@ -383,7 +429,7 @@ var _constants = require('./constants');
           }
 
           // If there is no key for the NowNode servers:
-          if (nowNodeApiKey == null) {
+          if (nowNodesApiKey == null) {
             reject(new Error('Missing connection key for fallback servers.'))
             return
           }
@@ -395,7 +441,7 @@ var _constants = require('./constants');
             io.fetchCors(`${uri}/api/v2/sendtx/`, {
               method: 'POST',
               headers: {
-                'api-key': nowNodeApiKey
+                'api-key': nowNodesApiKey
               },
               body: transaction.signedTx
             })
@@ -451,9 +497,7 @@ var _constants = require('./constants');
       })
     },
 
-    setPickNextTaskCB(
-      callback
-    ) {
+    setPickNextTaskCB(callback) {
       pickNextTaskCB = callback
     },
 
@@ -505,13 +549,13 @@ var _constants = require('./constants');
     },
 
     watchAddresses(
-      uri,
+      serverUri,
       addresses,
       deferredAddressSub
     ) {
-      const serverState = serverStatesCache[uri]
+      const serverState = serverStatesCache[serverUri]
       if (serverState == null)
-        throw new Error(`No blockbook connection with ${uri}`)
+        throw new Error(`No blockbook connection with ${serverUri}`)
 
       const { blockbook } = serverState
 
@@ -520,109 +564,104 @@ var _constants = require('./constants');
         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(() => {
-          // 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)
+      deferred.promise.catch((err) => {
+        // Remove new addresses to the set of known addresses
+        for (const address of addresses) {
+          serverState.addresses.delete(address)
+        }
+        // Reject the deferredAddressSub promise if provided
+        _optionalChain([deferredAddressSub, 'optionalAccess', _2 => _2.reject, 'call', _3 => _3(err)])
+      })
+
+      blockbook.watchAddresses(
+        Array.from(serverState.addresses),
+        deferredWithServerScoring(serverUri, deferred)
+      )
     },
 
-    watchBlocks(uri) {
-      const serverState = serverStatesCache[uri]
+    watchBlocks(serverUri) {
+      const serverState = serverStatesCache[serverUri]
       if (serverState == null)
-        throw new Error(`No blockbook connection with ${uri}`)
+        throw new Error(`No blockbook connection with ${serverUri}`)
 
       const { blockbook } = serverState
 
       serverState.blockSubscriptionStatus = 'subscribing'
 
-      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)
+      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
+          })
+        })()
       )
     }
   }