edge-currency-plugins 3.12.0 → 3.14.0

package/lib/common/constants.js

@@ -3,7 +3,10 @@
 // Fees
  const FEES_PATH = 'fees.json'; exports.FEES_PATH = FEES_PATH
  const MAX_FEE = 999999999.0; exports.MAX_FEE = MAX_FEE
- const LOW_FEE = 2; exports.LOW_FEE = LOW_FEE
+// Fee rates are sat/vB and may be fractional. Three decimal places matches the
+// precision of the mempool.space `/fees/precise` endpoint, which is the most
+// precise rate source we consume.
+ const FEE_RATE_DECIMALS = 3; exports.FEE_RATE_DECIMALS = FEE_RATE_DECIMALS
  const MAX_HIGH_DELAY = 200; exports.MAX_HIGH_DELAY = MAX_HIGH_DELAY
  const MAX_STANDARD_DELAY = 6; exports.MAX_STANDARD_DELAY = MAX_STANDARD_DELAY
  const MIN_STANDARD_DELAY = 2; exports.MIN_STANDARD_DELAY = MIN_STANDARD_DELAY

package/lib/common/fees/calcMinerFeePerByte.js

@@ -1,6 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});var _biggystring = require('biggystring');
 
 
+var _constants = require('../constants');
 
 
 
@@ -29,10 +30,20 @@
   } = feeInfo
   let { highFee, lowFee, standardFeeHigh, standardFeeLow } = feeInfo
 
-  highFee = _biggystring.round.call(void 0, _biggystring.mul.call(void 0, highFee, highFeeFudgeFactor), 0)
-  lowFee = _biggystring.round.call(void 0, _biggystring.mul.call(void 0, lowFee, lowFeeFudgeFactor), 0)
-  standardFeeHigh = _biggystring.round.call(void 0, _biggystring.mul.call(void 0, standardFeeHigh, standardFeeHighFudgeFactor), 0)
-  standardFeeLow = _biggystring.round.call(void 0, _biggystring.mul.call(void 0, standardFeeLow, standardFeeLowFudgeFactor), 0)
+  // Fee rates may be fractional, so these round to FEE_RATE_DECIMALS places
+  // rather than to a whole sat/vB. biggystring's `round` takes the power of ten
+  // to round at, so the precision is negated: -3 means three decimal places.
+  const feeRatePlaces = -_constants.FEE_RATE_DECIMALS
+  highFee = _biggystring.round.call(void 0, _biggystring.mul.call(void 0, highFee, highFeeFudgeFactor), feeRatePlaces)
+  lowFee = _biggystring.round.call(void 0, _biggystring.mul.call(void 0, lowFee, lowFeeFudgeFactor), feeRatePlaces)
+  standardFeeHigh = _biggystring.round.call(void 0, 
+    _biggystring.mul.call(void 0, standardFeeHigh, standardFeeHighFudgeFactor),
+    feeRatePlaces
+  )
+  standardFeeLow = _biggystring.round.call(void 0, 
+    _biggystring.mul.call(void 0, standardFeeLow, standardFeeLowFudgeFactor),
+    feeRatePlaces
+  )
 
   switch (networkFeeOption) {
     case 'low':
@@ -55,7 +66,10 @@
 
       // Add this much to the low fee = (amountDiffFromLow * lowHighFeeDiff) / lowHighAmountDiff)
       const temp1 = _biggystring.mul.call(void 0, amountDiffFromLow, lowHighFeeDiff)
-      const addFeeToLow = _biggystring.div.call(void 0, temp1, lowHighAmountDiff)
+      // `div` defaults to zero decimal places, which would truncate the
+      // interpolated rate back to a whole sat/vB. Unlike `round` above, its
+      // precision argument is the number of decimal places, not a power of ten.
+      const addFeeToLow = _biggystring.div.call(void 0, temp1, lowHighAmountDiff, _constants.FEE_RATE_DECIMALS)
       return _biggystring.add.call(void 0, standardFeeLow, addFeeToLow)
     }
 

package/lib/common/fees/calcReplacementFeeRate.js

