@hiveio/dhive 1.3.1-beta → 1.3.3

package/lib/utils.js

@@ -52,8 +52,10 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const cross_fetch_1 = require("cross-fetch");
 const stream_1 = require("stream");
-// TODO: Add more errors that should trigger a failover
-const timeoutErrors = ['timeout', 'ENOTFOUND', 'ECONNREFUSED', 'database lock', 'CERT_HAS_EXPIRED', 'EHOSTUNREACH', 'ECONNRESET', 'ERR_TLS_CERT_ALTNAME_INVALID'];
+// Errors that indicate the request never reached the server — safe to retry even for broadcasts
+const PRE_CONNECTION_ERRORS = ['ECONNREFUSED', 'ENOTFOUND', 'EHOSTUNREACH', 'EAI_AGAIN'];
+// All errors that should trigger failover for read operations
+const FAILOVER_ERRORS = [...PRE_CONNECTION_ERRORS, 'timeout', 'database lock', 'CERT_HAS_EXPIRED', 'ECONNRESET', 'ERR_TLS_CERT_ALTNAME_INVALID', 'ETIMEDOUT', 'EPIPE', 'EPROTO'];
 /**
  * Return a promise that will resove when a specific event is emitted.
  */
@@ -114,70 +116,175 @@ function copy(object) {
 }
 exports.copy = copy;
 /**
- * Fetch API wrapper that retries until timeout is reached.
+ * Check if an error code indicates the request never reached the server.
  */
