@pioneer-platform/blockbook 8.18.0 → 8.20.0

package/lib/BlockbookWebSocket.d.ts

@@ -0,0 +1,43 @@
+import EventEmitter from 'events';
+export interface BlockbookMessage {
+    id: string;
+    method?: string;
+    params?: any;
+    data?: any;
+}
+export interface SubscribeAddressesResult {
+    subscribed: boolean;
+}
+export interface AddressNotification {
+    address: string;
+    tx?: any;
+}
+export declare class BlockbookWebSocket extends EventEmitter {
+    private ws?;
+    private url;
+    private connected;
+    private reconnecting;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private requestCounter;
+    private requestTimeout;
+    private pingInterval?;
+    private pendingRequests;
+    private subscriptions;
+    private methodToId;
+    constructor(url: string);
+    connect(): Promise<void>;
+    private handleMessage;
+    private request;
+    subscribeAddresses(addresses: string[], callback: (data: AddressNotification) => void | Promise<void>): Promise<SubscribeAddressesResult>;
+    unsubscribeAddresses(): Promise<SubscribeAddressesResult>;
+    ping(): Promise<any>;
+    getInfo(): Promise<any>;
+    disconnect(): Promise<void>;
+    private startPing;
+    private stopPing;
+    private rejectAllPending;
+    private scheduleReconnect;
+    isConnected(): boolean;
+}

package/lib/BlockbookWebSocket.js

