@hiveio/dhive 1.3.5 → 1.3.6

package/lib/health-tracker.d.ts

@@ -38,6 +38,12 @@ export interface HealthTrackerOptions {
      * Default: 2 minutes.
      */
     headBlockTtlMs?: number;
+    /**
+     * Default duration (ms) to skip a node after receiving a 429 response,
+     * used when the server doesn't provide a Retry-After header.
+     * Default: 10 seconds.
+     */
+    defaultRateLimitMs?: number;
 }
 export declare class NodeHealthTracker {
     private health;
@@ -49,6 +55,7 @@ export declare class NodeHealthTracker {
     private readonly maxApiFailuresBeforeCooldown;
     private readonly staleBlockThreshold;
     private readonly headBlockTtlMs;
+    private readonly defaultRateLimitMs;
     constructor(options?: HealthTrackerOptions);
     private getOrCreate;
     /**
@@ -61,6 +68,16 @@ export declare class NodeHealthTracker {
      * Increments both the global consecutive failure counter and the API-specific counter.
      */
     recordFailure(node: string, api: string): void;
+    /**
+     * Record that a node returned HTTP 429 (Too Many Requests).
+     * The node will be skipped until the rate limit expires.
+     * @param retryAfterSeconds Value from the Retry-After header, or undefined to use default.
+     */
+    recordRateLimit(node: string, retryAfterSeconds?: number): void;
+    /**
+     * Check if a node is currently rate-limited (429 cooldown active).
+     */
+    isRateLimited(node: string): boolean;
     /**
      * Record an API/plugin-specific failure (e.g. "method not found", "plugin not enabled").
      * Only increments the per-API counter, NOT the global consecutive failure counter.

package/lib/health-tracker.js

@@ -11,7 +11,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 class NodeHealthTracker {
     constructor(options = {}) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         this.health = new Map();
         this.bestKnownHeadBlock = 0;
         this.bestKnownHeadBlockTime = 0;
@@ -21,6 +21,7 @@ class NodeHealthTracker {
         this.maxApiFailuresBeforeCooldown = (_d = options.maxApiFailuresBeforeCooldown) !== null && _d !== void 0 ? _d : 2;
         this.staleBlockThreshold = (_e = options.staleBlockThreshold) !== null && _e !== void 0 ? _e : 30;
         this.headBlockTtlMs = (_f = options.headBlockTtlMs) !== null && _f !== void 0 ? _f : 120000;
+        this.defaultRateLimitMs = (_g = options.defaultRateLimitMs) !== null && _g !== void 0 ? _g : 10000;
     }
     getOrCreate(node) {
         let state = this.health.get(node);
@@ -55,6 +56,29 @@ class NodeHealthTracker {
         state.lastFailure = Date.now();
         this.incrementApiFailure(state, api);
     }
+    /**
+     * Record that a node returned HTTP 429 (Too Many Requests).
+     * The node will be skipped until the rate limit expires.
+     * @param retryAfterSeconds Value from the Retry-After header, or undefined to use default.
+     */
+    recordRateLimit(node, retryAfterSeconds) {
+        const state = this.getOrCreate(node);
+        const delayMs = retryAfterSeconds != null
+            ? retryAfterSeconds * 1000
+            : this.defaultRateLimitMs;
+        state.rateLimit = { retryAfter: Date.now() + delayMs };
+        state.consecutiveFailures++;
+        state.lastFailure = Date.now();
+    }
+    /**
+     * Check if a node is currently rate-limited (429 cooldown active).
+     */
+    isRateLimited(node) {
+        const state = this.health.get(node);
+        if (!(state === null || state === void 0 ? void 0 : state.rateLimit))
+            return false;
+        return Date.now() < state.rateLimit.retryAfter;
+    }
     /**
      * Record an API/plugin-specific failure (e.g. "method not found", "plugin not enabled").
      * Only increments the per-API counter, NOT the global consecutive failure counter.
@@ -93,6 +117,10 @@ class NodeHealthTracker {
         if (!state)
             return true; // Unknown nodes are assumed healthy
         const now = Date.now();
+        // Check rate-limit cooldown (429 received)
+        if (state.rateLimit && now < state.rateLimit.retryAfter) {
+            return false;
+        }
         // Check overall node health (consecutive failures)
         if (state.consecutiveFailures >= this.maxFailuresBeforeCooldown) {
             if (now - state.lastFailure < this.nodeCooldownMs) {

package/lib/utils.js

@@ -155,7 +155,7 @@ function nextNode(nodes, currentIndex) {
  * - NEVER retry after timeout or response errors to prevent double-broadcasting
  */
 function retryingFetch(currentAddress, allAddresses, opts, timeout, failoverThreshold, consoleOnFailover, backoff, fetchTimeout, retryContext) {
-    var _a;
+    var _a, _b, _c;
     return __awaiter(this, void 0, void 0, function* () {
         const { healthTracker, api, isBroadcast } = retryContext || {};
         const logFailover = (_a = retryContext === null || retryContext === void 0 ? void 0 : retryContext.consoleOnFailover) !== null && _a !== void 0 ? _a : consoleOnFailover;
@@ -182,12 +182,34 @@ function retryingFetch(currentAddress, allAddresses, opts, timeout, failoverThre
         while (true) {
             const node = orderedNodes[nodeIndex];
             try {
+                // Skip nodes that are currently rate-limited
+                if (healthTracker && healthTracker.isRateLimited(node)) {
+                    lastError = new Error(`Node ${node} is rate-limited, skipping`);
+                    if (healthTracker && api)
+                        healthTracker.recordFailure(node, api);
+                    throw lastError;
+                }
                 if (fetchTimeout) {
                     opts.timeout = fetchTimeout(nodesTriedInRound);
                 }
                 const response = yield cross_fetch_1.default(node, opts);
                 if (!response.ok) {
-                    // Some Hive nodes return non-200 HTTP status (500, 502, 503, 429, etc.)
+                    // Handle 429 — record rate limit and fail over immediately
+                    if (response.status === 429) {
+                        const retryAfterHeader = (_c = (_b = response.headers) === null || _b === void 0 ? void 0 : _b.get) === null || _c === void 0 ? void 0 : _c.call(_b, 'retry-after');
+                        const retryAfterSec = retryAfterHeader ? parseInt(retryAfterHeader, 10) : undefined;
+                        if (healthTracker) {
+                            healthTracker.recordRateLimit(node, !isNaN(retryAfterSec) ? retryAfterSec : undefined);
+                        }
+                        throw new Error(`HTTP 429: Too Many Requests`);
+                    }
+                    // Handle 503 — don't parse JSON body, just fail over
+                    if (response.status === 503) {
+                        if (healthTracker && api)
+                            healthTracker.recordFailure(node, api);
+                        throw new Error(`HTTP 503: Service Temporarily Unavailable`);
+                    }
+                    // Some Hive nodes return non-200 HTTP status (500, 502, etc.)
                     // but still include a valid JSON-RPC response in the body.
                     // This happens when a node is overloaded — it processes the transaction
                     // but returns an error HTTP status. For broadcasts, ignoring the body
@@ -200,7 +222,7 @@ function retryingFetch(currentAddress, allAddresses, opts, timeout, failoverThre
                             return { response: resJson, currentAddress: node };
                         }
                     }
-                    catch (_b) {
+                    catch (_d) {
                         // JSON parse failed, fall through to error handling
                     }
                     const statusText = response.statusText || `status code ${response.status}`;
@@ -247,6 +269,11 @@ function retryingFetch(currentAddress, allAddresses, opts, timeout, failoverThre
                     // Unrecognized error type — don't failover, throw immediately
                     throw error;
                 }
+                // Small delay between node attempts within a round to prevent
+                // flooding all nodes when multiple concurrent requests fail over
+                if (totalNodes > 1 && nodesTriedInRound > 0) {
+                    yield sleep(50 + Math.random() * 50); // 50-100ms jitter
+                }
                 // Try next node immediately (no backoff within a round)
                 if (totalNodes > 1) {
                     nodeIndex = nextNode(orderedNodes, nodeIndex);

package/lib/version.js

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

package/package.json

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