edge-currency-plugins 3.12.0 → 3.13.0

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/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']
     },
     {

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/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/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']
     },
     {

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

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

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

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

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

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

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

@@ -45,7 +45,7 @@ var _commonInfo = require('./commonInfo');
  const engineInfo = {
   serverConfigs: [
     {
-      type: 'blockbook-nownode',
+      type: 'blockbook',
       uris: ['https://firo-eusa1.edge.app']
     },
     {

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

@@ -177,8 +177,16 @@ var _Socket = require('./Socket');
 
 
  {
-        const value = yield { ...message }
-        deferred.resolve(value)
+        try {
+          const value = yield { ...message }
+          deferred.resolve(value)
+        } catch (error) {
+          // The socket reports a failed request (an error response, the
+          // request timeout, the socket closing) by throwing into this
+          // generator. Without this catch the deferred stays pending forever
+          // and the caller hangs instead of seeing the failure.
+          deferred.reject(error)
+        }
         return false
       }
       const generator = taskGeneratorFn()

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

@@ -116,7 +116,13 @@ export interface EngineInfo {
     txSpecificHandling?: (tx: TransactionData, specialTx: unknown) => TransactionData;
 }
 export interface ServerConfig {
-    type: 'blockbook-nownode';
+    /**
+     * - `blockbook`: a public Blockbook HTTP server. No credentials are sent.
+     * - `blockbook-nownode`: a NOWNodes Blockbook HTTP server. Requests carry
+     *   the `nowNodesApiKey` init option as the `api-key` header, and the
+     *   server is skipped when no key is configured.
+     */
+    type: 'blockbook' | 'blockbook-nownode';
     uris: string[];
 }
 /**

package/lib/src/common/utxobased/engine/ServerStates.d.ts

@@ -23,6 +23,11 @@ interface ServerStateConfig {
     pluginInfo: PluginInfo;
     pluginState: PluginState;
     walletInfo: SafeWalletInfo;
+    /**
+     * Upper bound on any single broadcast attempt. Defaults to the same 30
+     * seconds the socket layer uses for a request. Exposed for tests.
+     */
+    broadcastTimeoutMs?: number;
 }
 export interface ServerStates {
     setPickNextTaskCB: (callback: (uri: string) => AsyncGenerator<WsTask<unknown> | boolean>) => void;
@@ -46,5 +51,21 @@ export interface ServerStates {
     transactionSpecialQueryTask: (serverUri: string, txId: string) => WsTaskGenerator<unknown>;
     utxoListQueryTask: (serverUri: string, address: string) => WsTaskGenerator<AddressUtxosResponse>;
 }
+/**
+ * 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.
+ */
+export declare const NOWNODES_BROADCAST_DELAY_MS = 2000;
+/**
+ * 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.
+ */
+export declare const BROADCAST_ATTEMPT_TIMEOUT_MS = 30000;
 export declare function makeServerStates(config: ServerStateConfig): ServerStates;
 export {};

package/lib/test/common/utxobased/engine/ServerStates.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-currency-plugins",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "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",