@pioneer-platform/blockbook 8.4.0 → 8.5.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @pioneer-platform/blockbook
 
+## 8.5.0
+
+### Minor Changes
+
+- Automated minor version bump for all packages
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/loggerdog@8.5.0
+  - @pioneer-platform/nodes@8.5.0
+  - @pioneer-platform/pioneer-caip@9.4.0
+
+## 8.4.1
+
+### Patch Changes
+
+- Automated patch version bump for all packages
+- Updated dependencies
+  - @pioneer-platform/loggerdog@8.4.1
+  - @pioneer-platform/nodes@8.4.1
+  - @pioneer-platform/pioneer-caip@9.3.1
+
 ## 8.4.0
 
 ### Minor Changes

package/lib/index.d.ts

@@ -2,14 +2,36 @@ declare const TAG = " | blockbook-client | ";
 declare const Blockbook: any;
 declare const log: any;
 declare const fakeUa: any;
+declare const axiosLib: any;
 declare const Axios: any;
 declare const https: any;
 declare const nodes: any;
 declare const axios: any;
 declare let NOW_NODES_API: string | undefined;
-declare let BLOCKBOOK_URLS: any;
+interface NodeConfig {
+    url: string;
+    priority: number;
+    avgResponseTime: number;
+    successRate: number;
+    lastChecked: number;
+    isActive: boolean;
+    consecutiveFailures: number;
+    totalRequests: number;
+    successfulRequests: number;
+}
+interface CoinNodes {
+    [symbol: string]: NodeConfig[];
+}
+declare let BLOCKBOOK_NODES: CoinNodes;
 declare let BLOCKBOOK_SOCKETS: any;
-declare let add_custom_node: (coin: string, url: string) => boolean;
+declare let BLOCKBOOK_URLS: any;
+declare let add_custom_node: (coin: string, url: string, priority?: number) => boolean;
+declare let remove_node: (coin: string, url: string) => boolean;
+declare let set_node_priority: (coin: string, url: string, priority: number) => boolean;
+declare let get_node_stats: (coin?: string) => any;
+declare let reorder_nodes_by_performance: (coin: string) => void;
+declare let reorder_nodes_by_priority: (symbol: string) => void;
+declare let update_legacy_urls: (symbol: string) => void;
 declare let init_network: (servers?: any[]) => Promise<boolean>;
 declare let get_fees: (coin: string) => Promise<any>;
 declare let get_info_by_pubkey: (coin: string, pubkey: string, page?: string | undefined) => Promise<any>;
@@ -19,5 +41,6 @@ declare let get_txs_by_xpub: (coin: string, xpub: string) => Promise<any>;
 declare let broadcast_transaction: (coin: string, hex: string) => Promise<any>;
 declare let get_transaction: (coin: string, txid: string) => Promise<any>;
 declare let get_utxos_by_xpub: (coin: string, xpub: string) => Promise<any>;
+declare let update_node_performance: (coin: string, url: string, success: boolean, responseTime: number) => void;
 declare let get_balance_by_xpub: (coin: string, xpub: any) => Promise<number>;
 declare let get_node_info: () => Promise<boolean>;

package/lib/index.js

@@ -43,7 +43,8 @@ var TAG = " | blockbook-client | ";
 var Blockbook = require('blockbook-client').Blockbook;
 var log = require('@pioneer-platform/loggerdog')();
 var fakeUa = require('fake-useragent');
