blue-js-sdk 2.3.0 → 2.4.0

package/batch.js

@@ -25,7 +25,7 @@
  */
 
 import { ChainError, ErrorCodes } from './errors.js';
-import { sleep } from './defaults.js';
+import { sleep, DEFAULT_LCD } from './defaults.js';
 import {
   broadcast,
   extractAllSessionIds,
@@ -246,7 +246,7 @@ async function _processBatch(client, account, batch, gigabytes, denom, ctx) {
 export async function waitForBatchSessions(nodeAddrs, walletAddr, lcdUrl, options = {}) {
   const maxWaitMs = options.maxWaitMs ?? DEFAULT_POLL_TIMEOUT;
   const pollIntervalMs = options.pollIntervalMs ?? 2000;
-  const baseLcd = lcdUrl || 'https://lcd.sentinel.co';
+  const baseLcd = lcdUrl || DEFAULT_LCD;
 
   if (nodeAddrs.length === 0) return { confirmed: [], pending: [] };
 

package/chain/authz.js

@@ -11,7 +11,6 @@
 
 import { protoString, protoEmbedded, protoInt64 } from '../v3protocol.js';
 import { ChainError, ErrorCodes } from '../errors.js';
-import { lcd, lcdPaginatedSafe } from './lcd.js';
 import { buildRegistry } from './client.js';
 
 // ─── Protobuf Helpers ───────────────────────────────────────────────────────
@@ -99,11 +98,4 @@ export function encodeForExec(msgs) {
   });
 }
 
-/**
- * Query authz grants between granter and grantee.
- * @returns {Promise<Array>} Array of grant objects
- */
-export async function queryAuthzGrants(lcdUrl, granter, grantee) {
-  const { items } = await lcdPaginatedSafe(lcdUrl, `/cosmos/authz/v1beta1/grants?granter=${granter}&grantee=${grantee}`, 'grants');
-  return items;
-}
+// queryAuthzGrants removed — use RPC-first version from chain/queries.js

package/chain/fee-grants.js

@@ -13,7 +13,7 @@ import { EventEmitter } from 'events';
 import { protoString, protoInt64, protoEmbedded } from '../v3protocol.js';
 import { LCD_ENDPOINTS } from '../defaults.js';
 import { ValidationError, ErrorCodes } from '../errors.js';
-import { lcd, lcdPaginatedSafe, lcdQueryAll } from './lcd.js';
+import { lcdQuery, lcdPaginatedSafe } from './lcd.js';
 import { isSameKey } from './wallet.js';
 import { queryPlanSubscribers } from './queries.js';
 import {
@@ -178,9 +178,9 @@ export async function queryFeeGrant(lcdUrl, granter, grantee) {
     }
   } catch { /* fall through to LCD */ }
 
-  // LCD fallback
+  // LCD fallback (with endpoint failover via lcdQuery)
   try {
-    const data = await lcd(lcdUrl, `/cosmos/feegrant/v1beta1/allowance/${granter}/${grantee}`);
+    const data = await lcdQuery(`/cosmos/feegrant/v1beta1/allowance/${granter}/${grantee}`, { lcdUrl });
     return data.allowance || null;
   } catch { return null; } // 404 = no grant
 }

package/chain/index.js

@@ -50,6 +50,19 @@ import { publicEndpointAgent } from '../security/index.js';
 // Wallet — validation helpers (used by chain functions that validate addresses)
 import { validateMnemonic, validateAddress } from '../wallet/index.js';
 