@@ -0,0 +1,25 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _constants = require('../constants');
+
+/**
+ * Calculate the sat/vB fee rate for a transaction that replaces another by fee:
+ * double the rate the replaced transaction paid.
+ *
+ * The rate rounds up to FEE_RATE_DECIMALS places. Rounding up means the
+ * replacement never pays less than double, and a positive rate never rounds
+ * down to zero, which the UTXO picker would accept as a valid rate. Rounding
+ * to a fixed number of places keeps the rate readable where it is reported as
+ * `feeRateUsed`.
+ *
+ * @param replacedFee The fee the replaced transaction paid, in satoshis
+ * @param replacedVBytes The replaced transaction's virtual size
+ * @returns {number}
+ */
+ const calcReplacementFeeRate = (
+  replacedFee,
+  replacedVBytes
+) => {
+  const scale = 10 ** _constants.FEE_RATE_DECIMALS
+  // The fee and size are whole numbers, so this division is exact whenever the
+  // scaled rate is, and Math.ceil sees no floating point noise.
+  return Math.ceil((replacedFee * 2 * scale) / replacedVBytes) / scale
+}; exports.calcReplacementFeeRate = calcReplacementFeeRate

package/lib/common/fees/processMempoolSpaceFees.js

@@ -1,7 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
 var _cleaners = require('cleaners');
 
-var _constants = require('../constants');
 
 
  const asMempoolSpaceFees = _cleaners.asObject.call(void 0, {
@@ -12,13 +11,16 @@ var _constants = require('../constants');
 
 /**
  * Calculates the FeeRates object from MempoolSpace
- * Sets the minimum of LOW_FEE on all fee levels
  * @param fees
  * @returns Partial<FeeRates>
  */
 
-const STANDARD_FEE_HIGH_MULTIPLIER = 1.3
-const HIGH_FEE_MULTIPLIER = 2
+// The `/fees/precise` endpoint reports rates with up to three decimal places,
+// so the multipliers run through biggystring rather than JS numbers. A float
+// multiply would reintroduce noise (0.575 * 1.3 is 0.7474999999999999) that
+// biggystring carries exactly.
+const STANDARD_FEE_HIGH_MULTIPLIER = '1.3'
+const HIGH_FEE_MULTIPLIER = '2'
 
  const processMempoolSpaceFees = (fees) => {
   let mempoolFees
@@ -28,19 +30,13 @@ const HIGH_FEE_MULTIPLIER = 2
     return null
   }
 
-  const { fastestFee, halfHourFee } = mempoolFees
-
-  const lowFee = halfHourFee.toString()
-  const standardFeeLow = fastestFee.toString()
-  const standardFeeHigh = Math.round(
-    fastestFee * STANDARD_FEE_HIGH_MULTIPLIER
-  ).toString()
-  const highFee = Math.round(fastestFee * HIGH_FEE_MULTIPLIER).toString()
+  const fastestFee = mempoolFees.fastestFee.toString()
+  const halfHourFee = mempoolFees.halfHourFee.toString()
 
   return {
-    lowFee: bs.max(lowFee, _constants.LOW_FEE.toString()),
-    standardFeeLow: bs.max(standardFeeLow, _constants.LOW_FEE.toString()),
-    standardFeeHigh: bs.max(standardFeeHigh, _constants.LOW_FEE.toString()),
-    highFee: bs.max(highFee, _constants.LOW_FEE.toString())
+    lowFee: halfHourFee,
+    standardFeeLow: fastestFee,
+    standardFeeHigh: bs.mul(fastestFee, STANDARD_FEE_HIGH_MULTIPLIER),
+    highFee: bs.mul(fastestFee, HIGH_FEE_MULTIPLIER)
   }
 }; exports.processMempoolSpaceFees = processMempoolSpaceFees

package/lib/common/plugin/types.js

@@ -313,6 +313,12 @@ var _types3 = require('../utxobased/db/types');
 
 
 
+
+
+
+
+
+
 
 
 

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

@@ -91,6 +91,47 @@ var _constants = require('./constants');
 
 
 
+
+
+
+
+
+
+/**
+ * How long broadcastTx gives the first wave (our sockets and Edge's own HTTP
+ * servers) before it also sends the transaction to the NOWNodes HTTP servers.
+ * NOWNodes is a third party, so it should only see a transaction when our own
+ * infrastructure has not already carried it. A first wave that fails outright
+ * does not wait this long; the second wave fires as soon as it has all failed.
+ */
+ const NOWNODES_BROADCAST_DELAY_MS = 2000; exports.NOWNODES_BROADCAST_DELAY_MS = NOWNODES_BROADCAST_DELAY_MS
+
+/**
+ * Every broadcast attempt is counted toward "all attempts failed", so every
+ * attempt must settle. Sockets already expire a request after 30 seconds
+ * (Socket.ts); HTTP has no such bound of its own, and a server that accepts
+ * the connection and never answers would otherwise hold the whole broadcast
+ * open. This mirrors the socket figure.
+ */
+ const BROADCAST_ATTEMPT_TIMEOUT_MS = 30000; exports.BROADCAST_ATTEMPT_TIMEOUT_MS = BROADCAST_ATTEMPT_TIMEOUT_MS
+
+const withTimeout = async ( 
+  promise,
+  ms,
+  message
+) => {
+  let timer
+  const timeout = new Promise((resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(message))
+    }, ms)
+  })
+  try {
+    return await Promise.race([promise, timeout])
+  } finally {
+    if (timer != null) clearTimeout(timer)
+  }
+}
 
  function makeServerStates(config) {
   const {
@@ -103,6 +144,7 @@ var _constants = require('./constants');
     walletInfo
   } = config
   const { serverConfigs = [] } = pluginInfo.engineInfo
+  const { broadcastTimeoutMs = exports.BROADCAST_ATTEMPT_TIMEOUT_MS } = config
   log('Making server states')
 
   const serverStatesCache = {}
@@ -366,112 +408,171 @@ var _constants = require('./constants');
   }
 
   const instance = {
+    /**
+     * Broadcast in two waves:
+     *
+     * 1. Immediately: every blockbook in the connection cache (whether or not
+     *    its socket has finished connecting; a queued request transmits as
+     *    soon as the socket opens, and times out otherwise) and every
+     *    `blockbook` HTTP server, which are Edge's own.
+     * 2. After NOWNODES_BROADCAST_DELAY_MS, or as soon as every first-wave
+     *    attempt has failed, whichever comes first: the `blockbook-nownode`
+     *    HTTP servers. These are a third party and only see the transaction
+     *    when our own infrastructure has not already carried it.
+     *
+     * The first success wins. The promise rejects only after every attempt
+     * has failed. Earlier versions only used HTTP when no socket was
+     * connected, so a single socket that looked connected but never answered
+     * could fail the whole broadcast without any HTTP attempt.
+     */
     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
-        )
-
-        // 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 httpAttempt = (
+          uri,
+          headers
+        ) => ({
+          uri,
+          run: async () => {
+            const response = await io.fetchCors(`${uri}/api/v2/sendtx/`, {
+              method: 'POST',
+              headers,
+              body: transaction.signedTx
+            })
+            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).result
           }
+        })
+
+        //
+        // Build both waves up front, so `attempts` is the full count and an
+        // all-fail first wave cannot reject before the second has run.
+        //
+        const firstWave = []
+        const secondWave = []
+
+        for (const uri of Object.keys(serverStatesCache)) {
+          const { blockbook } = serverStatesCache[uri]
+          if (blockbook == null) continue
+          firstWave.push({
+            uri,
+            run: async () => (await blockbook.broadcastTx(transaction)).result
+          })
         }
 