-function retryingFetch(currentAddress, allAddresses, opts, timeout, failoverThreshold, consoleOnFailover, backoff, fetchTimeout) {
+function isPreConnectionError(error) {
+    if (!error || !error.code)
+        return false;
+    return PRE_CONNECTION_ERRORS.some((code) => error.code.includes(code));
+}
+/**
+ * Check if an error should trigger failover for read operations.
+ * Matches any known network/timeout error, or errors with no code (HTTP errors).
+ */
+function shouldFailover(error) {
+    if (!error)
+        return true;
+    // HTTP errors (from !response.ok) have no .code — they should trigger failover
+    if (!error.code)
+        return true;
+    return FAILOVER_ERRORS.some((code) => error.code.includes(code));
+}
+/**
+ * Get the next node in the ordered list (wraps around).
+ */
+function nextNode(nodes, currentIndex) {
+    return (currentIndex + 1) % nodes.length;
+}
+/**
+ * Smart fetch with immediate failover and per-node health tracking.
+ *
+ * For read operations:
+ * - On failure, immediately try the next healthy node (no backoff within a round)
+ * - After trying all nodes once (one round), apply backoff before the next round
+ * - Stop after failoverThreshold rounds
+ *
+ * For broadcast operations:
+ * - Only retry on pre-connection errors (ECONNREFUSED, ENOTFOUND, etc.)
+ *   where we know the request never reached the server
+ * - NEVER retry after timeout or response errors to prevent double-broadcasting
+ */
+function retryingFetch(currentAddress, allAddresses, opts, timeout, failoverThreshold, consoleOnFailover, backoff, fetchTimeout, retryContext) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
-        let start = Date.now();
-        let tries = 0;
+        const { healthTracker, api, isBroadcast } = retryContext || {};
+        const logFailover = (_a = retryContext === null || retryContext === void 0 ? void 0 : retryContext.consoleOnFailover) !== null && _a !== void 0 ? _a : consoleOnFailover;
+        // Build ordered node list: healthy nodes first, then unhealthy as fallback
+        let orderedNodes;
+        if (Array.isArray(allAddresses) && allAddresses.length > 1) {
+            orderedNodes = healthTracker
+                ? healthTracker.getOrderedNodes(allAddresses, api)
+                : [...allAddresses];
+        }
+        else {
+            orderedNodes = Array.isArray(allAddresses) ? allAddresses : [allAddresses];
+        }
+        // Always start from the healthiest node (index 0 of the ordered list).
+        // The health tracker already sorted nodes with healthy ones first,
+        // so starting from 0 ensures we use the best available node.
+        let nodeIndex = 0;
+        const totalNodes = orderedNodes.length;
+        const startTime = Date.now();
+        let nodesTriedInRound = 0;
         let round = 0;
-        do {
+        let lastError;
+        // tslint:disable-next-line: no-constant-condition
+        while (true) {
+            const node = orderedNodes[nodeIndex];
             try {
                 if (fetchTimeout) {
-                    opts.timeout = fetchTimeout(tries);
+                    opts.timeout = fetchTimeout(nodesTriedInRound);
                 }
-                const response = yield cross_fetch_1.default(currentAddress, opts);
+                const response = yield cross_fetch_1.default(node, opts);
                 if (!response.ok) {
+                    // Support for Drone: HTTP 500 with valid JSON-RPC response
+                    if (response.status === 500) {
+                        try {
+                            const resJson = yield response.json();
+                            if (resJson.jsonrpc === '2.0') {
+                                if (healthTracker && api)
+                                    healthTracker.recordSuccess(node, api);
+                                return { response: resJson, currentAddress: node };
+                            }
+                        }
+                        catch (_b) {
+                            // JSON parse failed, fall through to error handling
+                        }
+                    }
                     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
                 }
-                return { response: yield response.json(), currentAddress };
+                const responseJson = yield response.json();
+                // Record success in health tracker
+                if (healthTracker && api) {
+                    healthTracker.recordSuccess(node, api);
+                }
+                return { response: responseJson, currentAddress: node };
             }
             catch (error) {
-                if (timeout !== 0 && Date.now() - start > timeout) {
-                    if ((!error || !error.code) && Array.isArray(allAddresses)) {
-                        // If error is empty or not code is present, it means rpc is down => switch
-                        currentAddress = failover(currentAddress, allAddresses, currentAddress, consoleOnFailover);
+                lastError = error;
+                // Record failure in health tracker
+                if (healthTracker && api) {
+                    healthTracker.recordFailure(node, api);
+                }
+                // === BROADCAST SAFETY ===
+                // For broadcasts, only retry if the request definitely never reached the server.
+                // If there's any chance the server received it, throw immediately to prevent
+                // double-broadcasting (e.g. double transfers, double votes).
+                if (isBroadcast) {
+                    if (isPreConnectionError(error) && totalNodes > 1) {
+                        // Safe to try another node — request never left the client
+                        nodeIndex = nextNode(orderedNodes, nodeIndex);
+                        nodesTriedInRound++;
+                        if (nodesTriedInRound >= totalNodes) {
+                            // Tried all nodes, give up for broadcasts
+                            throw error;
+                        }
+                        if (logFailover) {
+                            // tslint:disable-next-line: no-console
+                            console.log(`Broadcast failover to: ${orderedNodes[nodeIndex]} (${error.code}, request never sent)`);
+                        }
+                        continue;
                     }
-                    else {
-                        const isFailoverError = timeoutErrors.filter((fe) => error && error.code && error.code.includes(fe)).length > 0;
-                        if (isFailoverError &&
-                            Array.isArray(allAddresses) &&
-                            allAddresses.length > 1) {
-                            if (round < failoverThreshold) {
-                                start = Date.now();
-                                tries = -1;
-                                if (failoverThreshold > 0) {
-                                    round++;
-                                }
-                                currentAddress = failover(currentAddress, allAddresses, currentAddress, consoleOnFailover);
-                            }
-                            else {
-                                error.message = `[${error.code}] tried ${failoverThreshold} times with ${allAddresses.join(',')}`;
+                    // Timeout, HTTP error, or unknown error — request may have been received.
+                    // Do NOT retry. Throw immediately.
+                    throw error;
+                }
+                // === READ OPERATION FAILOVER ===
+                if (!shouldFailover(error)) {
+                    // Unrecognized error type — don't failover, throw immediately
+                    throw error;
+                }
+                // Try next node immediately (no backoff within a round)
+                if (totalNodes > 1) {
+                    nodeIndex = nextNode(orderedNodes, nodeIndex);
+                    nodesTriedInRound++;
+                    if (nodesTriedInRound >= totalNodes) {
+                        // Completed a full round through all nodes
+                        nodesTriedInRound = 0;
+                        // failoverThreshold=0 means retry forever (only timeout can stop it)
+                        if (failoverThreshold > 0) {
+                            round++;
+                            if (round >= failoverThreshold) {
+                                error.message = `All ${totalNodes} nodes failed after ${failoverThreshold} rounds. ` +
+                                    `Last error: [${error.code || 'HTTP'}] ${error.message}. ` +
+                                    `Nodes: ${orderedNodes.join(', ')}`;
                                 throw error;
                             }
                         }
-                        else {
-                            // tslint:disable-next-line: no-console
-                            console.error(`Didn't failover for error ${error.code ? 'code' : 'message'}: [${error.code || error.message}]`);
+                        // Check total timeout before starting next round
+                        if (timeout !== 0 && Date.now() - startTime > timeout) {
                             throw error;
                         }
+                        // Backoff between rounds (not between individual node attempts)
+                        yield sleep(backoff(round));
+                    }
+                    if (logFailover) {
+                        // tslint:disable-next-line: no-console
+                        console.log(`Switched Hive RPC: ${orderedNodes[nodeIndex]} (previous: ${node}, error: ${error.code || error.message})`);
+                    }
+                }
+                else {
+                    // Single node: use backoff and retry same node (legacy behavior)
+                    if (timeout !== 0 && Date.now() - startTime > timeout) {
+                        throw error;
                     }
+                    yield sleep(backoff(nodesTriedInRound++));
                 }
-                yield sleep(backoff(tries++));
             }
-        } while (true);
+        }
     });
 }
 exports.retryingFetch = retryingFetch;
-const failover = (url, urls, currentAddress, consoleOnFailover) => {
-    const index = urls.indexOf(url);
-    const targetUrl = urls.length === index + 1 ? urls[0] : urls[index + 1];
-    if (consoleOnFailover) {
-        // tslint:disable-next-line: no-console
-        console.log(`Switched Hive RPC: ${targetUrl} (previous: ${currentAddress})`);
-    }
-    return targetUrl;
-};
 // Hack to be able to generate a valid witness_set_properties op
 // Can hopefully be removed when hived's JSON representation is fixed
 const ByteBuffer = require("@ecency/bytebuffer");

package/lib/version.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = '1.3.0';
+exports.default = '1.3.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiveio/dhive",
-  "version": "1.3.1-beta",
+  "version": "1.3.3",
   "description": "Hive blockchain RPC client library",
   "author": "hive-network",
   "license": "BSD-3-Clause-No-Military-License",