+// RPC-first query modules — delegates LCD-only functions to these
+import {
+  findExistingSession as _rpcFindExistingSession,
+  fetchActiveNodes as _rpcFetchActiveNodes,
+  getNetworkOverview as _rpcGetNetworkOverview,
+  getNodePrices as _rpcGetNodePrices,
+  discoverPlanIds as _rpcDiscoverPlanIds,
+} from './queries.js';
+import {
+  queryFeeGrants as _rpcQueryFeeGrants,
+  queryFeeGrant as _rpcQueryFeeGrant,
+} from './fee-grants.js';
+
 // ─── All Type URL Constants ──────────────────────────────────────────────────
 
 export const MSG_TYPES = {
@@ -345,19 +358,10 @@ export function txResponse(result) {
 /**
  * Find an existing active session for a wallet+node pair.
  * Returns session ID (BigInt) or null. Use this to avoid double-paying.
- *
- * Note: Sessions have a nested base_session object containing the actual data.
+ * Delegates to chain/queries.js RPC-first implementation.
  */
 export async function findExistingSession(lcdUrl, walletAddr, nodeAddr) {
-  const data = await lcd(lcdUrl, `/sentinel/session/v3/sessions?address=${walletAddr}&status=1&pagination.limit=100`);
-  for (const s of (data.sessions || [])) {
-    const bs = s.base_session || s; // session data is nested in base_session
-    if (bs.node_address !== nodeAddr) continue;
-    const maxBytes = parseInt(bs.max_bytes || '0');
-    const used = parseInt(bs.download_bytes || '0') + parseInt(bs.upload_bytes || '0');
-    if (maxBytes === 0 || used < maxBytes) return BigInt(bs.id);
-  }
-  return null;
+  return _rpcFindExistingSession(lcdUrl, walletAddr, nodeAddr);
 }
 
 /**
@@ -377,176 +381,44 @@ export function resolveNodeUrl(node) {
 }
 
 /**
- * Fetch all active nodes from LCD with pagination.
+ * Fetch all active nodes with RPC-first + LCD fallback.
  * Returns array of node objects. Each node has `remote_url` resolved from `remote_addrs`.
+ * Delegates to chain/queries.js RPC-first implementation.
  */
 export async function fetchActiveNodes(lcdUrl, limit = 500, maxPages = 20) {
-  const nodes = [];
-  let nextKey = null;
-  let page = 0;
-  do {
-    const keyParam = nextKey ? `&pagination.key=${encodeURIComponent(nextKey)}` : '';
-    const data = await lcd(lcdUrl, `/sentinel/node/v3/nodes?status=1&pagination.limit=${limit}${keyParam}`);
-    nodes.push(...(data.nodes || []));
-    nextKey = data.pagination?.next_key || null;
-    page++;
-  } while (nextKey && page < maxPages);
-  // Add computed remote_url for backward compatibility
-  for (const n of nodes) {
-    try { n.remote_url = resolveNodeUrl(n); } catch { /* skip nodes with no address */ }
-  }
-  return nodes;
+  return _rpcFetchActiveNodes(lcdUrl, limit, maxPages);
 }
 
 /**
  * Get a quick network overview — total nodes, counts by country and service type, average prices.
- * Perfect for dashboard UIs, onboarding screens, and network health displays.
+ * Delegates to chain/queries.js RPC-first implementation.
  *
  * @param {string} [lcdUrl] - LCD endpoint (default: cascading fallback)
  * @returns {Promise<{ totalNodes: number, byCountry: Array<{country: string, count: number}>, byType: {wireguard: number, v2ray: number, unknown: number}, averagePrice: {gigabyteDvpn: number, hourlyDvpn: number}, nodes: Array }>}
- *
- * @example
- *   const overview = await getNetworkOverview();
- *   console.log(`${overview.totalNodes} nodes across ${overview.byCountry.length} countries`);
- *   console.log(`Average: ${overview.averagePrice.gigabyteDvpn.toFixed(3)} P2P/GB`);
  */
 export async function getNetworkOverview(lcdUrl) {
-  const fetchFn = async (url) => fetchActiveNodes(url);
-  let nodes;
-  if (lcdUrl) {
-    nodes = await fetchFn(lcdUrl);
-  } else {
-    const result = await tryWithFallback(LCD_ENDPOINTS, fetchFn, 'getNetworkOverview');
-    nodes = result.result;
-  }
-
-  // Filter to nodes that accept udvpn
-  const active = nodes.filter(n => n.remote_url && (n.gigabyte_prices || []).some(p => p.denom === 'udvpn'));
-
-  // Count by country (from LCD metadata, limited — enrichNodes gives better data)
-  const countryMap = {};
-  for (const n of active) {
-    const c = n.location?.country || n.country || 'Unknown';
-    countryMap[c] = (countryMap[c] || 0) + 1;
-  }
-  const byCountry = Object.entries(countryMap)
-    .map(([country, count]) => ({ country, count }))
-    .sort((a, b) => b.count - a.count);
-
-  // Count by type (type not in LCD — estimate from service_type field if present)
-  const byType = { wireguard: 0, v2ray: 0, unknown: 0 };
-  for (const n of active) {
-    const t = n.service_type || n.type;
-    if (t === 'wireguard' || t === 1) byType.wireguard++;
-    else if (t === 'v2ray' || t === 2) byType.v2ray++;
-    else byType.unknown++;
-  }
-
-  // Average prices
-  let gbTotal = 0, gbCount = 0, hrTotal = 0, hrCount = 0;
-  for (const n of active) {
-    const gb = (n.gigabyte_prices || []).find(p => p.denom === 'udvpn');
-    if (gb?.quote_value) { gbTotal += parseInt(gb.quote_value, 10); gbCount++; }
-    const hr = (n.hourly_prices || []).find(p => p.denom === 'udvpn');
-    if (hr?.quote_value) { hrTotal += parseInt(hr.quote_value, 10); hrCount++; }
-  }
-
-  return {
-    totalNodes: active.length,
-    byCountry,
-    byType,
-    averagePrice: {
-      gigabyteDvpn: gbCount > 0 ? (gbTotal / gbCount) / 1_000_000 : 0,
-      hourlyDvpn: hrCount > 0 ? (hrTotal / hrCount) / 1_000_000 : 0,
-    },
-    nodes: active,
-  };
+  return _rpcGetNetworkOverview(lcdUrl);
 }
 
 /**
  * Discover plan IDs by probing subscription endpoints.
- * Workaround for /sentinel/plan/v3/plans returning 501 Not Implemented.
+ * Delegates to chain/queries.js RPC-first implementation.
  * Returns sorted array of plan IDs that have at least 1 subscription.
  */
 export async function discoverPlanIds(lcdUrl, maxId = 100) {
-  const ids = [];
-  const batchSize = 10;
-  for (let batch = 0; batch < maxId / batchSize; batch++) {
-    const checks = [];
-    for (let i = batch * batchSize + 1; i <= (batch + 1) * batchSize; i++) {
-      checks.push(
-        lcd(lcdUrl, `/sentinel/subscription/v3/plans/${i}/subscriptions?pagination.limit=1&pagination.count_total=true`)
-          .then(d => { if (parseInt(d.pagination?.total || '0') > 0) ids.push(i); })
-          .catch(() => {})
-      );
-    }
-    await Promise.all(checks);
-  }
-  return ids.sort((a, b) => a - b);
+  return _rpcDiscoverPlanIds(lcdUrl, maxId);
 }
 
 /**
- * Get standardized prices for a node — abstracts V3 LCD price parsing entirely.
- *
- * Solves the common "NaN / GB" problem by defensively extracting quote_value,
- * base_value, or amount from the nested LCD response structure.
+ * Get standardized prices for a node — abstracts V3 price parsing entirely.
+ * Delegates to chain/queries.js RPC-first implementation (direct node lookup, not full-list scan).
  *
  * @param {string} nodeAddress - sentnode1... address
  * @param {string} [lcdUrl] - LCD endpoint URL (default: cascading fallback across all endpoints)
  * @returns {Promise<{ gigabyte: { dvpn: number, udvpn: number, raw: object|null }, hourly: { dvpn: number, udvpn: number, raw: object|null }, denom: string, nodeAddress: string }>}
- *
- * @example
- *   const prices = await getNodePrices('sentnode1abc...');
- *   console.log(`${prices.gigabyte.dvpn} P2P/GB, ${prices.hourly.dvpn} P2P/hr`);
- *   // Use prices.gigabyte.raw for the full { denom, base_value, quote_value } object
- *   // needed by encodeMsgStartSession's max_price field.
  */
 export async function getNodePrices(nodeAddress, lcdUrl) {
-  if (typeof nodeAddress !== 'string' || !/^sentnode1[a-z0-9]{38}$/.test(nodeAddress)) {
-    throw new ValidationError(ErrorCodes.INVALID_NODE_ADDRESS, 'nodeAddress must be a valid sentnode1... bech32 address (46 characters)', { value: nodeAddress });
-  }
-
-  const fetchNode = async (baseUrl) => {
-    let nextKey = null;
-    let pages = 0;
-    do {
-      const keyParam = nextKey ? `&pagination.key=${encodeURIComponent(nextKey)}` : '';
-      const data = await lcd(baseUrl, `/sentinel/node/v3/nodes?status=1&pagination.limit=500${keyParam}`);
-      const nodes = data.nodes || [];
-      const found = nodes.find(n => n.address === nodeAddress);
-      if (found) return found;
-      nextKey = data.pagination?.next_key || null;
-      pages++;
-    } while (nextKey && pages < 20);
-    return null;
-  };
-
-  let node;
-  if (lcdUrl) {
-    node = await fetchNode(lcdUrl);
-  } else {
-    const result = await tryWithFallback(LCD_ENDPOINTS, fetchNode, 'getNodePrices');
-    node = result.result;
-  }
-
-  if (!node) throw new NodeError(ErrorCodes.NODE_NOT_FOUND, `Node ${nodeAddress} not found on LCD (may be inactive or deregistered)`, { nodeAddress });
-
-  function extractPrice(priceArray) {
-    if (!Array.isArray(priceArray)) return { dvpn: 0, udvpn: 0, raw: null };
-    const entry = priceArray.find(p => p.denom === 'udvpn');
-    if (!entry) return { dvpn: 0, udvpn: 0, raw: null };
-    // Defensive fallback chain: quote_value (V3 current) -> base_value -> amount (legacy)
-    const rawVal = entry.quote_value || entry.base_value || entry.amount || '0';
-    const udvpn = parseInt(rawVal, 10) || 0;
-    return { dvpn: parseFloat((udvpn / 1_000_000).toFixed(6)), udvpn, raw: entry };
-  }
-
-  return {
-    gigabyte: extractPrice(node.gigabyte_prices),
-    hourly: extractPrice(node.hourly_prices),
-    denom: 'P2P',
-    nodeAddress,
-  };
+  return _rpcGetNodePrices(nodeAddress, lcdUrl);
 }
 
 // ─── Display & Serialization Helpers ────────────────────────────────────────
@@ -761,22 +633,20 @@ export function buildRevokeFeeGrantMsg(granter, grantee) {
 
 /**
  * Query fee grants given to a grantee.
+ * Delegates to chain/fee-grants.js RPC-first implementation.
  * @returns {Promise<Array>} Array of allowance objects
  */
 export async function queryFeeGrants(lcdUrl, grantee) {
-  const data = await lcd(lcdUrl, `/cosmos/feegrant/v1beta1/allowances/${grantee}`);
-  return data.allowances || [];
+  return _rpcQueryFeeGrants(lcdUrl, grantee);
 }
 
 /**
  * Query a specific fee grant between granter and grantee.
+ * Delegates to chain/fee-grants.js RPC-first implementation.
  * @returns {Promise<object|null>} Allowance object or null
  */
 export async function queryFeeGrant(lcdUrl, granter, grantee) {
-  try {
-    const data = await lcd(lcdUrl, `/cosmos/feegrant/v1beta1/allowance/${granter}/${grantee}`);
-    return data.allowance || null;
-  } catch { return null; } // 404 = no grant
+  return _rpcQueryFeeGrant(lcdUrl, granter, grantee);
 }
 
 /**
@@ -878,14 +748,7 @@ export function encodeForExec(msgs) {
   });
 }
 
-/**
- * Query authz grants between granter and grantee.
- * @returns {Promise<Array>} Array of grant objects
- */
-export async function queryAuthzGrants(lcdUrl, granter, grantee) {
-  const data = await lcd(lcdUrl, `/cosmos/authz/v1beta1/grants?granter=${granter}&grantee=${grantee}`);
-  return data.grants || [];
-}
+// queryAuthzGrants removed — use RPC-first version from chain/queries.js
 
 // Re-export extractSessionId for convenience (from protocol module)
 export { extractSessionId };

package/chain/queries.js

@@ -56,6 +56,15 @@ async function getRpcClient() {
   return _rpcClientPromise;
 }
 
+/**
+ * Clear the cached RPC query client. Called during process cleanup
+ * to ensure WebSocket connections are properly closed.
+ */
+export function resetQueryRpcCache() {
+  _rpcClient = null;
+  _rpcClientPromise = null;
+}
+
 // ─── Query Helpers ───────────────────────────────────────────────────────────
 
 /**
@@ -344,9 +353,9 @@ export async function querySessionById(lcdUrl, sessionId) {
     }
   } catch { /* fall through to LCD */ }
 
-  // LCD fallback
+  // LCD fallback (with endpoint failover via lcdQuery)
   try {
-    const data = await lcd(lcdUrl, `/sentinel/session/v3/sessions/${sessionId}`);
+    const data = await lcdQuery(`/sentinel/session/v3/sessions/${sessionId}`, { lcdUrl });
     const raw = data?.session;
     if (!raw) return null;
     return flattenSession(raw);
@@ -372,9 +381,9 @@ export async function querySessionAllocation(lcdUrl, sessionId) {
   } catch { /* fall through */ }
 
   if (!s) {
-    // LCD fallback
+    // LCD fallback (with endpoint failover via lcdQuery)
     try {
-      const data = await lcd(lcdUrl, `/sentinel/session/v3/sessions/${sessionId}`);
+      const data = await lcdQuery(`/sentinel/session/v3/sessions/${sessionId}`, { lcdUrl });
       s = data.session?.base_session || data.session || null;
     } catch { return null; }
   }

package/client/index.js

@@ -33,9 +33,7 @@ import {
   events as sdkEvents, ConnectionState,
 } from '../connection/index.js';
 import {
-  createWallet, privKeyFromMnemonic, createClient, broadcast,
-  createSafeBroadcaster, getBalance, findExistingSession, fetchActiveNodes,
-  discoverPlanIds, resolveNodeUrl, lcd, MSG_TYPES,
+  createWallet, createClient, getBalance,
 } from '../chain/index.js';
 import { nodeStatusV3 } from '../protocol/index.js';
 import { createNodeHttpsAgent, clearKnownNode, clearAllKnownNodes, getKnownNode } from '../security/index.js';

package/connection/discovery.js

@@ -1,8 +1,8 @@
 /**
  * Node Discovery — query, fetch, enrich, index, and score nodes.
  *
- * Handles LCD queries for online nodes, caching, quality scoring,
- * and geographic indexing.
+ * Handles RPC-first queries (LCD fallback) for online nodes, caching,
+ * quality scoring, and geographic indexing.
  */
 
 import {
@@ -63,7 +63,7 @@ export function scoreNode(status) {
 // ─── Query Nodes ─────────────────────────────────────────────────────────────
 
 /**
- * Fetch active nodes from LCD and check which are actually online.
+ * Fetch active nodes via RPC-first (LCD fallback) and check which are actually online.
  * Returns array sorted by quality score (best first).
  *
  * Built-in quality scoring (from 400+ node tests):
@@ -119,12 +119,12 @@ async function _queryOnlineNodesImpl(options = {}) {
   const logFn = options.log || null;
   const brokenAddrs = new Set(BROKEN_NODES.map(n => n.address));
 
-  // 1. Fetch ALL active nodes from LCD — uses lcdPaginatedSafe (handles broken pagination)
+  // 1. Fetch ALL active nodes via RPC-first (falls back to LCD if RPC fails)
   let nodes = [];
   if (options.lcdUrl) {
     nodes = await fetchActiveNodes(options.lcdUrl);
   } else {
-    const { result } = await tryWithFallback(LCD_ENDPOINTS, fetchActiveNodes, 'LCD node list');
+    const { result } = await tryWithFallback(LCD_ENDPOINTS, fetchActiveNodes, 'RPC-first node list');
     nodes = result;
   }
 
@@ -194,12 +194,12 @@ async function _queryOnlineNodesImpl(options = {}) {
   return online;
 }
 
-// ─── Full Node Catalog (LCD only, no per-node status checks) ────────────────
+// ─── Full Node Catalog (RPC-first, no per-node status checks) ───────────────
 
 /**
- * Fetch ALL active nodes from the LCD. No per-node HTTP checks — instant.
+ * Fetch ALL active nodes via RPC-first (LCD fallback). No per-node HTTP checks — instant.
  *
- * Returns every node that accepts udvpn, with LCD data only:
+ * Returns every node that accepts udvpn, with chain data:
  * address, remote_url, gigabyte_prices, hourly_prices.
  *
  * Use this for: building node lists/maps, country pickers, price comparisons.
@@ -217,7 +217,7 @@ export async function fetchAllNodes(options = {}) {
     const { result } = await tryWithFallback(
       LCD_ENDPOINTS,
       async (url) => fetchActiveNodes(url),
-      'LCD full node list',
+      'RPC-first full node list',
     );
     nodes = result;
   }
@@ -275,9 +275,9 @@ export function buildNodeIndex(nodes) {
 }
 
 /**
- * Enrich LCD nodes with type/country/city by probing each node's status API.
+ * Enrich chain nodes with type/country/city by probing each node's status API.
  *
- * @param {Array} nodes - Raw LCD nodes from fetchAllNodes()
+ * @param {Array} nodes - Raw chain nodes from fetchAllNodes()
  * @param {object} [options]
  * @param {number} [options.concurrency=30] - Parallel probes
  * @param {function} [options.onProgress] - Callback: ({ total, done, enriched }) => void

package/cosmjs-setup.js

@@ -462,29 +462,11 @@ export function extractId(txResult, eventPattern, keyNames) {
 }
 
 // ─── LCD Query Helper ────────────────────────────────────────────────────────
+// Canonical LCD functions live in chain/lcd.js. Re-export for backward compatibility.
 
 import axios from 'axios';
-import { publicEndpointAgent } from './tls-trust.js';
 
-/**
- * Query a Sentinel LCD REST endpoint.
- * Checks both HTTP status AND gRPC error codes in response body.
- * Uses CA-validated HTTPS for LCD public infrastructure (valid CA certs).
- *
- * Usage:
- *   const data = await lcd('https://lcd.sentinel.co', '/sentinel/node/v3/nodes?status=1');
- */
-export async function lcd(baseUrl, path) {
-  // Accept Endpoint objects ({ url, name }) or bare strings
-  const base = typeof baseUrl === 'object' ? baseUrl.url : baseUrl;
-  const url = `${base}${path}`;
-  const res = await axios.get(url, { httpsAgent: publicEndpointAgent, timeout: 15000 });
-  const data = res.data;
-  if (data?.code && data.code !== 0) {
-    throw new ChainError(ErrorCodes.LCD_ERROR, `LCD ${path}: code=${data.code} ${data.message || ''}`, { path, code: data.code, message: data.message });
-  }
-  return data;
-}
+export { lcd, lcdQuery, lcdQueryAll, lcdPaginatedSafe } from './chain/lcd.js';
 
 // ─── Query Helpers ───────────────────────────────────────────────────────────
 
@@ -933,90 +915,7 @@ export async function queryAuthzGrants(lcdUrl, granter, grantee) {
   return _queryAuthzGrants(lcdUrl, granter, grantee);
 }
 
-// ─── LCD Query Helpers (v25b) ────────────────────────────────────────────────
-// General-purpose LCD query with timeout, retry, error wrapping, and pagination.
-
-/**
- * Single LCD query with timeout, single retry on network error, and ChainError wrapping.
- * Uses the fallback endpoint list if no lcdUrl is provided.
- *
- * @param {string} path - LCD path (e.g. '/sentinel/node/v3/nodes?status=1')
- * @param {object} [opts]
- * @param {string} [opts.lcdUrl] - Specific LCD endpoint (or uses fallback chain)
- * @param {number} [opts.timeout] - Request timeout in ms (default: 15000)
- * @returns {Promise<any>} Parsed JSON response
- */
-export async function lcdQuery(path, opts = {}) {
-  const timeout = opts.timeout || 15000;
-  const doQuery = async (baseUrl) => {
-    try {
-      return await lcd(baseUrl, path);
-    } catch (err) {
-      // Single retry on network error
-      if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND' || err.message?.includes('timeout')) {
-        await new Promise(r => setTimeout(r, 1000));
-        return await lcd(baseUrl, path);
-      }
-      throw err;
-    }
-  };
-
-  if (opts.lcdUrl) {
-    return doQuery(opts.lcdUrl);
-  }
-  const { result } = await tryWithFallback(LCD_ENDPOINTS, doQuery, `LCD ${path}`);
-  return result;
-}
-
-/**
- * Auto-paginating LCD query. Fetches all pages via next_key, returns all results + chain total.
- *
- * @param {string} basePath - LCD path without pagination params (e.g. '/sentinel/node/v3/nodes?status=1')
- * @param {object} [opts]
- * @param {string} [opts.lcdUrl] - Specific LCD endpoint (or uses fallback chain)
- * @param {number} [opts.limit] - Page size (default: 200)
- * @param {number} [opts.timeout] - Per-page timeout (default: 15000)
- * @param {string} [opts.dataKey] - Key for the results array in response (default: auto-detect first array)
- * @returns {Promise<{ items: any[], total: number|null }>}
- */
-export async function lcdQueryAll(basePath, opts = {}) {
-  const limit = opts.limit || 200;
-  const dataKey = opts.dataKey || null;
-
-  const fetchAll = async (baseUrl) => {
-    let allItems = [];
-    let nextKey = null;
-    let chainTotal = null;
-    let isFirst = true;
-    do {
-      const sep = basePath.includes('?') ? '&' : '?';
-      let url = `${basePath}${sep}pagination.limit=${limit}`;
-      if (isFirst) url += '&pagination.count_total=true';
-      if (nextKey) url += `&pagination.key=${encodeURIComponent(nextKey)}`;
-      const data = await lcd(baseUrl, url);
-      if (isFirst && data.pagination?.total) {
-        chainTotal = parseInt(data.pagination.total, 10);
-      }
-      // Auto-detect data key: first array property that isn't 'pagination'
-      const key = dataKey || Object.keys(data).find(k => k !== 'pagination' && Array.isArray(data[k]));
-      const pageItems = key ? (data[key] || []) : [];
-      allItems = allItems.concat(pageItems);
-      nextKey = data.pagination?.next_key || null;
-      isFirst = false;
-    } while (nextKey);
-
-    if (chainTotal && allItems.length !== chainTotal) {
-      console.warn(`[lcdQueryAll] Pagination mismatch: got ${allItems.length}, chain reports ${chainTotal}`);
-    }
-    return { items: allItems, total: chainTotal };
-  };
-
-  if (opts.lcdUrl) {
-    return fetchAll(opts.lcdUrl);
-  }
-  const { result } = await tryWithFallback(LCD_ENDPOINTS, fetchAll, `LCD paginated ${basePath}`);
-  return result;
-}
+// LCD Query Helpers — canonical implementations in chain/lcd.js, re-exported above.
 
 // ─── Plan Subscriber Helpers (v25b) ──────────────────────────────────────────
 
@@ -1176,53 +1075,7 @@ export function buildEndSessionMsg(from, sessionId) {
   };
 }
 
-// ─── v26c: Defensive Pagination ──────────────────────────────────────────────
-
-/**
- * Paginated LCD query that handles Sentinel's broken pagination.
- * Tries next_key first. If next_key is null but we got exactly `limit` results
- * (suggesting truncation), falls back to a single large request.
- *
- * @param {string} lcdUrl - LCD base URL
- * @param {string} path - Endpoint path (e.g. '/sentinel/node/v3/plans/36/nodes')
- * @param {string} itemsKey - Response array key ('nodes', 'subscriptions', 'sessions')
- * @param {object} [opts]
- * @param {number} [opts.limit=500] - Page size for paginated requests
- * @param {number} [opts.fallbackLimit=5000] - Single-request limit if pagination broken
- * @returns {Promise<{ items: any[], total: number }>}
- */
-export async function lcdPaginatedSafe(lcdUrl, path, itemsKey, opts = {}) {
-  const limit = opts.limit || 500;
-  const fallbackLimit = opts.fallbackLimit || 5000;
-  const baseLcd = lcdUrl || LCD_ENDPOINTS[0].url;
-  const sep = path.includes('?') ? '&' : '?';
-
-  const firstPage = await lcd(baseLcd, `${path}${sep}pagination.limit=${limit}`);
-  const firstItems = firstPage[itemsKey] || [];
-  const nextKey = firstPage.pagination?.next_key;
-
-  // Fewer than limit = that's everything
-  if (firstItems.length < limit) {
-    return { items: firstItems, total: firstItems.length };
-  }
-
-  // next_key exists = pagination works, follow it
-  if (nextKey) {
-    let allItems = [...firstItems];
-    let key = nextKey;
-    while (key) {
-      const page = await lcd(baseLcd, `${path}${sep}pagination.limit=${limit}&pagination.key=${encodeURIComponent(key)}`);
-      allItems.push(...(page[itemsKey] || []));
-      key = page.pagination?.next_key || null;
-    }
-    return { items: allItems, total: allItems.length };
-  }
-
-  // next_key null but hit limit = broken pagination. Single large request.
-  const fullData = await lcd(baseLcd, `${path}${sep}pagination.limit=${fallbackLimit}`);
-  const allItems = fullData[itemsKey] || [];
-  return { items: allItems, total: allItems.length };
-}
+// lcdPaginatedSafe — canonical implementation in chain/lcd.js, re-exported above.
 
 // ─── v26c: Session & Subscription Queries ────────────────────────────────────
 

package/defaults.js

@@ -25,7 +25,7 @@ axios.defaults.adapter = 'http';
 // This is the npm/semver version for consumers. Internal development iterations
 // (v20, v21, v22, etc.) track feature milestones and are not exposed as exports.
 
-export const SDK_VERSION = '2.3.0';
+export const SDK_VERSION = '2.4.0';
 
 // ─── Timestamps ──────────────────────────────────────────────────────────────
 

package/node-connect.js

@@ -39,8 +39,11 @@ import {
 
 import {
   findExistingSession, fetchActiveNodes, queryNode, resolveNodeUrl,
+  resetQueryRpcCache,
 } from './chain/queries.js';
 
+import { disconnectRpc } from './chain/rpc.js';
+
 import {
   nodeStatusV3, generateWgKeyPair, initHandshakeV3,
   writeWgConfig, generateV2RayUUID, initHandshakeV3V2Ray,
@@ -389,7 +392,7 @@ export function clearSystemProxy(state) {
 // ─── Query Nodes ─────────────────────────────────────────────────────────────
 
 /**
- * Fetch active nodes from LCD and check which are actually online.
+ * Fetch active nodes via RPC-first (LCD fallback) and check which are actually online.
  * Returns array sorted by quality score (best first).
  *
  * Built-in quality scoring (from 400+ node tests):
@@ -445,12 +448,12 @@ async function _queryOnlineNodesImpl(options = {}) {
   const logFn = options.log || null;
   const brokenAddrs = new Set(BROKEN_NODES.map(n => n.address));
 
-  // 1. Fetch ALL active nodes from LCD — uses lcdPaginatedSafe (handles broken pagination)
+  // 1. Fetch ALL active nodes via RPC-first (falls back to LCD if RPC fails)
   let nodes = [];
   if (options.lcdUrl) {
     nodes = await fetchActiveNodes(options.lcdUrl);
   } else {
-    const { result } = await tryWithFallback(LCD_ENDPOINTS, fetchActiveNodes, 'LCD node list');
+    const { result } = await tryWithFallback(LCD_ENDPOINTS, fetchActiveNodes, 'RPC-first node list');
     nodes = result;
   }
 
@@ -520,12 +523,12 @@ async function _queryOnlineNodesImpl(options = {}) {
   return online;
 }
 
-// ─── Full Node Catalog (LCD only, no per-node status checks) ────────────────
+// ─── Full Node Catalog (RPC-first, no per-node status checks) ───────────────
 
 /**
- * Fetch ALL active nodes from the LCD. No per-node HTTP checks — instant.
+ * Fetch ALL active nodes via RPC-first (LCD fallback). No per-node HTTP checks — instant.
  *
- * Returns every node that accepts udvpn, with LCD data only:
+ * Returns every node that accepts udvpn, with chain data:
  * address, remote_url, gigabyte_prices, hourly_prices.
  *
  * Use this for: building node lists/maps, country pickers, price comparisons.
@@ -543,7 +546,7 @@ export async function fetchAllNodes(options = {}) {
     const { result } = await tryWithFallback(
       LCD_ENDPOINTS,
       async (url) => fetchActiveNodes(url),
-      'LCD full node list',
+      'RPC-first full node list',
     );
     nodes = result;
   }
@@ -601,9 +604,9 @@ export function buildNodeIndex(nodes) {
 }
 
 /**
- * Enrich LCD nodes with type/country/city by probing each node's status API.
+ * Enrich chain nodes with type/country/city by probing each node's status API.
  *
- * @param {Array} nodes - Raw LCD nodes from fetchAllNodes()
+ * @param {Array} nodes - Raw chain nodes from fetchAllNodes()
  * @param {object} [options]
  * @param {number} [options.concurrency=30] - Parallel probes
  * @param {function} [options.onProgress] - Callback: ({ total, done, enriched }) => void
@@ -2436,15 +2439,17 @@ export function registerCleanupHandlers() {
   if (orphans?.cleaned?.length) console.log('[sentinel-sdk] Recovered orphans:', orphans.cleaned.join(', '));
   emergencyCleanupSync(); // kill stale tunnels from previous crash
   killOrphanV2Ray(); // kill orphaned v2ray from previous crash
-  process.on('exit', () => { if (_killSwitchEnabled) disableKillSwitch(); clearSystemProxy(); killOrphanV2Ray(); emergencyCleanupSync(); });
-  process.on('SIGINT', () => { if (_killSwitchEnabled) disableKillSwitch(); clearSystemProxy(); killOrphanV2Ray(); emergencyCleanupSync(); process.exit(130); });
-  process.on('SIGTERM', () => { if (_killSwitchEnabled) disableKillSwitch(); clearSystemProxy(); killOrphanV2Ray(); emergencyCleanupSync(); process.exit(143); });
+  process.on('exit', () => { if (_killSwitchEnabled) disableKillSwitch(); clearSystemProxy(); killOrphanV2Ray(); emergencyCleanupSync(); resetQueryRpcCache(); disconnectRpc(); });
+  process.on('SIGINT', () => { if (_killSwitchEnabled) disableKillSwitch(); clearSystemProxy(); killOrphanV2Ray(); emergencyCleanupSync(); resetQueryRpcCache(); disconnectRpc(); process.exit(130); });
+  process.on('SIGTERM', () => { if (_killSwitchEnabled) disableKillSwitch(); clearSystemProxy(); killOrphanV2Ray(); emergencyCleanupSync(); resetQueryRpcCache(); disconnectRpc(); process.exit(143); });
   process.on('uncaughtException', (err) => {
     console.error('Uncaught exception:', err);
     if (_killSwitchEnabled) disableKillSwitch();
     clearSystemProxy();
     killOrphanV2Ray();
     emergencyCleanupSync();
+    resetQueryRpcCache();
+    disconnectRpc();
     process.exit(1);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blue-js-sdk",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Decentralized VPN SDK for the Sentinel P2P bandwidth network. WireGuard + V2Ray tunnels, Cosmos blockchain, 900+ nodes. Tested on Windows. macOS/Linux support included but untested.",
   "type": "module",
   "main": "index.js",

package/pricing/index.js

@@ -11,8 +11,7 @@
  *   console.log(formatDvpn(prices.gigabyte.udvpn)); // "0.04 P2P"
  */
 
-import { lcd } from '../chain/index.js';
-import { fetchActiveNodes } from '../chain/index.js';
+import { queryNode, fetchActiveNodes } from '../chain/queries.js';
 import { LCD_ENDPOINTS, tryWithFallback } from '../config/index.js';
 import { ValidationError, NodeError, ErrorCodes } from '../errors/index.js';
 
@@ -39,30 +38,8 @@ export async function getNodePrices(nodeAddress, lcdUrl) {
     throw new ValidationError(ErrorCodes.INVALID_NODE_ADDRESS, 'nodeAddress must be a valid sentnode1... bech32 address (46 characters)', { value: nodeAddress });
   }
 
-  const fetchNode = async (baseUrl) => {
-    let nextKey = null;
-    let pages = 0;
-    do {
-      const keyParam = nextKey ? `&pagination.key=${encodeURIComponent(nextKey)}` : '';
-      const data = await lcd(baseUrl, `/sentinel/node/v3/nodes?status=1&pagination.limit=500${keyParam}`);
-      const nodes = data.nodes || [];
-      const found = nodes.find(n => n.address === nodeAddress);
-      if (found) return found;
-      nextKey = data.pagination?.next_key || null;
-      pages++;
-    } while (nextKey && pages < 20);
-    return null;
-  };
-
-  let node;
-  if (lcdUrl) {
-    node = await fetchNode(lcdUrl);
-  } else {
-    const result = await tryWithFallback(LCD_ENDPOINTS, fetchNode, 'getNodePrices');
-    node = result.result;
-  }
-
-  if (!node) throw new NodeError(ErrorCodes.NODE_NOT_FOUND, `Node ${nodeAddress} not found on LCD (may be inactive or deregistered)`, { nodeAddress });
+  // RPC-first single node lookup (was: paginating ALL nodes via LCD)
+  const node = await queryNode(nodeAddress, { lcdUrl });
 
   function extractPrice(priceArray) {
     if (!Array.isArray(priceArray)) return { dvpn: 0, udvpn: 0, raw: null };