-        // 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.
+        // 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
+        for (const config of serverConfigs) {
+          if (config.type === 'blockbook-nownode') {
+            // NOWNodes requires the key, and the key must not go anywhere else:
+            if (nowNodesApiKey == null) {
+              log.warn(
+                'broadcastTx: skipping NOWNodes HTTP servers (no nowNodesApiKey)'
+              )
+              continue
+            }
+            for (const uri of config.uris) {
+              secondWave.push(httpAttempt(uri, { 'api-key': nowNodesApiKey }))
+            }
+          } else {
+            for (const uri of config.uris) {
+              firstWave.push(httpAttempt(uri, {}))
+            }
+          }
+        }
+
+        const attempts = firstWave.length + secondWave.length
+        if (attempts === 0) {
+          reject(
+            new Error('No available connections. Check your internet signal.')
+          )
+          return
+        }
+
+        let resolved = false
+        let failures = 0
+        const failureMessages = []
+        let secondWaveFired = false
+        let secondWaveTimer
+
+        const onSuccess = (uri, txid) => {
+          if (resolved) return
+          resolved = true
+          if (secondWaveTimer != null) clearTimeout(secondWaveTimer)
+          log(`broadcastTx succeeded via ${uri}: ${txid}`)
+          resolve(txid)
+        }
+        const onFailure = (uri, error) => {
+          const message = error instanceof Error ? error.message : String(error)
+          failureMessages.push(`${uri}: ${message}`)
+          log.warn(`broadcastTx attempt failed for ${uri}: ${message}`)
+          failures++
+          if (resolved) return
+          if (failures === attempts) {
+            log.error(
+              `broadcastTx fail: ${JSON.stringify(
+                transaction
+              )}\n${failureMessages.join('\n')}`
+            )
             reject(
-              new Error('No available connections. Check your internet signal.')
+              error instanceof Error
+                ? error
+                : new Error(`Broadcast failed: ${failureMessages.join('; ')}`)
             )
             return
           }
-
-          // If there is no key for the NowNode servers:
-          if (nowNodesApiKey == null) {
-            reject(new Error('Missing connection key for fallback servers.'))
-            return
+          // Every first-wave attempt has failed, so there is nothing left to
+          // wait for. Fire the second wave now rather than sit out the delay.
+          if (!secondWaveFired && failures >= firstWave.length) {
+            fireSecondWave()
           }
-
-          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
+        }
+        const fire = (attempt) => {
+          withTimeout(
+            attempt.run(),
+            broadcastTimeoutMs,
+            `Timeout for broadcast to ${attempt.uri}`
+          )
+            .then(txid => {
+              onSuccess(attempt.uri, txid)
             })
-              .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)
-                }
-              })
-          }
+            .catch((error) => {
+              onFailure(attempt.uri, error)
+            })
+        }
+        const fireSecondWave = () => {
+          if (secondWaveFired) return
+          secondWaveFired = true
+          if (secondWaveTimer != null) clearTimeout(secondWaveTimer)
+          if (secondWave.length === 0) return
+          log.warn(
+            'broadcastTx: first wave has not resolved, trying NOWNodes servers'
+          )
+          for (const attempt of secondWave) fire(attempt)
+        }
+
+        for (const attempt of firstWave) fire(attempt)
+        if (firstWave.length === 0) {
+          // Nothing of our own to try first:
+          fireSecondWave()
+        } else if (secondWave.length > 0) {
+          secondWaveTimer = setTimeout(
+            fireSecondWave,
+            exports.NOWNODES_BROADCAST_DELAY_MS
+          )
         }
       })
     },

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

