blue-js-sdk 2.3.0 → 2.6.0

package/cosmjs-setup.js

@@ -87,6 +87,8 @@ import {
   getExpiringGrants as _getExpiringGrants,
   renewExpiringGrants as _renewExpiringGrants,
   monitorFeeGrants as _monitorFeeGrants,
+  streamGrantPlanSubscribers as _streamGrantPlanSubscribers,
+  computeFeeGrantGasCosts as _computeFeeGrantGasCosts,
 } from './chain/fee-grants.js';
 
 // ─── Input Validation Helpers ────────────────────────────────────────────────
@@ -462,29 +464,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 ───────────────────────────────────────────────────────────
 
@@ -503,9 +487,15 @@ export async function getBalance(client, address) {
  * Returns session ID (BigInt) or null. Use this to avoid double-paying.
  *
  * Note: Sessions have a nested base_session object containing the actual data.
+ *
+ * @param {string} lcdUrl - LCD endpoint URL
+ * @param {string} walletAddr - sent1... wallet address
+ * @param {string} nodeAddr - sentnode1... node address
+ * @param {object} [opts] - Optional. Pass `{ onStaleDuplicate: (BigInt) => void }` to
+ *   receive fire-and-forget cancellation callbacks for stale duplicate sessions.
  */
-export async function findExistingSession(lcdUrl, walletAddr, nodeAddr) {
-  return _findExistingSession(lcdUrl, walletAddr, nodeAddr);
+export async function findExistingSession(lcdUrl, walletAddr, nodeAddr, opts) {
+  return _findExistingSession(lcdUrl, walletAddr, nodeAddr, opts);
 }
 
 /**
@@ -933,90 +923,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) ──────────────────────────────────────────
 
@@ -1107,6 +1014,22 @@ export function monitorFeeGrants(opts = {}) {
   return _monitorFeeGrants(opts);
 }
 
+/**
+ * Stream progress as we grant fee allowances to all plan subscribers in batches.
+ * Async generator. See chain/fee-grants.js for event shapes.
+ */
+export function streamGrantPlanSubscribers(planId, opts = {}) {
+  return _streamGrantPlanSubscribers(planId, opts);
+}
+
+/**
+ * Sum udvpn fees the granter has paid on behalf of a plan's subscribers.
+ * Iterates subscribers, pulls TX history, filters on fee.granter.
+ */
+export async function computeFeeGrantGasCosts(planId, opts = {}) {
+  return _computeFeeGrantGasCosts(planId, opts);
+}
+
 // ─── Query Helpers (v25c) ────────────────────────────────────────────────────
 
 /**
@@ -1176,53 +1099,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/index.js

@@ -27,6 +27,9 @@ export {
   enrichNodes,
   buildNodeIndex,
   disconnect,
+  disconnectAndEndSession,
+  disconnectState,
+  disconnectStateAndEndSession,
   isConnected,
   getStatus,
   registerCleanupHandlers,
@@ -52,7 +55,6 @@ export {
   disableDnsLeakPrevention,
   events,
   ConnectionState,
-  disconnectState,
   tryFastReconnect,
 } from './node-connect.js';
 
@@ -311,6 +313,7 @@ export {
   rpcQueryFeeGrantsIssued,
   rpcQueryAuthzGrants,
   rpcQueryProvider,
+  rpcGetTxByHash,
 } from './chain/rpc.js';
 
 // ─── Subscription Sharing (plan operator → user onboarding) ────────────────
@@ -323,6 +326,7 @@ export {
 
 export {
   querySubscriptionAllocations,
+  getTxByHash,
 } from './chain/queries.js';
 
 // ─── TypeScript Client (extends CosmJS SigningStargateClient) ───────────────

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
@@ -1008,7 +1011,17 @@ export async function connectDirect(opts) {
     if (!forceNewSession) {
       progress(onProgress, logFn, 'session', 'Checking for existing session...');
       checkAborted(signal);
-      sessionId = await findExistingSession(lcd, account.address, opts.nodeAddress);
+      sessionId = await findExistingSession(lcd, account.address, opts.nodeAddress, {
+        // Dedup: if multiple active sessions exist for this node (stale duplicates from
+        // crashes or multi-client wallets), keep the highest-ID one. Silently cancel stale
+        // lower-ID sessions before MsgStartSession — mirrors C# SessionManager dedup pattern.
+        onStaleDuplicate: (staleId) => {
+          logFn?.(`[connect] Cancelling stale duplicate session ${staleId} on ${opts.nodeAddress}...`);
+          _endSessionOnChain(staleId, opts.mnemonic, opts.feeGranter || null).catch(e => {
+            logFn?.(`[connect] Failed to cancel stale session ${staleId}: ${e.message}`);
+          });
+        },
+      });
       if (sessionId && isSessionPoisoned(String(sessionId))) {
         progress(onProgress, logFn, 'session', `Session ${sessionId} previously failed — skipping`);
         sessionId = null;
@@ -1457,8 +1470,10 @@ async function connectInternal(opts, paymentStrategy, retryStrategy, state = _de
         { nodeAddress: state.connection?.nodeAddress });
     }
     const prev = state.connection;
-    await disconnectState(state);
-    if (opts.log || defaultLog) (opts.log || defaultLog)(`[connect] Disconnected from ${prev?.nodeAddress || 'previous node'}`);
+    // Hard disconnect: user is actively connecting to a different node,
+    // so the old session should be settled and the deposit refunded.
+    await disconnectStateAndEndSession(state);
+    if (opts.log || defaultLog) (opts.log || defaultLog)(`[connect] Ended session on ${prev?.nodeAddress || 'previous node'} — connecting to new node`);
   }
 
   const onProgress = opts.onProgress || null;
@@ -2264,13 +2279,35 @@ function formatUptime(ms) {
 }
 
 // ─── Disconnect ──────────────────────────────────────────────────────────────
+//
+// TWO DISCONNECT PATHS — CHOOSE INTENT EXPLICITLY.
+//
+// Soft: disconnect() / disconnectState(state)
+//   - Tears down the local tunnel (WireGuard/V2Ray) and cleans up system state.
+//   - Leaves the on-chain session in status=1 (active).
+//   - Next connectDirect() to the SAME node reuses the session via
+//     findExistingSession — no new MsgStartSession TX, no new payment, bandwidth preserved.
+//   - Use when: user is pausing, network changed, closing the app temporarily.
+//
+// Hard: disconnectAndEndSession() / disconnectStateAndEndSession(state)
+//   - Tears down the tunnel AND broadcasts MsgCancelSession on chain.
+//   - Session moves status=1 → settling → refund after ~2h settlement window.
+//   - Use when: user is done with this node, switching nodes permanently,
+//     or wants the bandwidth deposit back.
+//
+// Internal: _disconnectInternal(state, { endSession })
+//   - Caller MUST pass endSession explicitly as true or false.
+//   - No default — forces intentional choice at every callsite.
 
 /**
- * Clean up all active tunnels and system proxy.
- * ALWAYS call this on exit — a stale WireGuard tunnel will kill your internet.
+ * Internal disconnect implementation. Caller must explicitly pass endSession.
+ * @param {object} state - ConnectionState instance
+ * @param {{ endSession: boolean }} opts
+ *   endSession: true  → broadcast MsgCancelSession (hard disconnect)
+ *   endSession: false → preserve on-chain session for reuse (soft disconnect)
+ * @private
  */
-/** Disconnect a specific state instance (internal). */
-export async function disconnectState(state) {
+async function _disconnectInternal(state, { endSession }) {
   // v30: Signal any running connectAuto() retry loop to abort, and release the
   // connection lock so the user can reconnect after disconnect completes.
   _abortConnect = true;
@@ -2296,11 +2333,18 @@ export async function disconnectState(state) {
       state.wgTunnel = null;
     }
 
-    // End session on chain (best-effort, fire-and-forget — never blocks disconnect)
-    if (prev?.sessionId && state._mnemonic) {
-      _endSessionOnChain(prev.sessionId, state._mnemonic, state._feeGranter).catch(e => {
-        console.warn(`[sentinel-sdk] Failed to end session ${prev.sessionId} on chain: ${e.message}`);
-      });
+    if (endSession) {
+      // Hard disconnect: broadcast MsgCancelSession — session settles and refunds deposit.
+      if (prev?.sessionId && state._mnemonic) {
+        _endSessionOnChain(prev.sessionId, state._mnemonic, state._feeGranter).catch(e => {
+          console.warn(`[sentinel-sdk] Failed to end session ${prev.sessionId} on chain: ${e.message}`);
+        });
+      }
+    } else {
+      // Soft disconnect: leave session on chain in status=1 for reuse.
+      if (prev?.sessionId) {
+        console.log(`[sentinel-sdk] Session ${prev.sessionId} preserved on chain (status=1) for future reuse — no MsgCancelSession broadcast.`);
+      }
     }
   } finally {
     // ALWAYS clear connection state — even if teardown threw
@@ -2314,8 +2358,55 @@ export async function disconnectState(state) {
   }
 }
 
+/**
+ * Soft disconnect — tear down the local tunnel, leave the on-chain session active.
+ *
+ * A subsequent connectDirect() to the SAME node will reuse the session via
+ * findExistingSession — no new MsgStartSession TX, no new payment, remaining
+ * bandwidth is preserved.
+ *
+ * Use when: user is pausing, network changed, or closing the app temporarily.
+ * To settle the session on-chain and reclaim the unused deposit, use
+ * disconnectAndEndSession() instead.
+ *
+ * @param {object} state - ConnectionState instance
+ */
+export async function disconnectState(state) {
+  return _disconnectInternal(state, { endSession: false });
+}
+
+/**
+ * Soft disconnect (default state) — tear down the tunnel, leave on-chain session active.
+ *
+ * @see disconnectState
+ */
 export async function disconnect() {
-  return disconnectState(_defaultState);
+  return _disconnectInternal(_defaultState, { endSession: false });
+}
+
+/**
+ * Hard disconnect — tear down the tunnel AND broadcast MsgCancelSession on chain.
+ *
+ * The session settles after the ~2h inactive_pending window. The node refunds
+ * the unused portion of the bandwidth deposit (for peer-to-peer sessions).
+ * For plan-based sessions, this stops metering against the plan allocation.
+ *
+ * Use when: user is done with this node (switching nodes permanently, ending
+ * their session, or wants the deposit back).
+ *
+ * @param {object} state - ConnectionState instance
+ */
+export async function disconnectStateAndEndSession(state) {
+  return _disconnectInternal(state, { endSession: true });
+}
+
+/**
+ * Hard disconnect (default state) — tear down the tunnel AND broadcast MsgCancelSession.
+ *
+ * @see disconnectStateAndEndSession
+ */
+export async function disconnectAndEndSession() {
+  return _disconnectInternal(_defaultState, { endSession: true });
 }
 
 // ─── Session End (on-chain cleanup) ──────────────────────────────────────────
@@ -2436,15 +2527,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/operator.js

@@ -77,6 +77,8 @@ export {
   grantPlanSubscribers,
   renewExpiringGrants,
   monitorFeeGrants,
+  streamGrantPlanSubscribers,
+  computeFeeGrantGasCosts,
 } from './cosmjs-setup.js';
 
 // ─── Authz ──────────────────────────────────────────────────────────────────

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "blue-js-sdk",
-  "version": "2.3.0",
+  "version": "2.6.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",
   "types": "types/index.d.ts",
   "bin": {
-    "sentinel": "./cli/index.js",
-    "sentinel-ai": "./ai-path/cli.js"
+    "sentinel": "./cli/index.js"
   },
   "exports": {
     ".": {
@@ -16,7 +15,6 @@
     },
     "./consumer": "./consumer.js",
     "./operator": "./operator.js",
-    "./ai-path": "./ai-path/index.js",
     "./blue": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
@@ -49,7 +47,6 @@
     "errors/",
     "examples/",
     "docs/",
-    "ai-path/",
     "bin/setup.js",
     "dist/",
     "src/",

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/types/index.d.ts

@@ -469,8 +469,8 @@ export function isMnemonicValid(mnemonic: string): boolean;
 /** Get current P2P price in USD */
 export function getDvpnPrice(): Promise<number>;
 
-/** Find existing active session for wallet+node pair */
-export function findExistingSession(lcdUrl: string, walletAddr: string, nodeAddr: string): Promise<bigint | null>;
+/** Find existing active session for wallet+node pair. Deduplicates stale sessions via onStaleDuplicate callback. */
+export function findExistingSession(lcdUrl: string, walletAddr: string, nodeAddr: string, opts?: { onStaleDuplicate?: (sessionId: bigint) => void }): Promise<bigint | null>;
 
 /** Fetch active nodes from LCD with pagination */
 export function fetchActiveNodes(lcdUrl: string, limit?: number, maxPages?: number): Promise<unknown[]>;