@pioneer-platform/blockbook 8.10.0 → 8.11.1

package/BLOCKBOOK_API.md

@@ -0,0 +1,347 @@
+# Blockbook API Documentation
+
+Comprehensive documentation of Blockbook REST API endpoints relevant to UTXO blockchain operations.
+
+## API Base URL Structure
+
+Blockbook servers use the following URL structure:
+```
+https://{server}/api/v2/{endpoint}
+```
+
+## Core Endpoints
+
+### 1. XPUB Information (`/api/v2/xpub/{xpub}`)
+
+Get extended public key (xpub) information including derived addresses, balances, and transaction history.
+
+**Endpoint**: `GET /api/v2/xpub/{xpub}`
+
+**Query Parameters**:
+
+| Parameter | Type | Values | Default | Description |
+|-----------|------|--------|---------|-------------|
+| `page` | int | ≥0 | 0 | Page number for pagination |
+| `pageSize` | int | 1-1000 | 1000 | Number of transactions per page |
+| `from` | int | block height | 0 | Filter transactions from this block height |
+| `to` | int | block height | 0 | Filter transactions to this block height |
+| `details` | string | `basic`, `tokens`, `tokenBalances`, `txids`, `txslight`, `txs` | `txids` | Level of detail to return |
+| `tokens` | string | `nonzero`, `used`, `derived` | `nonzero` | Which derived addresses to return |
+| `gap` | int | ≥0 | 0 | BIP44 gap limit for address derivation |
+| `secondary` | string | fiat currency | - | Secondary currency for fiat conversion |
+
+**Details Parameter Values**:
+- `basic` - Only basic account information (balance, txs count)
+- `tokens` - Basic info + list of derived addresses (tokens array)
+- `tokenBalances` - Basic info + addresses with their balances
+- `txids` - Basic info + addresses + transaction IDs (paginated)
+- `txslight` - Basic info + addresses + light transaction data (paginated)
+- `txs` - Basic info + addresses + full transaction data (paginated)
+
+**Tokens Parameter Values** (⚠️ CRITICAL for address index calculation):
+- `nonzero` - **DEFAULT** - Only returns addresses with current non-zero balance
+- `used` - Returns addresses that have been used (had transactions), even if balance is zero now
+- `derived` - Returns ALL derived addresses up to gap limit
+
+**Response Structure**:
+```typescript
+{
+  address: string,              // The xpub itself
+  balance: string,              // Current balance in satoshis
+  totalReceived: string,        // Total ever received
+  totalSent: string,            // Total ever sent
+  unconfirmedBalance: string,   // Unconfirmed balance
+  unconfirmedTxs: number,       // Number of unconfirmed txs
+  txs: number,                  // Total transaction count
+  usedTokens: number,           // Number of addresses that have been used
+  tokens: Array<{
+    type: string,               // "XPUBAddress" (string, not numeric!)
+    name: string,               // The derived address
+    path: string,               // BIP44 path: m/purpose'/coin'/account'/change/index
+    transfers: number,          // Number of transfers for this address
+    decimals: number            // Token decimals (8 for BTC)
+  }>
+}
+```
+
+**BIP44 Path Format**: `m/purpose'/coin_type'/account'/change/address_index`
+- `purpose` - 44 (legacy), 49 (wrapped segwit), 84 (native segwit)
+- `coin_type` - 0 (BTC), 2 (LTC), 3 (DOGE), 5 (DASH), 145 (BCH), etc.
+- `account` - Usually 0
+- `change` - **0 for receive addresses, 1 for change addresses**
+- `address_index` - Sequential index starting from 0
+
+**CRITICAL ISSUE**: By default, blockbook uses `tokens=nonzero` which only returns addresses with current balance. For wallets that have spent all their funds, this returns NO addresses even if they have transaction history!
+
+**SOLUTION**: Always use `?details=tokens&tokens=used` or `?details=tokens&tokens=derived` to get complete address information.
+
+**Example Requests**:
+
+```bash
+# Get basic info only (no addresses)
+GET /api/v2/xpub/{xpub}?details=basic
+
+# Get ALL used addresses (RECOMMENDED for address index calculation)
+GET /api/v2/xpub/{xpub}?details=tokens&tokens=used
+
+# Get ALL derived addresses up to gap limit
+GET /api/v2/xpub/{xpub}?details=tokens&tokens=derived&gap=20
+
+# Get full transaction history with used addresses
+GET /api/v2/xpub/{xpub}?details=txs&tokens=used&page=0&pageSize=50
+```
+
+### 2. Address Information (`/api/v2/address/{address}`)
+
+Get information about a single address.
+
+**Endpoint**: `GET /api/v2/address/{address}`
+
+**Query Parameters**: Same as xpub endpoint
+
+**Response Structure**: Similar to xpub but for single address
+
+### 3. UTXO Query (`/api/v2/utxo/{xpub_or_address}`)
+
+Get unspent transaction outputs for an address or xpub.
+
+**Endpoint**: `GET /api/v2/utxo/{xpub_or_address}`
+
+**Query Parameters**:
+
+| Parameter | Type | Values | Default | Description |
+|-----------|------|--------|---------|-------------|
+| `confirmed` | boolean | true/false | false | Return only confirmed UTXOs |
+| `gap` | int | ≥0 | 0 | BIP44 gap limit for xpub derivation |
+
+**Response Structure**:
+```typescript
+Array<{
+  txid: string,
+  vout: number,
+  value: string,           // Value in satoshis
+  height: number,
+  confirmations: number,
+  address: string,
+  path: string,            // BIP44 path (for xpub queries)
+  lockTime: number,
+  coinbase: boolean
+}>
+```
+
+### 4. Transaction Query (`/api/v2/tx/{txid}`)
+
+Get detailed information about a specific transaction.
+
+**Endpoint**: `GET /api/v2/tx/{txid}`
+
+**Response**: Full transaction details including inputs, outputs, confirmations
+
+### 5. Fee Estimation (`/api/v2/estimatefee/{blocks}`)
+
+Get estimated fee rate for confirmation within specified number of blocks.
+
+**Endpoint**: `GET /api/v2/estimatefee/{blocks}`
+
+**Example**: `/api/v2/estimatefee/1` (fastest), `/api/v2/estimatefee/6` (average)
+
+**Response**:
+```typescript
+{
+  result: string  // Fee rate in BTC/kB (or -1 if unavailable)
+}
+```
+
+**Note**: Fee estimation may return `-1` if the node doesn't have enough data. Always have fallback default fees.
+
+### 6. Fee Statistics (`/api/v2/feestats/`)
+
+Get comprehensive fee statistics from recent blocks.
+
+**Endpoint**: `GET /api/v2/feestats/`
+
+**Response**: Detailed fee statistics for different confirmation targets
+
+### 7. Broadcast Transaction (`/api/v2/sendtx/`)
+
+Broadcast a signed transaction to the network.
+
+**Endpoint**: `POST /api/v2/sendtx/`
+
+**Body**: Raw transaction hex (text/plain)
+
+**Response**:
+```typescript
+{
+  result: string  // Transaction ID (txid) if successful
+}
+```
+
+### 8. Block Information (`/api/v2/block/{height_or_hash}`)
+
+Get information about a specific block.
+
+**Endpoint**: `GET /api/v2/block/{height_or_hash}`
+
+### 9. Balance History (`/api/v2/balancehistory/{xpub_or_address}`)
+
+Get historical balance data for charting and analytics.
+
+**Endpoint**: `GET /api/v2/balancehistory/{xpub_or_address}`
+
+**Query Parameters**:
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `from` | timestamp | Start time (unix timestamp) |
+| `to` | timestamp | End time (unix timestamp) |
+| `groupBy` | int | Group interval in seconds (default: 3600) |
+| `fiatcurrency` | string | Currency code for fiat conversion |
+| `gap` | int | BIP44 gap limit for xpub |
+
+## Common Issues and Solutions
+
+### Issue 1: Empty `tokens` Array Despite Transaction History
+
+**Problem**: Calling `/api/v2/xpub/{xpub}?details=tokens` returns `usedTokens: 0` and empty `tokens: []` array even though `txs: 25`.
+
+**Cause**: Default `tokens=nonzero` parameter only returns addresses with current non-zero balance. If wallet has spent all funds, no addresses are returned.
+
+**Solution**: Always use `tokens=used` or `tokens=derived`:
+```bash
+GET /api/v2/xpub/{xpub}?details=tokens&tokens=used
+```
+
+### Issue 2: Incorrect Change Address Index Calculation
+
+**Problem**: Change address index is calculated as 0 when it should be higher.
+
+**Cause**: Using the `type` field (which is a string "XPUBAddress") instead of parsing the BIP44 path.
+
+**Solution**: Parse the `path` field to determine if address is receive (change=0) or change (change=1):
+```javascript
+const pathParts = token.path.split('/');  // e.g. "m/44'/0'/0'/1/5"
+const changeIndicator = parseInt(pathParts[3], 10);  // 0 = receive, 1 = change
+const addressIndex = parseInt(pathParts[4], 10);     // 5
+```
+
+### Issue 3: Missing Pagination for Large Wallets
+
+**Problem**: Only getting first page of transactions for active wallets.
+
+**Cause**: Not implementing pagination logic.
+
+**Solution**: Check `totalPages` in response and loop through all pages:
+```javascript
+let page = 0;
+let allTxs = [];
+do {
+  const response = await getXpubInfo(xpub, {details: 'txs', page, pageSize: 50});
+  allTxs = allTxs.concat(response.transactions);
+  page++;
+} while (page < response.totalPages);
+```
+
+## Performance Considerations
+
+### Node Selection and Failover
+
+- NowNodes: Priority 0 (fastest, rate limited)
+- Zelcore: Priority 10 (slower, unlimited)
+- ShapeShift: Priority 20 (slower, public)
+
+Implement failover logic to try multiple nodes in priority order.
+
+### Response Time Optimization
+
+- Use `details=basic` or `details=tokens` for quick queries (no transaction data)
+- Use `details=txids` instead of `details=txs` when only txids are needed
+- Implement caching for frequently accessed xpubs
+- Use pagination to avoid large responses
+
+### Rate Limiting
+
+Public blockbook nodes have rate limits:
+- Implement exponential backoff for retries
+- Distribute requests across multiple nodes
+- Cache responses appropriately
+
+## Integration Best Practices
+
+### 1. Always Request Used Addresses
+
+```javascript
+const xpubInfo = await blockbook.getPubkeyInfo(coin, xpub);
+// Add tokens=used to the URL
+```
+
+### 2. Parse Paths, Not Type Field
+
+```javascript
+// WRONG - type is a string "XPUBAddress"
+if (token.type === 1) { /* change address */ }
+
+// CORRECT - parse the BIP44 path
+const pathParts = token.path.split('/');
+const changeIndicator = parseInt(pathParts[3].replace("'", ""), 10);
+if (changeIndicator === 1) { /* change address */ }
+```
+
+### 3. Handle Empty Responses
+
+```javascript
+if (!data.tokens || data.tokens.length === 0) {
+  if (data.txs > 0) {
+    console.warn(`Wallet has ${data.txs} transactions but no address data!`);
+    console.warn(`Did you forget tokens=used parameter?`);
+  }
+  return { changeIndex: 0 };  // Safe fallback
+}
+```
+
+### 4. Implement Failover Logic
+
+```javascript
+const nodes = ['node1.example.com', 'node2.example.com', 'node3.example.com'];
+for (const node of nodes) {
+  try {
+    return await fetchFromNode(node, xpub);
+  } catch (err) {
+    console.error(`Node ${node} failed:`, err);
+    continue;  // Try next node
+  }
+}
+throw new Error('All nodes failed');
+```
+
+## Migration Guide
+
+### From Current Implementation to Fixed Implementation
+
+**Current (Broken)**:
+```javascript
+// Doesn't request used addresses
+const url = `${BLOCKBOOK_URL}/api/v2/xpub/${xpub}`;
+
+// Relies on numeric type field
+if (token.type === 1) { /* change */ }
+```
+
+**Fixed (Working)**:
+```javascript
+// Requests all used addresses
+const url = `${BLOCKBOOK_URL}/api/v2/xpub/${xpub}?details=tokens&tokens=used`;
+
+// Parses BIP44 path correctly
+const pathParts = token.path.split('/');
+const changeIndicator = parseInt(pathParts[3].replace("'", ""), 10);
+if (changeIndicator === 1) { /* change */ }
+```
+
+## Additional Resources
+
+- [Blockbook GitHub Repository](https://github.com/trezor/blockbook)
+- [BIP32 - Hierarchical Deterministic Wallets](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)
+- [BIP44 - Multi-Account Hierarchy](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki)
+- [BIP49 - Derivation for P2WPKH-nested-in-P2SH](https://github.com/bitcoin/bips/blob/master/bip-0049.mediawiki)
+- [BIP84 - Derivation for P2WPKH](https://github.com/bitcoin/bips/blob/master/bip-0084.mediawiki)

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @pioneer-platform/blockbook
 
+## 8.11.1
+
+### Patch Changes
+
+- cache work
+
+## 8.11.0
+
+### Minor Changes
+
+- Automated minor version bump for all packages
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/loggerdog@8.11.0
+  - @pioneer-platform/nodes@8.11.0
+  - @pioneer-platform/pioneer-caip@9.10.0
+
 ## 8.10.0
 
 ### Minor Changes

package/lib/index.d.ts

@@ -36,7 +36,7 @@ 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>;
 declare let get_txids_by_address: (coin: string, address: string, page?: number) => Promise<any>;
-declare let get_info_by_address: (coin: string, address: string, filter?: string) => Promise<any>;
+declare let get_info_by_address: (coin: string, address: string, filter?: string, options?: any) => Promise<any>;
 declare let get_txs_by_xpub: (coin: string, xpub: string) => Promise<any>;
 declare let broadcast_transaction: (coin: string, hex: string) => Promise<{
     success: boolean;

package/lib/index.js

@@ -94,8 +94,8 @@ module.exports = {
     getTransaction: function (coin, txid) {
         return get_transaction(coin, txid);
     },
-    getAddressInfo: function (coin, address, filter) {
-        return get_info_by_address(coin, address, filter);
+    getAddressInfo: function (coin, address, filter, options) {
+        return get_info_by_address(coin, address, filter, options);
     },
     getPubkeyInfo: function (coin, pubkey, filter) {
         return get_info_by_pubkey(coin, pubkey, filter);
@@ -357,7 +357,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;
+                    url = BLOCKBOOK_URLS[coin.toUpperCase()] + "/api/v2/xpub/" + pubkey + "?details=tokens&tokens=used&page=" + page;
                     log.debug(tag, "url: ", url);
                     body = {
                         method: 'GET',
@@ -371,7 +371,15 @@ var get_info_by_pubkey = function (coin, pubkey, page) {
                 case 2:
                     resp = _a.sent();
                     log.debug(tag, "resp: ", resp);
-                    //TODO paginate?
+                    // Validate that we got the tokens array
+                    if (!resp.data.tokens || !Array.isArray(resp.data.tokens)) {
+                        log.warn(tag, "\u26A0\uFE0F  Blockbook response missing tokens array for ".concat(coin, " xpub ").concat(pubkey.substring(0, 20), "..."));
+                        log.warn(tag, "Response has ".concat(resp.data.txs || 0, " transactions but no address details"));
+                        log.warn(tag, "This should not happen with tokens=used parameter!");
+                    }
+                    else {
+                        log.info(tag, "\u2705 Got ".concat(resp.data.tokens.length, " used address tokens for xpub (txs: ").concat(resp.data.txs, ", usedTokens: ").concat(resp.data.usedTokens, ")"));
+                    }
                     return [2 /*return*/, resp.data];
                 case 3:
                     e_3 = _a.sent();
@@ -420,9 +428,9 @@ var get_txids_by_address = function (coin, address, page) {
         });
     });
 };
-var get_info_by_address = function (coin, address, filter) {
+var get_info_by_address = function (coin, address, filter, options) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, url, body, resp, e_5;
+        var tag, url, params, body, resp, e_5;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -432,10 +440,25 @@ var get_info_by_address = function (coin, address, filter) {
                     _a.trys.push([1, 3, , 4]);
                     if (!filter)
                         filter = "all";
-                    //let url = ETH_BLOCKBOOK_URL+"/api/v2/address/"+address+"?="+filter
                     if (!BLOCKBOOK_URLS[coin.toUpperCase()])
                         throw Error("invalid coin: " + coin);
-                    url = BLOCKBOOK_URLS[coin.toUpperCase()] + "/api/v2/address/" + address + "?details=all";
+                    url = BLOCKBOOK_URLS[coin.toUpperCase()] + "/api/v2/address/" + address;
+                    params = [];
+                    if (filter === 'txs' || filter === 'all') {
+                        params.push('details=txs');
+                    }
+                    else {
+                        params.push('details=' + filter);
+                    }
+                    // Add pagination if provided
+                    if (options === null || options === void 0 ? void 0 : options.page)
+                        params.push('page=' + options.page);
+                    if (options === null || options === void 0 ? void 0 : options.pageSize)
+                        params.push('pageSize=' + options.pageSize);
+                    if (params.length > 0) {
+                        url += '?' + params.join('&');
+                    }
+                    log.debug(tag, "Fetching ".concat(coin, " address ").concat(address.substring(0, 10), "... from: ").concat(url));
                     body = {
                         method: 'GET',
                         url: url,
@@ -444,12 +467,9 @@ var get_info_by_address = function (coin, address, filter) {
                             'User-Agent': fakeUa()
                         },
                     };
-                    return [4 /*yield*/, axios(body)
-                        //TODO paginate?
-                    ];
+                    return [4 /*yield*/, axios(body)];
                 case 2:
                     resp = _a.sent();
-                    //TODO paginate?
                     return [2 /*return*/, resp.data];
                 case 3:
                     e_5 = _a.sent();
@@ -470,7 +490,7 @@ var get_txs_by_xpub = function (coin, xpub) {
                     _a.label = 1;
                 case 1:
                     _a.trys.push([1, 3, , 4]);
-                    url = BLOCKBOOK_URLS[coin.toUpperCase()] + "/api/v2/xpub/" + xpub + "?details=all";
+                    url = BLOCKBOOK_URLS[coin.toUpperCase()] + "/api/v2/xpub/" + xpub + "?details=txs";
                     body = {
                         method: 'GET',
                         url: url,
@@ -660,16 +680,20 @@ 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, symbol, nodes_3, activeNodes, i, node, startTime, url, body, resp, responseTime, error_2, responseTime, errorMessage, e_9;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var tag, symbol, isBitcoin, nodes_3, activeNodes, i, node, startTime, url, body, resp, responseTime, error_2, responseTime, errorMessage, e_9;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
                 case 0:
                     tag = TAG + " | get_utxos_by_xpub | ";
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 8, , 9]);
                     symbol = coin.toUpperCase();
+                    isBitcoin = symbol === 'BTC';
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 8, , 9]);
                     nodes_3 = BLOCKBOOK_NODES[symbol];
+                    if (isBitcoin)
+                        log.info(tag, '🔍 [BITCOIN BLOCKBOOK] Starting UTXO query for xpub:', xpub.substring(0, 20) + '...');
                     if (!nodes_3 || nodes_3.length === 0) {
                         throw new Error("No nodes configured for ".concat(symbol));
                     }
@@ -678,37 +702,77 @@ var get_utxos_by_xpub = function (coin, xpub) {
                         throw new Error("No active nodes available for ".concat(symbol));
                     }
                     log.info(tag, "Attempting UTXO query for ".concat(symbol, " with ").concat(activeNodes.length, " nodes available"));
+                    if (isBitcoin) {
+                        log.info(tag, '🔍 [BITCOIN BLOCKBOOK] Available nodes:', activeNodes.map(function (n) { return ({
+                            url: n.url,
+                            priority: n.priority,
+                            isActive: n.isActive
+                        }); }));
+                    }
                     i = 0;
-                    _a.label = 2;
+                    _b.label = 2;
                 case 2:
                     if (!(i < activeNodes.length)) return [3 /*break*/, 7];
                     node = activeNodes[i];
                     startTime = Date.now();
-                    _a.label = 3;
+                    _b.label = 3;
                 case 3:
-                    _a.trys.push([3, 5, , 6]);
+                    _b.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,
+                        headers: {
+                            'content-type': 'application/json',
+                            'User-Agent': fakeUa()
+                        },
                         timeout: 15000 // 15s timeout per node
                     };
+                    if (isBitcoin) {
+                        log.info(tag, '🔍 [BITCOIN BLOCKBOOK] Request details:', {
+                            url: url,
+                            method: body.method,
+                            timeout: body.timeout,
+                            headers: body.headers
+                        });
+                    }
                     return [4 /*yield*/, axios(body)];
                 case 4:
-                    resp = _a.sent();
+                    resp = _b.sent();
                     responseTime = Date.now() - startTime;
+                    if (isBitcoin) {
+                        log.info(tag, '🔍 [BITCOIN BLOCKBOOK] Raw API response:', {
+                            status: resp.status,
+                            statusText: resp.statusText,
+                            dataType: typeof resp.data,
+                            dataIsArray: Array.isArray(resp.data),
+                            dataLength: (_a = resp.data) === null || _a === void 0 ? void 0 : _a.length,
+                            data: resp.data
+                        });
+                    }
                     // 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"));
+                    if (isBitcoin) {
+                        log.info(tag, '🔍 [BITCOIN BLOCKBOOK] Returning UTXOs:', resp.data);
+                    }
                     return [2 /*return*/, resp.data];
                 case 5:
-                    error_2 = _a.sent();
+                    error_2 = _b.sent();
                     responseTime = Date.now() - startTime;
                     // Update node performance metrics
                     update_node_performance(symbol, node.url, false, responseTime);
                     errorMessage = error_2 instanceof Error ? error_2.message : String(error_2);
                     log.warn(tag, "\u274C Node ".concat(i + 1, " failed after ").concat(responseTime, "ms:"), errorMessage);
+                    if (isBitcoin) {
+                        log.error(tag, '🔍 [BITCOIN BLOCKBOOK] Node failed with error:', {
+                            nodeUrl: node.url,
+                            errorMessage: errorMessage,
+                            errorType: error_2 instanceof Error ? error_2.constructor.name : typeof error_2,
+                            fullError: error_2
+                        });
+                    }
                     // 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));
@@ -720,7 +784,10 @@ var get_utxos_by_xpub = function (coin, xpub) {
                     return [3 /*break*/, 2];
                 case 7: return [3 /*break*/, 9];
                 case 8:
-                    e_9 = _a.sent();
+                    e_9 = _b.sent();
+                    if (isBitcoin) {
+                        log.error(tag, '🔍 [BITCOIN BLOCKBOOK] Final error after all nodes failed:', e_9);
+                    }
                     console.error(tag, e_9);
                     throw e_9;
                 case 9: return [2 /*return*/];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/blockbook",
-  "version": "8.10.0",
+  "version": "8.11.1",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {
@@ -11,9 +11,9 @@
     "build:live": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/index.ts"
   },
   "dependencies": {
-    "@pioneer-platform/loggerdog": "^8.10.0",
-    "@pioneer-platform/nodes": "^8.10.0",
-    "@pioneer-platform/pioneer-caip": "^9.9.0",
+    "@pioneer-platform/loggerdog": "^8.11.0",
+    "@pioneer-platform/nodes": "^8.11.10",
+    "@pioneer-platform/pioneer-caip": "^9.10.0",
     "@types/request-promise-native": "^1.0.17",
     "axiom": "^0.1.6",
     "axios": "^1.6.0",
@@ -32,4 +32,4 @@
   ],
   "author": "highlander",
   "license": "MIT"
-}
+}