@@ -20,6 +20,7 @@ var _edgecorejs = require('edge-core-js');
 
 var _filterUndefined = require('../../../util/filterUndefined');
 var _unixTime = require('../../../util/unixTime');
+var _calcReplacementFeeRate = require('../../fees/calcReplacementFeeRate');
 var _makeFees = require('../../fees/makeFees');
 var _EngineEmitter = require('../../plugin/EngineEmitter');
 var _Metadata = require('../../plugin/Metadata');
@@ -187,9 +188,12 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
       // Must not be confirmed or dropped.
       if (replacedTx.blockHeight !== 0) return null
 
-      // Double the fee used for the RBF transaction:
+      // Double the fee rate used by the replaced transaction:
       const vBytes = _utils.transactionSizeFromHex.call(void 0, replacedTx.hex)
-      const newFeeRate = Math.round((parseInt(replacedTx.fees) / vBytes) * 2)
+      const newFeeRate = _calcReplacementFeeRate.calcReplacementFeeRate.call(void 0, 
+        parseInt(replacedTx.fees),
+        vBytes
+      )
 
       const replacedTxInputs = replacedTx.inputs
       // Recreate UTXOs from DataLayer transaction and mark them as unspent:
@@ -631,7 +635,16 @@ var _UtxoWalletTools = require('./UtxoWalletTools');
         freshAddress.segwitAddress)), () => (
         freshAddress.publicAddress))
 