@@ -0,0 +1,407 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockbookWebSocket = void 0;
+var ws_1 = __importDefault(require("ws"));
+var events_1 = __importDefault(require("events"));
+var BlockbookWebSocket = /** @class */ (function (_super) {
+    __extends(BlockbookWebSocket, _super);
+    function BlockbookWebSocket(url) {
+        var _this = _super.call(this) || this;
+        _this.connected = false;
+        _this.reconnecting = false;
+        _this.reconnectAttempts = 0;
+        _this.maxReconnectAttempts = 10;
+        _this.reconnectDelay = 2000;
+        _this.requestCounter = 0;
+        _this.requestTimeout = 5000;
+        // Track pending requests by ID
+        _this.pendingRequests = new Map();
+        // Track active subscriptions by ID
+        _this.subscriptions = new Map();
+        // Track subscription method to ID mapping (only one subscription per method)
+        _this.methodToId = new Map();
+        _this.url = url;
+        return _this;
+    }
+    BlockbookWebSocket.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (this.connected) {
+                    return [2 /*return*/];
+                }
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        try {
+                            _this.ws = new ws_1.default(_this.url);
+                            _this.ws.once('open', function () {
+                                _this.connected = true;
+                                _this.reconnectAttempts = 0;
+                                _this.emit('connected', _this.url);
+                                _this.startPing();
+                                resolve();
+                            });
+                            _this.ws.once('error', function (error) {
+                                console.error("WebSocket connection error for ".concat(_this.url, ":"), error);
+                                reject(error);
+                            });
+                            // Handle incoming messages - PROPERLY HANDLE BUFFERS
+                            _this.ws.on('message', function (data) {
+                                try {
+                                    // Convert Buffer to string in Bun
+                                    var messageStr = void 0;
+                                    if (Buffer.isBuffer(data)) {
+                                        messageStr = data.toString('utf8');
+                                    }
+                                    else if (typeof data === 'string') {
+                                        messageStr = data;
+                                    }
+                                    else if (Array.isArray(data)) {
+                                        messageStr = Buffer.concat(data).toString('utf8');
+                                    }
+                                    else {
+                                        _this.emit('error', new Error("Unexpected WebSocket data type: ".concat(typeof data)));
+                                        return;
+                                    }
+                                    var message = JSON.parse(messageStr);
+                                    _this.handleMessage(message);
+                                }
+                                catch (error) {
+                                    _this.emit('error', new Error("Failed to parse WebSocket message: ".concat(error)));
+                                }
+                            });
+                            _this.ws.on('close', function (code) {
+                                _this.connected = false;
+                                _this.stopPing();
+                                _this.rejectAllPending('WebSocket closed');
+                                _this.emit('disconnected', code);
+                                // Auto-reconnect if not a normal closure
+                                if (code !== 1000 && code !== 1005 && !_this.reconnecting) {
+                                    _this.scheduleReconnect();
+                                }
+                            });
+                            _this.ws.on('error', function (error) {
+                                // Don't emit error events that are already handled in other listeners
+                                // Just log them to avoid unhandled error crashes
+                                console.error("WebSocket error for ".concat(_this.url, ":"), error);
+                            });
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    })];
+            });
+        });
+    };
+    BlockbookWebSocket.prototype.handleMessage = function (message) {
+        var _this = this;
+        var id = message.id, data = message.data;
+        if (!id) {
+            this.emit('error', new Error('Received message without ID'));
+            return;
+        }
+        // Check if this is a response to a pending request
+        var pending = this.pendingRequests.get(id);
+        if (pending) {
+            this.pendingRequests.delete(id);
+            if (data === null || data === void 0 ? void 0 : data.error) {
+                pending.reject(new Error(data.error.message || 'Request failed'));
+            }
+            else {
+                pending.resolve(data);
+            }
+            return;
+        }
+        // Check if this is a subscription notification
+        var subscription = this.subscriptions.get(id);
+        if (subscription) {
+            if (data === null || data === void 0 ? void 0 : data.error) {
+                this.emit('error', new Error("Subscription error for ".concat(subscription.method, ": ").concat(data.error.message)));
+            }
+            else {
+                try {
+                    var result = subscription.callback(data);
+                    if (result instanceof Promise) {
+                        result.catch(function (error) {
+                            _this.emit('error', new Error("Subscription callback error: ".concat(error)));
+                        });
+                    }
+                }
+                catch (error) {
+                    this.emit('error', new Error("Subscription callback error: ".concat(error)));
+                }
+            }
+            return;
+        }
+        // Unknown message
+        this.emit('unknown-message', message);
+    };
+    BlockbookWebSocket.prototype.request = function (method, params) {
+        var _this = this;
+        if (!this.connected || !this.ws) {
+            return Promise.reject(new Error('WebSocket not connected'));
+        }
+        var id = (this.requestCounter++).toString();
+        var message = {
+            id: id,
+            method: method,
+            params: params,
+        };
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () {
+                if (_this.pendingRequests.has(id)) {
+                    _this.pendingRequests.delete(id);
+                    reject(new Error("Timeout waiting for ".concat(method, " response (id: ").concat(id, ")")));
+                }
+            }, _this.requestTimeout);
+            // Store pending request
+            _this.pendingRequests.set(id, {
+                resolve: function (value) {
+                    clearTimeout(timeout);
+                    resolve(value);
+                },
+                reject: function (reason) {
+                    clearTimeout(timeout);
+                    reject(reason);
+                },
+                method: method,
+            });
+            // Send request
+            _this.ws.send(JSON.stringify(message));
+        });
+    };
+    BlockbookWebSocket.prototype.subscribeAddresses = function (addresses, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var id, method, params, oldId, result, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        id = (this.requestCounter++).toString();
+                        method = 'subscribeAddresses';
+                        params = { addresses: addresses };
+                        // Store subscription BEFORE sending request
+                        this.subscriptions.set(id, { method: method, params: params, callback: callback });
+                        oldId = this.methodToId.get(method);
+                        if (oldId) {
+                            this.subscriptions.delete(oldId);
+                        }
+                        this.methodToId.set(method, id);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.request(method, params)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                    case 3:
+                        error_1 = _a.sent();
+                        // If request fails, clean up subscription
+                        this.subscriptions.delete(id);
+                        if (this.methodToId.get(method) === id) {
+                            this.methodToId.delete(method);
+                        }
+                        throw error_1;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BlockbookWebSocket.prototype.unsubscribeAddresses = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var method, id;
+            return __generator(this, function (_a) {
+                method = 'subscribeAddresses';
+                id = this.methodToId.get(method);
+                if (!id) {
+                    return [2 /*return*/, { subscribed: false }];
+                }
+                this.subscriptions.delete(id);
+                this.methodToId.delete(method);
+                return [2 /*return*/, this.request('unsubscribeAddresses', {})];
+            });
+        });
+    };
+    BlockbookWebSocket.prototype.ping = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('ping', {})];
+            });
+        });
+    };
+    BlockbookWebSocket.prototype.getInfo = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('getInfo', {})];
+            });
+        });
+    };
+    BlockbookWebSocket.prototype.disconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (!this.ws || !this.connected) {
+                    return [2 /*return*/];
+                }
+                this.reconnecting = false; // Prevent auto-reconnect
+                return [2 /*return*/, new Promise(function (resolve) {
+                        _this.ws.once('close', function () { return resolve(); });
+                        _this.ws.close(1000, 'Normal closure');
+                    })];
+            });
+        });
+    };
+    BlockbookWebSocket.prototype.startPing = function () {
+        var _this = this;
+        this.stopPing();
+        // Ping every 25 seconds to keep connection alive
+        this.pingInterval = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            var error_2;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.ping()];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_2 = _b.sent();
+                        this.emit('error', new Error("Ping failed: ".concat(error_2)));
+                        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.terminate(); // Force close to trigger reconnect
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); }, 25000);
+    };
+    BlockbookWebSocket.prototype.stopPing = function () {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = undefined;
+        }
+    };
+    BlockbookWebSocket.prototype.rejectAllPending = function (reason) {
+        this.pendingRequests.forEach(function (pending, id) {
+            pending.reject(new Error(reason));
+        });
+        this.pendingRequests.clear();
+    };
+    BlockbookWebSocket.prototype.scheduleReconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var delay, jitter;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (this.reconnecting) {
+                    return [2 /*return*/];
+                }
+                this.reconnectAttempts++;
+                if (this.reconnectAttempts > this.maxReconnectAttempts) {
+                    this.emit('error', new Error('Max reconnect attempts reached'));
+                    return [2 /*return*/];
+                }
+                this.reconnecting = true;
+                delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), 60000);
+                jitter = Math.random() * 1000;
+                this.emit('reconnecting', { attempt: this.reconnectAttempts, delay: delay });
+                setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                    var subsToRestore, _i, subsToRestore_1, sub, error_3;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 6, , 7]);
+                                return [4 /*yield*/, this.connect()];
+                            case 1:
+                                _a.sent();
+                                subsToRestore = Array.from(this.subscriptions.values());
+                                this.subscriptions.clear();
+                                this.methodToId.clear();
+                                _i = 0, subsToRestore_1 = subsToRestore;
+                                _a.label = 2;
+                            case 2:
+                                if (!(_i < subsToRestore_1.length)) return [3 /*break*/, 5];
+                                sub = subsToRestore_1[_i];
+                                if (!(sub.method === 'subscribeAddresses')) return [3 /*break*/, 4];
+                                return [4 /*yield*/, this.subscribeAddresses(sub.params.addresses, sub.callback)];
+                            case 3:
+                                _a.sent();
+                                _a.label = 4;
+                            case 4:
+                                _i++;
+                                return [3 /*break*/, 2];
+                            case 5:
+                                this.reconnecting = false;
+                                return [3 /*break*/, 7];
+                            case 6:
+                                error_3 = _a.sent();
+                                this.reconnecting = false;
+                                this.scheduleReconnect();
+                                return [3 /*break*/, 7];
+                            case 7: return [2 /*return*/];
+                        }
+                    });
+                }); }, delay + jitter);
+                return [2 /*return*/];
+            });
+        });
+    };
+    BlockbookWebSocket.prototype.isConnected = function () {
+        return this.connected;
+    };
+    return BlockbookWebSocket;
+}(events_1.default));
+exports.BlockbookWebSocket = BlockbookWebSocket;

