blue-js-sdk 2.3.0 → 2.6.0

package/chain/queries.js

@@ -32,6 +32,7 @@ import {
   rpcQueryBalance,
   rpcQueryProvider as _rpcQueryProvider,
   rpcQueryAuthzGrants as _rpcQueryAuthzGrants,
+  rpcGetTxByHash,
 } from './rpc.js';
 
 // Re-export for convenience
@@ -56,6 +57,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 ───────────────────────────────────────────────────────────
 
 /**
@@ -72,8 +82,22 @@ export async function getBalance(client, address) {
  * Find an existing active session for a wallet+node pair.
  * Returns session ID (BigInt) or null. Use this to avoid double-paying.
  * RPC-first with LCD fallback.
+ *
+ * Dedup: if multiple active sessions exist for the same node_address (stale
+ * duplicates from crashes or multi-client wallets), the one with the HIGHEST
+ * session ID is returned. All lower-ID duplicates are passed to `onStaleDuplicate`
+ * (if provided) for fire-and-forget cancellation.
+ *
+ * @param {string} lcdUrl - LCD endpoint URL
+ * @param {string} walletAddr - sent1... wallet address
+ * @param {string} nodeAddr - sentnode1... node address
+ * @param {object} [opts]
+ * @param {function} [opts.onStaleDuplicate] - Called with (BigInt sessionId) for each
+ *   stale lower-ID duplicate session. Caller is responsible for fire-and-forget
+ *   MsgCancelSession. Keeps chain/queries.js dependency-free of signing/broadcast logic.
+ * @returns {Promise<BigInt|null>}
  */
-export async function findExistingSession(lcdUrl, walletAddr, nodeAddr) {
+export async function findExistingSession(lcdUrl, walletAddr, nodeAddr, opts = {}) {
   let sessions;
 
   // RPC-first: returns decoded, flat session objects
@@ -93,6 +117,8 @@ export async function findExistingSession(lcdUrl, walletAddr, nodeAddr) {
     });
   }
 
+  // Collect all non-exhausted active sessions for this node
+  const matching = [];
   for (const s of sessions) {
     if ((s.node_address || s.node) !== nodeAddr) continue;
     // RPC returns status as number (1=active), LCD as string
@@ -102,9 +128,22 @@ export async function findExistingSession(lcdUrl, walletAddr, nodeAddr) {
     if (acct && acct !== walletAddr) continue;
     const maxBytes = parseInt(s.max_bytes || '0');
     const used = parseInt(s.download_bytes || '0') + parseInt(s.upload_bytes || '0');
-    if (maxBytes === 0 || used < maxBytes) return BigInt(s.id);
+    if (maxBytes === 0 || used < maxBytes) matching.push(BigInt(s.id));
+  }
+
+  if (matching.length === 0) return null;
+
+  // Sort descending — highest session ID is the freshest (most recent MsgStartSession)
+  matching.sort((a, b) => (a > b ? -1 : a < b ? 1 : 0));
+
+  // Dedup: cancel stale lower-ID duplicates (fire-and-forget via caller callback)
+  if (matching.length > 1 && typeof opts.onStaleDuplicate === 'function') {
+    for (let i = 1; i < matching.length; i++) {
+      opts.onStaleDuplicate(matching[i]);
+    }
   }
-  return null;
+
+  return matching[0];
 }
 
 /**
@@ -344,9 +383,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 +411,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; }
   }
@@ -832,3 +871,75 @@ export function saveVpnSettings(settings) {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
   writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), { mode: 0o600 });
 }
+
+// ─── TX Hash Lookup (RPC-first, LCD fallback) ───────────────────────────────
+
+/**
+ * Fetch a transaction by hash. RPC is tried first; if it fails or the TX is
+ * not found, falls back to the LCD REST endpoint.
+ *
+ * Accepts bare hex or 0x-prefixed hex for the hash.
+ * Returns the same normalised shape regardless of source:
+ *   { hash, height, code, rawLog, events, gasUsed, gasWanted }
+ *
+ * Use this to re-fetch TX events after a crash/restart or from a different
+ * process (CosmJS only returns DeliverTxResponse inline from signAndBroadcast).
+ *
+ * @param {string} txHash - Transaction hash (bare hex or 0x-prefixed)
+ * @param {object} [opts]
+ * @param {string} [opts.rpcUrl] - RPC endpoint (uses cached client if omitted)
+ * @param {string} [opts.lcdUrl] - LCD endpoint for fallback
+ * @returns {Promise<{ hash: string, height: number, code: number, rawLog: string, events: Array<{ type: string, attributes: Array<{ key: string, value: string }> }>, gasUsed: string, gasWanted: string } | null>}
+ */
+export async function getTxByHash(txHash, opts = {}) {
+  const hex = txHash.replace(/^0x/i, '').toUpperCase();
+
+  // ── RPC-first ──────────────────────────────────────────────────────────────
+  try {
+    let rpc;
+    if (opts.rpcUrl) {
+      const { createRpcQueryClient } = await import('./rpc.js');
+      rpc = await createRpcQueryClient(opts.rpcUrl);
+    } else {
+      rpc = await getRpcClient();
+    }
+    if (rpc?.tmClient) {
+      const result = await rpcGetTxByHash(rpc.tmClient, hex);
+      return result;
+    }
+  } catch (rpcErr) {
+    // "tx not found" from RPC → fall through to LCD
+    const msg = rpcErr?.message || '';
+    if (!msg.toLowerCase().includes('not found') && !msg.toLowerCase().includes('404')) {
+      // Real connectivity error — still fall through, LCD may succeed
+    }
+  }
+
+  // ── LCD fallback ───────────────────────────────────────────────────────────
+  try {
+    const doLcd = async (baseUrl) => {
+      const data = await lcdQuery(`/cosmos/tx/v1beta1/txs/${hex}`, { lcdUrl: baseUrl });
+      const txResp = data?.tx_response;
+      if (!txResp) return null;
+      const events = (txResp.events || []).map(ev => ({
+        type: ev.type,
+        attributes: (ev.attributes || []).map(attr => ({
+          key: attr.key,
+          value: attr.value,
+        })),
+      }));
+      return {
+        hash: (txResp.txhash || hex).toUpperCase(),
+        height: parseInt(txResp.height || '0', 10),
+        code: txResp.code || 0,
+        rawLog: txResp.raw_log || '',
+        events,
+        gasUsed: String(txResp.gas_used || '0'),
+        gasWanted: String(txResp.gas_wanted || '0'),
+      };
+    };
+    if (opts.lcdUrl) return await doLcd(opts.lcdUrl);
+    const { result } = await tryWithFallback(LCD_ENDPOINTS, doLcd, `getTxByHash ${hex}`);
+    return result;
+  } catch { return null; }
+}