-      const feeRate = parseInt(await fees.getRate(edgeSpendInfo))
+      // Fee rates may be fractional (e.g. a 1.8 sat/vB custom fee), so this
+      // must not be truncated to an integer. The picker rounds the satoshi
+      // amounts it derives from this rate up to whole satoshis. Number rejects
+      // any string that is not entirely a number, where parseFloat would read a
+      // comma-decimal '1,8' as 1 and charge the wrong rate without an error.
+      const feeRateString = await fees.getRate(edgeSpendInfo)
+      const feeRate = Number(feeRateString)
+      if (!isFinite(feeRate) || feeRate <= 0) {
+        throw new Error(`Invalid fee rate: ${feeRateString}`)
+      }
 
       let maxUtxo
       if (txOptions.CPFP != null) {

package/lib/common/utxobased/info/bitcoin.js

@@ -20,8 +20,8 @@ const currencyInfo = {
 
   // Explorers:
   blockExplorer: 'https://blockchair.com/bitcoin/block/%s',
-  addressExplorer: 'https://blockchair.com/bitcoin/address/%s',
-  transactionExplorer: 'https://blockchair.com/bitcoin/transaction/%s',
+  addressExplorer: 'https://mempool.space/address/%s',
+  transactionExplorer: 'https://mempool.space/tx/%s',
 
   denominations: [
     { name: 'BTC', multiplier: '100000000', symbol: '₿' },
@@ -53,7 +53,7 @@ const currencyInfo = {
 const engineInfo = {
   serverConfigs: [
     {
-      type: 'blockbook-nownode',
+      type: 'blockbook',
       uris: ['https://btc-wusa1.edge.app', 'https://btc-eu1.edge.app']
     },
     {
@@ -65,7 +65,7 @@ const engineInfo = {
   forks: ['bitcoincash', 'bitcoingold'],
   gapLimit: 25,
   feeUpdateInterval: 60000,
-  mempoolSpaceFeeInfoServer: 'https://mempool.space/api/v1/fees/recommended',
+  mempoolSpaceFeeInfoServer: 'https://mempool.space/api/v1/fees/precise',
   defaultFeeInfo: {
     lowFeeFudgeFactor: undefined,
     standardFeeLowFudgeFactor: undefined,

package/lib/common/utxobased/info/bitcoincash.js

@@ -53,7 +53,7 @@ const currencyInfo = {
 const engineInfo = {
   serverConfigs: [
     {
-      type: 'blockbook-nownode',
+      type: 'blockbook',
       uris: ['https://bch-eusa1.edge.app']
     },
     {

package/lib/common/utxobased/info/bitcointestnet.js

@@ -45,7 +45,7 @@ var _commonInfo = require('./commonInfo');
   forks: ['bitcoincash', 'bitcoingold'],
   gapLimit: 25,
   feeUpdateInterval: 60000,
-  mempoolSpaceFeeInfoServer: 'https://mempool.space/api/v1/fees/recommended',
+  mempoolSpaceFeeInfoServer: 'https://mempool.space/api/v1/fees/precise',
   defaultFeeInfo: {
     lowFeeFudgeFactor: undefined,
     standardFeeLowFudgeFactor: undefined,

package/lib/common/utxobased/info/bitcointestnet4.js

@@ -49,7 +49,7 @@ var _commonInfo = require('./commonInfo');
   gapLimit: 25,
   feeUpdateInterval: 60000,
   mempoolSpaceFeeInfoServer:
-    'https://mempool.space/testnet4/api/v1/fees/recommended',
+    'https://mempool.space/testnet4/api/v1/fees/precise',
   defaultFeeInfo: {
     lowFeeFudgeFactor: undefined,
     standardFeeLowFudgeFactor: undefined,

package/lib/common/utxobased/info/dash.js

@@ -52,7 +52,7 @@ const currencyInfo = {
 const engineInfo = {
   serverConfigs: [
     {
-      type: 'blockbook-nownode',
+      type: 'blockbook',
       uris: ['https://dash-wusa1.edge.app']
     },
     {

package/lib/common/utxobased/info/digibyte.js

@@ -46,7 +46,7 @@ const currencyInfo = {
 const engineInfo = {
   serverConfigs: [
     {
-      type: 'blockbook-nownode',
+      type: 'blockbook',
       uris: ['https://dgb-eu1.edge.app']
     },
     {

package/lib/common/utxobased/info/dogecoin.js

@@ -48,7 +48,7 @@ const currencyInfo = {
 const engineInfo = {
   serverConfigs: [
     {
-      type: 'blockbook-nownode',
+      type: 'blockbook',
       uris: ['https://doge-eusa1.edge.app']
     },
     {

package/lib/common/utxobased/info/ecash.js

@@ -32,7 +32,10 @@ const currencyInfo = {
   ..._commonInfo.legacyMemoInfo,
   defaultSettings: {
     customFeeSettings: ['satPerByte'],
-    blockbookServers: ['wss://blockbook.fabien.cash/websocket'],
+    blockbookServers: [
+      'wss://blockbook.fabien.cash/websocket',
+      'wss://xec-blockbook.nownodes.io/wss/%{nowNodesApiKey}'
+    ],
     enableCustomServers: false
   },
   displayName: 'eCash',

package/lib/common/utxobased/info/litecoin.js

@@ -20,8 +20,8 @@ var _commonInfo = require('./commonInfo');
 
   // Explorers:
   blockExplorer: 'https://blockchair.com/litecoin/block/%s',
-  addressExplorer: 'https://blockchair.com/litecoin/address/%s',
-  transactionExplorer: 'https://blockchair.com/litecoin/transaction/%s',
+  addressExplorer: 'https://litecoinspace.org/address/%s',
+  transactionExplorer: 'https://litecoinspace.org/tx/%s',
 
   denominations: [
     { name: 'LTC', multiplier: '100000000', symbol: 'Ł' },
@@ -50,7 +50,7 @@ var _commonInfo = require('./commonInfo');
  const engineInfo = {
   serverConfigs: [
     {
-      type: 'blockbook-nownode',
+      type: 'blockbook',
       uris: ['https://ltc-wusa1.edge.app']
     },
     {