blue-js-sdk 2.2.0 → 2.4.0

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 = '1.0.0';
+export const SDK_VERSION = '2.4.0';
 
 // ─── Timestamps ──────────────────────────────────────────────────────────────
 
@@ -364,3 +364,123 @@ export async function tryWithFallback(endpoints, operation, label = 'operation')
   const { ChainError } = await import('./errors.js');
   throw new ChainError('ALL_ENDPOINTS_FAILED', `${label} failed on all ${endpoints.length} endpoints (verified ${LAST_VERIFIED}):\n${tried}\n\nAll endpoints may be down, or your network may be blocking HTTPS. Try curl-ing the URLs manually.`, { endpoints: errors });
 }
+
+// ─── Runtime Endpoint Management ────────────────────────────────────────────
+// Add/remove/reorder RPC and LCD endpoints at runtime without code changes.
+// The arrays above are `const` but are Objects (mutable contents).
+
+/**
+ * Add an RPC endpoint at runtime. Skips if URL already exists.
+ * @param {string} url - RPC URL (e.g. 'https://rpc.newprovider.com')
+ * @param {string} [name='Custom'] - Provider name
+ * @param {boolean} [prepend=false] - If true, adds to front (highest priority)
+ */
+export function addRpcEndpoint(url, name = 'Custom', prepend = false) {
+  if (RPC_ENDPOINTS.some(e => e.url === url)) return;
+  const entry = { url, name, verified: new Date().toISOString().slice(0, 10) };
+  prepend ? RPC_ENDPOINTS.unshift(entry) : RPC_ENDPOINTS.push(entry);
+}
+
+/**
+ * Add an LCD endpoint at runtime. Skips if URL already exists.
+ * @param {string} url - LCD URL (e.g. 'https://api.newprovider.com')
+ * @param {string} [name='Custom'] - Provider name
+ * @param {boolean} [prepend=false] - If true, adds to front (highest priority)
+ */
+export function addLcdEndpoint(url, name = 'Custom', prepend = false) {
+  if (LCD_ENDPOINTS.some(e => e.url === url)) return;
+  const entry = { url, name, verified: new Date().toISOString().slice(0, 10) };
+  prepend ? LCD_ENDPOINTS.unshift(entry) : LCD_ENDPOINTS.push(entry);
+}
+
+/**
+ * Remove an RPC endpoint by URL.
+ * @param {string} url
+ */
+export function removeRpcEndpoint(url) {
+  const idx = RPC_ENDPOINTS.findIndex(e => e.url === url);
+  if (idx !== -1) RPC_ENDPOINTS.splice(idx, 1);
+}
+
+/**
+ * Remove an LCD endpoint by URL.
+ * @param {string} url
+ */
+export function removeLcdEndpoint(url) {
+  const idx = LCD_ENDPOINTS.findIndex(e => e.url === url);
+  if (idx !== -1) LCD_ENDPOINTS.splice(idx, 1);
+}
+
+/**
+ * Replace ALL endpoints at once (e.g. from a config file or remote registry).
+ * @param {'rpc'|'lcd'} type
+ * @param {Array<{url: string, name?: string}>} endpoints
+ */
+export function setEndpoints(type, endpoints) {
+  const target = type === 'rpc' ? RPC_ENDPOINTS : LCD_ENDPOINTS;
+  target.length = 0;
+  for (const ep of endpoints) {
+    target.push({ url: ep.url, name: ep.name || 'Custom', verified: new Date().toISOString().slice(0, 10) });
+  }
+}
+
+/**
+ * Get current endpoint lists (for inspection/debugging).
+ * @returns {{ rpc: Array, lcd: Array }}
+ */
+export function getEndpoints() {
+  return { rpc: [...RPC_ENDPOINTS], lcd: [...LCD_ENDPOINTS] };
+}
+
+/**
+ * Health-check RPC endpoints and reorder by latency (fastest first).
+ * Uses Tendermint /status endpoint which returns node info + sync status.
+ * @param {number} [timeoutMs=5000] - Timeout per endpoint
+ * @returns {Promise<Array<{url: string, name: string, latencyMs: number|null, blockHeight?: number}>>}
+ */
+export async function checkRpcEndpointHealth(timeoutMs = 5000) {
+  const results = await Promise.all(RPC_ENDPOINTS.map(async (ep) => {
+    const start = Date.now();
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      const resp = await axios.get(`${ep.url}/status`, { signal: controller.signal, timeout: timeoutMs });
+      clearTimeout(timer);
+      const height = parseInt(resp.data?.result?.sync_info?.latest_block_height || '0', 10);
+      return { ...ep, latencyMs: Date.now() - start, blockHeight: height };
+    } catch {
+      return { ...ep, latencyMs: null };
+    }
+  }));
+  return results.sort((a, b) => {
+    if (a.latencyMs != null && b.latencyMs != null) return a.latencyMs - b.latencyMs;
+    if (a.latencyMs != null) return -1;
+    if (b.latencyMs != null) return 1;
+    return 0;
+  });
+}
+
+/**
+ * Health-check both RPC and LCD endpoints, reorder by latency.
+ * Moves fastest-responding endpoints to the front of each array.
+ * @param {number} [timeoutMs=5000]
+ * @returns {Promise<{ rpc: Array, lcd: Array }>}
+ */
+export async function optimizeEndpoints(timeoutMs = 5000) {
+  const [rpcResults, lcdResults] = await Promise.all([
+    checkRpcEndpointHealth(timeoutMs),
+    checkEndpointHealth(LCD_ENDPOINTS, timeoutMs),
+  ]);
+  // Reorder arrays in-place: healthy first, by latency
+  const reorder = (target, results) => {
+    const healthy = results.filter(r => r.latencyMs != null);
+    const dead = results.filter(r => r.latencyMs == null);
+    target.length = 0;
+    for (const r of [...healthy, ...dead]) {
+      target.push({ url: r.url, name: r.name, verified: r.verified || LAST_VERIFIED });
+    }
+  };
+  reorder(RPC_ENDPOINTS, rpcResults);
+  reorder(LCD_ENDPOINTS, lcdResults);
+  return { rpc: rpcResults, lcd: lcdResults };
+}