package/chain/rpc.js

@@ -402,11 +402,17 @@ function decodeAllocation(fields) {
 /**
  * Query active nodes via RPC.
  *
+ * NOTE ON PAGINATION: Sentinel v3's `QueryNodes` truncates at the requested
+ * `limit` and does NOT emit `pagination.next_key`. A standard Cosmos
+ * "loop while next_key is non-empty" pattern terminates on the first call
+ * and silently loses data. Request above the chain's current hard ceiling
+ * (~1048 active nodes as of 2026-04). Default raised to 10000.
+ *
  * @param {{ queryClient: QueryClient }} client - From createRpcQueryClient()
  * @param {{ status?: number, limit?: number }} [opts]
  * @returns {Promise<Array<{ address: string, gigabyte_prices: Array, hourly_prices: Array, remote_addrs: string[], status: number }>>}
  */
-export async function rpcQueryNodes(client, { status = 1, limit = 500 } = {}) {
+export async function rpcQueryNodes(client, { status = 1, limit = 10000 } = {}) {
   const path = '/sentinel.node.v3.QueryService/QueryNodes';
   const request = concat([
     encodeEnum(1, status),                                        // status field
@@ -446,12 +452,18 @@ export async function rpcQueryNode(client, address) {
 /**
  * Query nodes linked to a plan via RPC.
  *
+ * NOTE ON PAGINATION: `QueryNodesForPlan` silently truncates at the requested
+ * `limit` with no `next_key`. Observed 2026-04: plan 36 has 803 active nodes
+ * but `limit=500` returns exactly 500 with no indication more exist. Default
+ * raised to 10000. If a plan grows beyond that, raise further — the chain's
+ * own ceiling is the effective limit.
+ *
  * @param {{ queryClient: QueryClient }} client
  * @param {number|bigint} planId
  * @param {{ status?: number, limit?: number }} [opts]
  * @returns {Promise<Array>}
  */
-export async function rpcQueryNodesForPlan(client, planId, { status = 1, limit = 500 } = {}) {
+export async function rpcQueryNodesForPlan(client, planId, { status = 1, limit = 10000 } = {}) {
   const path = '/sentinel.node.v3.QueryService/QueryNodesForPlan';
   const request = concat([
     encodeUint64(1, planId),                                     // id
@@ -891,6 +903,50 @@ export async function rpcQueryProvider(client, provAddress) {
   }
 }
 
+// ─── TX Hash Lookup ─────────────────────────────────────────────────────────
+
+/**
+ * Fetch a transaction by hash via Tendermint RPC.
+ * Accepts bare hex (64 chars) or 0x-prefixed hex. Returns a normalized shape
+ * matching the LCD cosmos/tx/v1beta1/txs/{hash} response so callers don't
+ * need to handle both formats.
+ *
+ * @param {import('@cosmjs/tendermint-rpc').Tendermint37Client} tmClient - From createRpcQueryClient().tmClient
+ * @param {string} txHash - TX hash as hex string (bare or 0x-prefixed)
+ * @returns {Promise<{ hash: string, height: number, code: number, rawLog: string, events: Array<{ type: string, attributes: Array<{ key: string, value: string }> }>, gasUsed: string, gasWanted: string }>}
+ * @throws {Error} If the transaction is not found or RPC call fails
+ */
+export async function rpcGetTxByHash(tmClient, txHash) {
+  // Strip optional 0x prefix and normalise to upper-case for consistency
+  const hex = txHash.replace(/^0x/i, '').toUpperCase();
+  // Decode hex string → Uint8Array
+  const hashBytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    hashBytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+
+  const response = await tmClient.tx({ hash: hashBytes });
+
+  // Normalise events: TxData.events is already decoded by CosmJS
+  const events = (response.result.events || []).map(ev => ({
+    type: ev.type,
+    attributes: (ev.attributes || []).map(attr => ({
+      key: attr.key,
+      value: attr.value,
+    })),
+  }));
+
+  return {
+    hash: hex,
+    height: response.height,
+    code: response.result.code,
+    rawLog: response.result.log || '',
+    events,
+    gasUsed: String(response.result.gasUsed),
+    gasWanted: String(response.result.gasWanted),
+  };
+}
+
 export async function rpcQueryBalance(client, address, denom = 'udvpn') {
   const path = '/cosmos.bank.v1beta1.Query/Balance';
   const request = concat([

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/client.js

@@ -28,6 +28,7 @@ import { EventEmitter } from 'events';
 import {
   connectDirect, connectViaPlan, connectAuto, queryOnlineNodes,
   disconnect as sdkDisconnect, disconnectState,
+  disconnectAndEndSession as sdkDisconnectAndEndSession, disconnectStateAndEndSession,
   isConnected as sdkIsConnected, getStatus as sdkGetStatus,
   registerCleanupHandlers, setSystemProxy, clearSystemProxy,
   events as sdkEvents, ConnectionState,
@@ -125,13 +126,28 @@ export class SentinelClient extends EventEmitter {
   }
 
   /**
-   * Disconnect current VPN tunnel.
+   * Soft disconnect — tear down the tunnel, leave the on-chain session active.
+   *
+   * A subsequent connect() to the SAME node reuses the session (no new payment).
+   * Use for pause / temporary disconnect / network-change recovery.
+   * To settle the session and reclaim the deposit, use disconnectAndEndSession().
    */
   async disconnect() {
     await disconnectState(this._state);
     this._connection = null;
   }
 
+  /**
+   * Hard disconnect — tear down the tunnel AND broadcast MsgCancelSession on chain.
+   *
+   * Settles the session after the ~2h window and refunds the unused deposit.
+   * Use when the user is done with this node (switching permanently or wants refund).
+   */
+  async disconnectAndEndSession() {
+    await disconnectStateAndEndSession(this._state);
+    this._connection = null;
+  }
+
   /**
    * Check if a VPN tunnel is currently active.
    */

package/connection/connect.js

@@ -9,7 +9,7 @@ import {
   events, _defaultState, progress, checkAborted,
   warnIfNoCleanup, cachedCreateWallet, _recordMetric,
   broadcastWithInactiveRetry, getConnectLock, setConnectLock,
-  getAbortConnect, setAbortConnect,
+  getAbortConnect, setAbortConnect, _endSessionOnChain,
 } from './state.js';
 
 import {
@@ -31,7 +31,7 @@ import {
 import { createNodeHttpsAgent } from '../tls-trust.js';
 import { disconnectWireGuard } from '../wireguard.js';
 
-import { disconnectState } from './disconnect.js';
+import { disconnectState, disconnectStateAndEndSession } from './disconnect.js';
 import { queryOnlineNodes } from './discovery.js';
 import {
   recordNodeFailure, isCircuitOpen, configureCircuitBreaker,
@@ -79,8 +79,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;
@@ -397,7 +399,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).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;

package/connection/disconnect.js

@@ -28,13 +28,35 @@ import { queryNode, privKeyFromMnemonic } from '../cosmjs-setup.js';
 import { createNodeHttpsAgent } from '../tls-trust.js';
 
 // ─── 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.
   setAbortConnect(true);
@@ -65,11 +87,18 @@ export async function disconnectState(state) {
       try { disableDnsLeakPrevention(); } catch (e) { console.warn('[sentinel-sdk] DNS restore warning:', e.message); }
     }
 
-    // End session on chain (best-effort, fire-and-forget — never blocks disconnect)
-    if (prev?.sessionId && state._mnemonic) {
-      _endSessionOnChain(prev.sessionId, state._mnemonic).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).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
@@ -82,8 +111,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 (defaults to _defaultState)
+ */
+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 (defaults to _defaultState)
+ */
+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 });
 }
 
 // ─── Cleanup Registration ───────────────────────────────────────────────────

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/connection/index.js

@@ -32,6 +32,8 @@ export {
 export {
   disconnect,
   disconnectState,
+  disconnectAndEndSession,
+  disconnectStateAndEndSession,
   registerCleanupHandlers,
   recoverSession,
 } from './disconnect.js';