-var Axios = require('axios');
+var axiosLib = require('axios');
+var Axios = axiosLib.default || axiosLib;
 var https = require('https');
 var nodes = require("@pioneer-platform/nodes");
 var axios = Axios.create({
@@ -54,27 +55,29 @@ var axios = Axios.create({
 });
 // const axiosRetry = require('axios-retry');
 var NOW_NODES_API = process.env['NOW_NODES_API'];
-// axiosRetry(axios, {
-//     retries: 3, // number of retries
-//     retryDelay: (retryCount: number) => {
-//         log.error(TAG,`retry attempt: ${retryCount}`);
-//         return retryCount * 2000; // time interval between retries
-//     },
-//     retryCondition: (error: { response: { status: number; }; }) => {
-//         log.error(TAG,error)
-//         //@TODO mark node offline, and punish
-//         // if retry condition is not specified, by default idempotent requests are retried
-//         return error?.response?.status === 503;
-//     },
-// });
-var BLOCKBOOK_URLS = {};
+// Enhanced node management
+var BLOCKBOOK_NODES = {};
 var BLOCKBOOK_SOCKETS = {};
+// Legacy compatibility - will be populated from BLOCKBOOK_NODES
+var BLOCKBOOK_URLS = {};
 module.exports = {
     init: function (servers) {
         return init_network(servers);
     },
-    addNode: function (coin, url) {
-        return add_custom_node(coin, url);
+    addNode: function (coin, url, priority) {
+        return add_custom_node(coin, url, priority);
+    },
+    removeNode: function (coin, url) {
+        return remove_node(coin, url);
+    },
+    setPriority: function (coin, url, priority) {
+        return set_node_priority(coin, url, priority);
+    },
+    getNodeStats: function (coin) {
+        return get_node_stats(coin);
+    },
+    reorderNodes: function (coin) {
+        return reorder_nodes_by_performance(coin);
     },
     getInfo: function () {
         return get_node_info();
@@ -113,35 +116,124 @@ module.exports = {
         return broadcast_transaction(coin, hex);
     },
 };
-// Add a custom node at runtime
-var add_custom_node = function (coin, url) {
+// Enhanced node management functions
+var add_custom_node = function (coin, url, priority) {
     var symbol = coin.toUpperCase();
     var cleanUrl = url.replace(/\/$/, ''); // Remove trailing slash
-    // Store URLs as arrays if not already
-    if (typeof BLOCKBOOK_URLS[symbol] === 'string') {
-        BLOCKBOOK_URLS[symbol] = [BLOCKBOOK_URLS[symbol]];
-    }
-    if (!BLOCKBOOK_URLS[symbol]) {
-        BLOCKBOOK_URLS[symbol] = [];
+    // Initialize if not exists
+    if (!BLOCKBOOK_NODES[symbol]) {
+        BLOCKBOOK_NODES[symbol] = [];
     }
     // Check for duplicates
-    if (Array.isArray(BLOCKBOOK_URLS[symbol]) && BLOCKBOOK_URLS[symbol].includes(cleanUrl)) {
+    var existingNode = BLOCKBOOK_NODES[symbol].find(function (node) { return node.url === cleanUrl; });
+    if (existingNode) {
         log.warn("Node ".concat(cleanUrl, " already exists for ").concat(symbol));
         return false;
     }
-    if (Array.isArray(BLOCKBOOK_URLS[symbol])) {
-        BLOCKBOOK_URLS[symbol].push(cleanUrl);
+    // Determine priority
+    var defaultPriority = priority !== undefined ? priority :
+        (BLOCKBOOK_NODES[symbol].length === 0 ? 0 : Math.max.apply(Math, BLOCKBOOK_NODES[symbol].map(function (n) { return n.priority; })) + 10);
+    // Create new node config
+    var newNode = {
+        url: cleanUrl,
+        priority: defaultPriority,
+        avgResponseTime: 1000, // Default 1s
+        successRate: 100, // Optimistic start
+        lastChecked: Date.now(),
+        isActive: true,
+        consecutiveFailures: 0,
+        totalRequests: 0,
+        successfulRequests: 0
+    };
+    BLOCKBOOK_NODES[symbol].push(newNode);
+    // Sort by priority and update legacy compatibility
+    reorder_nodes_by_priority(symbol);
+    update_legacy_urls(symbol);
+    log.info("Added node for ".concat(symbol, ": ").concat(cleanUrl, " (priority: ").concat(defaultPriority, ")"));
+    log.info("".concat(symbol, " now has ").concat(BLOCKBOOK_NODES[symbol].length, " node(s)"));
+    return true;
+};
+var remove_node = function (coin, url) {
+    var symbol = coin.toUpperCase();
+    var cleanUrl = url.replace(/\/$/, '');
+    if (!BLOCKBOOK_NODES[symbol]) {
+        log.warn("No nodes configured for ".concat(symbol));
+        return false;
     }
-    else {
-        BLOCKBOOK_URLS[symbol] = [BLOCKBOOK_URLS[symbol], cleanUrl];
+    var initialLength = BLOCKBOOK_NODES[symbol].length;
+    BLOCKBOOK_NODES[symbol] = BLOCKBOOK_NODES[symbol].filter(function (node) { return node.url !== cleanUrl; });
+    if (BLOCKBOOK_NODES[symbol].length === initialLength) {
+        log.warn("Node ".concat(cleanUrl, " not found for ").concat(symbol));
+        return false;
     }
-    log.info("Added custom node for ".concat(symbol, ": ").concat(cleanUrl));
-    log.info("".concat(symbol, " now has ").concat(Array.isArray(BLOCKBOOK_URLS[symbol]) ? BLOCKBOOK_URLS[symbol].length : 1, " node(s)"));
+    update_legacy_urls(symbol);
+    log.info("Removed node for ".concat(symbol, ": ").concat(cleanUrl));
     return true;
 };
+var set_node_priority = function (coin, url, priority) {
+    var symbol = coin.toUpperCase();
+    var cleanUrl = url.replace(/\/$/, '');
+    if (!BLOCKBOOK_NODES[symbol]) {
+        log.warn("No nodes configured for ".concat(symbol));
+        return false;
+    }
+    var node = BLOCKBOOK_NODES[symbol].find(function (n) { return n.url === cleanUrl; });
+    if (!node) {
+        log.warn("Node ".concat(cleanUrl, " not found for ").concat(symbol));
+        return false;
+    }
+    node.priority = priority;
+    reorder_nodes_by_priority(symbol);
+    update_legacy_urls(symbol);
+    log.info("Updated priority for ".concat(symbol, " node ").concat(cleanUrl, ": ").concat(priority));
+    return true;
+};
+var get_node_stats = function (coin) {
+    if (coin) {
+        var symbol = coin.toUpperCase();
+        return BLOCKBOOK_NODES[symbol] || [];
+    }
+    return BLOCKBOOK_NODES;
+};
+var reorder_nodes_by_performance = function (coin) {
+    var symbol = coin.toUpperCase();
+    if (!BLOCKBOOK_NODES[symbol])
+        return;
+    // Sort by: active status, success rate, response time, then priority
+    BLOCKBOOK_NODES[symbol].sort(function (a, b) {
+        if (a.isActive !== b.isActive)
+            return b.isActive ? 1 : -1;
+        if (Math.abs(a.successRate - b.successRate) > 5)
+            return b.successRate - a.successRate;
+        if (Math.abs(a.avgResponseTime - b.avgResponseTime) > 500)
+            return a.avgResponseTime - b.avgResponseTime;
+        return a.priority - b.priority;
+    });
+    update_legacy_urls(symbol);
+};
+var reorder_nodes_by_priority = function (symbol) {
+    if (!BLOCKBOOK_NODES[symbol])
+        return;
+    BLOCKBOOK_NODES[symbol].sort(function (a, b) { return a.priority - b.priority; });
+};
+var update_legacy_urls = function (symbol) {
+    if (!BLOCKBOOK_NODES[symbol])
+        return;
+    var activeNodes = BLOCKBOOK_NODES[symbol].filter(function (n) { return n.isActive; });
+    if (activeNodes.length === 0) {
+        delete BLOCKBOOK_URLS[symbol];
+        return;
+    }
+    if (activeNodes.length === 1) {
+        BLOCKBOOK_URLS[symbol] = activeNodes[0].url;
+    }
+    else {
+        BLOCKBOOK_URLS[symbol] = activeNodes.map(function (n) { return n.url; });
+    }
+};
 var init_network = function (servers) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, SEED_NODES, blockbooks, i, blockbook, url, e_1;
+        var tag, SEED_NODES, blockbooks, i, blockbook, symbol, priority, url, symbol, nodes_1, e_1;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -163,11 +255,26 @@ var init_network = function (servers) {
                         blockbooks = SEED_NODES;
                     }
                     log.debug(tag, "blockbooks: ", blockbooks.length);
+                    // Clear existing nodes
+                    BLOCKBOOK_NODES = {};
+                    // Process nodes with priority assignment
                     for (i = 0; i < blockbooks.length; i++) {
                         blockbook = blockbooks[i];
-                        //get swagger
-                        if (blockbook && blockbook.service)
-                            BLOCKBOOK_URLS[blockbook.symbol.toUpperCase()] = blockbook.service;
+                        if (blockbook && blockbook.service) {
+                            symbol = blockbook.symbol.toUpperCase();
+                            priority = 50;
+                            if (blockbook.service.includes('nownodes.io')) {
+                                priority = 0; // Highest priority for NowNodes (fastest)
+                            }
+                            else if (blockbook.service.includes('zelcore.io')) {
+                                priority = 10; // Lower priority for Zelcore (slower)
+                            }
+                            else if (blockbook.service.includes('shapeshift.com')) {
+                                priority = 20; // Even lower for ShapeShift
+                            }
+                            // Add node with proper priority
+                            add_custom_node(symbol, blockbook.service, priority);
+                        }
                         if (blockbook && blockbook.websocket) {
                             url = blockbook.websocket.replace("/websocket", "");
                             url = blockbook.websocket.replace("wss://", "https://");
@@ -177,10 +284,17 @@ var init_network = function (servers) {
                             });
                         }
                         else {
-                            log.error(tag, "invalid unchained service: ", blockbook);
-                            // throw Error("invalid unchained service!")
+                            log.info(tag, "no websocket for: ", blockbook.symbol);
                         }
                     }
+                    // Log final configuration
+                    for (symbol in BLOCKBOOK_NODES) {
+                        nodes_1 = BLOCKBOOK_NODES[symbol];
+                        log.info(tag, "".concat(symbol, ": ").concat(nodes_1.length, " nodes configured"));
+                        nodes_1.forEach(function (node, idx) {
+                            log.info(tag, "  ".concat(idx + 1, ". ").concat(node.url, " (priority: ").concat(node.priority, ")"));
+                        });
+                    }
                     log.debug(tag, "BLOCKBOOK_URLS: ", BLOCKBOOK_URLS);
                     log.debug(tag, "BLOCKBOOK_SOCKETS: ", BLOCKBOOK_SOCKETS);
                     return [2 /*return*/, true];
@@ -381,41 +495,43 @@ var get_txs_by_xpub = function (coin, xpub) {
 var broadcast_transaction = function (coin, hex) {
     return __awaiter(this, void 0, void 0, function () {
         var tag, url, data, body, output, resp, e_7, errorMessage, statusCode, e_8;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     tag = TAG + " | broadcast_transaction | ";
-                    _b.label = 1;
+                    _c.label = 1;
                 case 1:
-                    _b.trys.push([1, 6, , 7]);
+                    _c.trys.push([1, 6, , 7]);
                     url = BLOCKBOOK_URLS[coin.toUpperCase()] + "/api/v2/sendtx/";
                     data = hex;
                     body = {
                         url: url,
                         headers: {
-                            'content-type': 'application/json',
+                            'content-type': 'text/plain',
                             'User-Agent': fakeUa()
                         },
                         method: 'POST',
-                        json: false,
                         data: data,
                     };
                     output = {
                         success: false
                     };
                     resp = void 0;
-                    _b.label = 2;
+                    _c.label = 2;
                 case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, axios(body)];
+                    _c.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, axios(body)
+                        // Only store serializable data, not the full axios response
+                    ];
                 case 3:
-                    resp = _b.sent();
-                    output.resp = resp;
+                    resp = _c.sent();
+                    // Only store serializable data, not the full axios response
+                    output.txid = ((_a = resp.data) === null || _a === void 0 ? void 0 : _a.result) || resp.data;
                     output.success = true;
                     return [3 /*break*/, 5];
                 case 4:
-                    e_7 = _b.sent();
+                    e_7 = _c.sent();
                     log.error(tag, "Broadcast error: ", e_7.message || e_7);
                     errorMessage = 'Unknown error occurred';
                     statusCode = null;
@@ -443,7 +559,7 @@ var broadcast_transaction = function (coin, hex) {
                     else if (e_7.request) {
                         // Request was made but no response received
                         errorMessage = 'Network error: No response received';
-                        log.debug(tag, "Request config: ", (_a = e_7.config) === null || _a === void 0 ? void 0 : _a.url);
+                        log.debug(tag, "Request config: ", (_b = e_7.config) === null || _b === void 0 ? void 0 : _b.url);
                     }
                     else {
                         // Something else happened
@@ -454,7 +570,7 @@ var broadcast_transaction = function (coin, hex) {
                     return [3 /*break*/, 5];
                 case 5: return [2 /*return*/, output];
                 case 6:
-                    e_8 = _b.sent();
+                    e_8 = _c.sent();
                     console.error(tag, 'error: ', e_8);
                     throw e_8;
                 case 7: return [2 /*return*/];
@@ -495,88 +611,123 @@ var get_transaction = function (coin, txid) {
         });
     });
 };
+// Enhanced UTXO function with priority-based sequential failover
 var get_utxos_by_xpub = function (coin, xpub) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, baseUrls, results, allUtxos, i, result, utxos, seen, uniqueUtxos, _i, allUtxos_1, utxo, key, url, body, resp, e_10;
-        var _this = this;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var tag, symbol, nodes_2, activeNodes, i, node, startTime, url, body, resp, responseTime, error_1, responseTime, errorMessage, e_10;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
                 case 0:
-                    tag = TAG + " | FA get_utxos_by_xpub | ";
-                    _b.label = 1;
+                    tag = TAG + " | get_utxos_by_xpub | ";
+                    _a.label = 1;
                 case 1:
-                    _b.trys.push([1, 6, , 7]);
-                    log.info(tag, "get_utxos_by_xpub: ", BLOCKBOOK_URLS);
-                    baseUrls = BLOCKBOOK_URLS[coin.toUpperCase()];
-                    if (!Array.isArray(baseUrls)) return [3 /*break*/, 3];
-                    // Multiple nodes - query each and merge results
-                    log.info(tag, "Querying ".concat(baseUrls.length, " nodes for ").concat(coin, "..."));
-                    return [4 /*yield*/, Promise.allSettled(baseUrls.map(function (baseUrl) { return __awaiter(_this, void 0, void 0, function () {
-                            var url, body, resp;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        url = baseUrl + "/api/v2/utxo/" + xpub + "?confirmed=false";
-                                        console.log("Querying node:", url);
-                                        body = {
-                                            method: 'GET',
-                                            url: url,
-                                        };
-                                        return [4 /*yield*/, axios(body)];
-                                    case 1:
-                                        resp = _a.sent();
-                                        return [2 /*return*/, resp.data];
-                                }
-                            });
-                        }); }))];
-                case 2:
-                    results = _b.sent();
-                    allUtxos = [];
-                    for (i = 0; i < results.length; i++) {
-                        result = results[i];
-                        if (result.status === 'fulfilled') {
-                            utxos = result.value;
-                            log.info(tag, "Node ".concat(i + 1, " returned ").concat(utxos.length, " UTXOs"));
-                            allUtxos.push.apply(allUtxos, utxos);
-                        }
-                        else {
-                            log.warn(tag, "Node ".concat(i + 1, " failed:"), (_a = result.reason) === null || _a === void 0 ? void 0 : _a.message);
-                        }
+                    _a.trys.push([1, 8, , 9]);
+                    symbol = coin.toUpperCase();
+                    nodes_2 = BLOCKBOOK_NODES[symbol];
+                    if (!nodes_2 || nodes_2.length === 0) {
+                        throw new Error("No nodes configured for ".concat(symbol));
                     }
-                    seen = new Set();
-                    uniqueUtxos = [];
-                    for (_i = 0, allUtxos_1 = allUtxos; _i < allUtxos_1.length; _i++) {
-                        utxo = allUtxos_1[_i];
-                        key = "".concat(utxo.txid, ":").concat(utxo.vout);
-                        if (!seen.has(key)) {
-                            seen.add(key);
-                            uniqueUtxos.push(utxo);
-                        }
+                    activeNodes = nodes_2.filter(function (n) { return n.isActive; }).sort(function (a, b) { return a.priority - b.priority; });
+                    if (activeNodes.length === 0) {
+                        throw new Error("No active nodes available for ".concat(symbol));
                     }
-                    log.info(tag, "Returning ".concat(uniqueUtxos.length, " unique UTXOs from ").concat(allUtxos.length, " total"));
-                    return [2 /*return*/, uniqueUtxos];
+                    log.info(tag, "Attempting UTXO query for ".concat(symbol, " with ").concat(activeNodes.length, " nodes available"));
+                    i = 0;
+                    _a.label = 2;
+                case 2:
+                    if (!(i < activeNodes.length)) return [3 /*break*/, 7];
+                    node = activeNodes[i];
+                    startTime = Date.now();
+                    _a.label = 3;
                 case 3:
-                    url = baseUrls + "/api/v2/utxo/" + xpub + "?confirmed=false";
-                    console.log("url:", url);
+                    _a.trys.push([3, 5, , 6]);
+                    log.info(tag, "Trying node ".concat(i + 1, "/").concat(activeNodes.length, ": ").concat(node.url, " (priority: ").concat(node.priority, ")"));
+                    url = node.url + "/api/v2/utxo/" + xpub + "?confirmed=false";
                     body = {
                         method: 'GET',
                         url: url,
+                        timeout: 15000 // 15s timeout per node
                     };
                     return [4 /*yield*/, axios(body)];
                 case 4:
-                    resp = _b.sent();
+                    resp = _a.sent();
+                    responseTime = Date.now() - startTime;
+                    // Update node performance metrics
+                    update_node_performance(symbol, node.url, true, responseTime);
+                    log.info(tag, "\u2705 Node ".concat(i + 1, " succeeded in ").concat(responseTime, "ms, returned ").concat(resp.data.length, " UTXOs"));
                     return [2 /*return*/, resp.data];
-                case 5: return [3 /*break*/, 7];
+                case 5:
+                    error_1 = _a.sent();
+                    responseTime = Date.now() - startTime;
+                    // Update node performance metrics
+                    update_node_performance(symbol, node.url, false, responseTime);
+                    errorMessage = error_1 instanceof Error ? error_1.message : String(error_1);
+                    log.warn(tag, "\u274C Node ".concat(i + 1, " failed after ").concat(responseTime, "ms:"), errorMessage);
+                    // If this is the last node, throw the error
+                    if (i === activeNodes.length - 1) {
+                        throw new Error("All ".concat(activeNodes.length, " nodes failed for ").concat(symbol, ". Last error: ").concat(errorMessage));
+                    }
+                    // Continue to next node
+                    return [3 /*break*/, 6];
                 case 6:
-                    e_10 = _b.sent();
+                    i++;
+                    return [3 /*break*/, 2];
+                case 7: return [3 /*break*/, 9];
+                case 8:
+                    e_10 = _a.sent();
                     console.error(tag, e_10);
                     throw e_10;
-                case 7: return [2 /*return*/];
+                case 9: return [2 /*return*/];
             }
         });
     });
 };
+// Performance tracking function
+var update_node_performance = function (coin, url, success, responseTime) {
+    var symbol = coin.toUpperCase();
+    var nodes = BLOCKBOOK_NODES[symbol];
+    if (!nodes)
+        return;
+    var node = nodes.find(function (n) { return n.url === url; });
+    if (!node)
+        return;
+    // Update counters
+    node.totalRequests++;
+    if (success) {
+        node.successfulRequests++;
+        node.consecutiveFailures = 0;
+    }
+    else {
+        node.consecutiveFailures++;
+    }
+    // Update success rate
+    node.successRate = (node.successfulRequests / node.totalRequests) * 100;
+    // Update average response time (exponential moving average)
+    var alpha = 0.3; // Weight for new sample
+    node.avgResponseTime = (alpha * responseTime) + ((1 - alpha) * node.avgResponseTime);
+    // Update health status
+    var wasActive = node.isActive;
+    // Deactivate if too many consecutive failures or very low success rate
+    if (node.consecutiveFailures >= 3 || (node.totalRequests >= 10 && node.successRate < 50)) {
+        node.isActive = false;
+        if (wasActive) {
+            log.warn("Deactivated node ".concat(url, " for ").concat(symbol, " (failures: ").concat(node.consecutiveFailures, ", success rate: ").concat(node.successRate.toFixed(1), "%)"));
+        }
+    }
+    // Reactivate if it was down but now working
+    if (!node.isActive && success && node.consecutiveFailures === 0) {
+        node.isActive = true;
+        log.info("Reactivated node ".concat(url, " for ").concat(symbol));
+    }
+    node.lastChecked = Date.now();
+    // Update legacy compatibility
+    update_legacy_urls(symbol);
+    // Auto-reorder nodes based on performance every 10 requests
+    if (node.totalRequests % 10 === 0) {
+        reorder_nodes_by_performance(symbol);
+        log.info("Auto-reordered ".concat(symbol, " nodes based on performance"));
+    }
+};
 var get_balance_by_xpub = function (coin, xpub) {
     return __awaiter(this, void 0, void 0, function () {
         var tag, output, balance, i, uxto, e_11;

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "@pioneer-platform/blockbook",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
+  "scripts": {
+    "test": "pnpm run build && node __tests__/test-module.js",
+    "start": "pnpm run build:live",
+    "build": "tsc -p .",
+    "prepublish": "tsc -p .",
+    "build:live": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/index.ts"
+  },
   "dependencies": {
-    "@pioneer-platform/loggerdog": "^8.4.0",
-    "@pioneer-platform/nodes": "^8.4.0",
-    "@pioneer-platform/pioneer-caip": "^9.3.0",
+    "@pioneer-platform/loggerdog": "^8.5.0",
+    "@pioneer-platform/nodes": "^8.5.0",
+    "@pioneer-platform/pioneer-caip": "^9.4.0",
     "@types/request-promise-native": "^1.0.17",
     "axiom": "^0.1.6",
     "axios": "^1.6.0",
@@ -24,12 +31,5 @@
     "keepkey"
   ],
   "author": "highlander",
-  "license": "MIT",
-  "scripts": {
-    "test": "pnpm run build && node __tests__/test-module.js",
-    "start": "pnpm run build:live",
-    "build": "tsc -p .",
-    "prepublish": "tsc -p .",
-    "build:live": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/index.ts"
-  }
+  "license": "MIT"
 }