package/index.js

@@ -307,6 +307,10 @@ export {
   rpcQueryPlan,
   rpcQueryBalance,
   rpcQueryFeeGrant,
+  rpcQueryFeeGrants,
+  rpcQueryFeeGrantsIssued,
+  rpcQueryAuthzGrants,
+  rpcQueryProvider,
 } from './chain/rpc.js';
 
 // ─── Subscription Sharing (plan operator → user onboarding) ────────────────
@@ -384,6 +388,15 @@ export {
   DEFAULT_DNS_PRESET,
   DNS_FALLBACK_ORDER,
   resolveDnsServers,
+  // Runtime endpoint management
+  addRpcEndpoint,
+  addLcdEndpoint,
+  removeRpcEndpoint,
+  removeLcdEndpoint,
+  setEndpoints,
+  getEndpoints,
+  checkRpcEndpointHealth,
+  optimizeEndpoints,
 } from './defaults.js';
 
 // ─── Typed Errors ────────────────────────────────────────────────────────────

package/node-connect.js

@@ -33,10 +33,17 @@ import os from 'os';
 
 import {
   createWallet, privKeyFromMnemonic, createClient, broadcast, broadcastWithFeeGrant,
-  extractId, findExistingSession, getBalance, MSG_TYPES, resolveNodeUrl,
-  fetchActiveNodes, filterNodes, queryNode, buildEndSessionMsg,
+  extractId, getBalance, MSG_TYPES,
+  filterNodes, buildEndSessionMsg,
 } from './cosmjs-setup.js';
 
+import {
+  findExistingSession, fetchActiveNodes, queryNode, resolveNodeUrl,
+  resetQueryRpcCache,
+} from './chain/queries.js';
+
+import { disconnectRpc } from './chain/rpc.js';
+
 import {
   nodeStatusV3, generateWgKeyPair, initHandshakeV3,
   writeWgConfig, generateV2RayUUID, initHandshakeV3V2Ray,
@@ -385,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):
@@ -441,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;
   }
 
@@ -516,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.
@@ -539,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;
   }
@@ -597,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
@@ -2432,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.2.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 };

package/session-manager.js

@@ -21,7 +21,7 @@ import path from 'path';
 import os from 'os';
 import { ChainError, ErrorCodes } from './errors.js';
 import { DEFAULT_LCD } from './defaults.js';
-import { lcdPaginatedSafe } from './cosmjs-setup.js';
+import { querySessions } from './chain/queries.js';
 import { loadPoisonedKeys, savePoisonedKeys } from './state.js';
 
 // ─── Constants ───────────────────────────────────────────────────────────────
@@ -94,11 +94,11 @@ export class SessionManager {
     }
 
     const map = new Map();
-    const queryPath = `/sentinel/session/v3/sessions?address=${addr}&status=1`;
 
     let items;
     try {
-      const result = await lcdPaginatedSafe(this._lcdUrl, queryPath, 'sessions');
+      // RPC-first via chain/queries.js — returns flattened sessions
+      const result = await querySessions(addr, this._lcdUrl, { status: '1' });
       items = result.items || [];
     } catch (err) {
       throw new ChainError(
@@ -109,13 +109,15 @@ export class SessionManager {
     }
 
     for (const s of items) {
+      // querySessions returns flat sessions (base_session unwrapped)
       const bs = s.base_session || s;
       const nodeAddr = bs.node_address || bs.node;
       if (!nodeAddr) continue;
 
       const acct = bs.acc_address || bs.address;
       if (acct && acct !== addr) continue;
-      if (bs.status && bs.status !== 'active') continue;
+      // RPC returns status as number (1=active), LCD as string
+      if (bs.status && bs.status !== 'active' && bs.status !== 1) continue;
 
       const maxBytes = parseInt(bs.max_bytes || '0');
       const used = parseInt(bs.download_bytes || '0') + parseInt(bs.upload_bytes || '0');