package/lib/index.js

@@ -54,7 +54,7 @@ var axios = Axios.create({
     timeout: 30000 // 10 seconds
 });
 // const axiosRetry = require('axios-retry');
-var NOW_NODES_API = process.env['NOW_NODES_API'];
+var NOW_NODES_API = process.env['NOW_NODES_API'] || process.env['NOWNODES_API_KEY'];
 // Enhanced node management
 var BLOCKBOOK_NODES = {};
 var BLOCKBOOK_SOCKETS = {};
@@ -233,7 +233,7 @@ var update_legacy_urls = function (symbol) {
 };
 var init_network = function (servers) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, SEED_NODES, blockbooks, i, blockbook, symbol, priority, url, symbol, nodes_1, e_1;
+        var tag, SEED_NODES, blockbooks, i, blockbook, symbol, priority, wsUrl, symbol, nodes_1, e_1;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -276,10 +276,27 @@ var init_network = function (servers) {
                             add_custom_node(symbol, blockbook.service, priority);
                         }
                         if (blockbook && blockbook.websocket) {
-                            url = blockbook.websocket.replace("/websocket", "");
-                            url = blockbook.websocket.replace("wss://", "https://");
+                            wsUrl = blockbook.websocket;
+                            // Ensure proper wss:// protocol
+                            if (!wsUrl.startsWith('wss://') && !wsUrl.startsWith('ws://')) {
+                                wsUrl = 'wss://' + wsUrl;
+                            }
+                            // Append NowNodes API key if needed
+                            if (wsUrl.includes('nownodes.io') && NOW_NODES_API && !wsUrl.includes(NOW_NODES_API)) {
+                                // NowNodes format: wss://btc.nownodes.io/wss/API_KEY/websocket
+                                // Remove any existing /wss/ suffix, then add /wss/API_KEY
+                                wsUrl = wsUrl.replace(/\/wss\/?$/, ''); // Remove trailing /wss or /wss/
+                                wsUrl = wsUrl + '/wss/' + NOW_NODES_API;
+                                log.info(tag, "Configured NowNodes websocket for ".concat(blockbook.symbol, " with API key"));
+                            }
+                            // Ensure /websocket suffix (only if not already there)
+                            if (!wsUrl.endsWith('/websocket')) {
+                                wsUrl = wsUrl + '/websocket';
+                            }
+                            log.info(tag, "WebSocket URL for ".concat(blockbook.symbol, ": ").concat(wsUrl));
+                            // Use blockbook-client package
                             BLOCKBOOK_SOCKETS[blockbook.symbol.toUpperCase()] = new Blockbook({
-                                nodes: [url],
+                                nodes: [wsUrl],
                                 disableTypeValidation: true,
                             });
                         }
@@ -357,7 +374,7 @@ var get_info_by_pubkey = function (coin, pubkey, page) {
                     _a.trys.push([1, 3, , 4]);
                     if (!page)
                         page = "1";
-                    url = BLOCKBOOK_URLS[coin.toUpperCase()] + "/api/v2/xpub/" + pubkey + "?details=tokens&tokens=used&page=" + page;
+                    url = BLOCKBOOK_URLS[coin.toUpperCase()] + "/api/v2/xpub/" + pubkey + "?details=tokens&tokens=derived&gap=20&page=" + page;
                     log.debug(tag, "url: ", url);
                     body = {
                         method: 'GET',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/blockbook",
-  "version": "8.18.0",
+  "version": "8.20.0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {
@@ -12,8 +12,8 @@
   },
   "dependencies": {
     "@pioneer-platform/loggerdog": "^8.11.0",
-    "@pioneer-platform/nodes": "^8.17.0",
-    "@pioneer-platform/pioneer-caip": "^9.17.0",
+    "@pioneer-platform/nodes": "^8.19.0",
+    "@pioneer-platform/pioneer-caip": "^9.19.0",
     "@types/request-promise-native": "^1.0.17",
     "axiom": "^0.1.6",
     "axios": "^1.6.0",