blue-js-sdk 2.3.0 → 2.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 JavaScript/TypeScript SDK for the [Sentinel](https://sentinel.co) decentralized VPN network. WireGuard + V2Ray tunnels, Cosmos blockchain, 900+ nodes. RPC queries, typed events, CosmJS compatible.
 
-**Also available:** [Blue C# SDK](https://github.com/Sentinel-Autonomybuilder/blue-csharp-sdk) | [Blue AI Connect](https://github.com/Sentinel-Autonomybuilder/blue-ai-connect) (zero-config wrapper for AI agents)
+**Also available:** [Blue C# SDK](https://github.com/Sentinel-Autonomybuilder/blue-csharp-sdk) | [Blue Agent Connect](https://github.com/Sentinel-Autonomybuilder/blue-agent-connect) (zero-config wrapper for AI agents)
 
 ## Platform Support
 
@@ -18,7 +18,7 @@ JavaScript/TypeScript SDK for the [Sentinel](https://sentinel.co) decentralized
 
 ---
 
-> **For AI agents:** If you just want `connect()` with one function call, use [`blue-ai-connect`](https://www.npmjs.com/package/blue-ai-connect) instead.
+> **For AI agents:** If you just want `connect()` with one function call, use [`blue-agent-connect`](https://www.npmjs.com/package/blue-agent-connect) instead.
 
 ## Install
 
@@ -46,7 +46,7 @@ await disconnect();
 
 ## For AI Agents
 
-Use [sentinel-ai-connect](https://www.npmjs.com/package/sentinel-ai-connect) — a zero-config wrapper with one function call from zero to encrypted tunnel.
+Use [blue-agent-connect](https://www.npmjs.com/package/blue-agent-connect) — a zero-config wrapper with one function call from zero to encrypted tunnel.
 
 ## Features
 

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
 }
@@ -354,3 +354,199 @@ export function monitorFeeGrants(opts = {}) {
 
   return emitter;
 }
+
+// ─── Streaming Batch Grant (for SSE / progress UIs) ──────────────────────────
+
+/**
+ * Stream progress as we grant fee allowances to all plan subscribers in batches.
+ *
+ * Async generator. Yields events with `{ type, ...payload }`:
+ *   - status      { msg }                                  — human-readable status line
+ *   - batch_start { batch, total, count, addresses }       — about to broadcast a batch
+ *   - batch_ok    { batch, total, granted, totalGranted, txHash, elapsed }
+ *   - batch_error { batch, total, error, elapsed }
+ *   - done        { granted, skipped, total, errors? }
+ *   - error       { msg }
+ *
+ * The caller passes a `broadcast(msgs, memo)` function — any safe-broadcaster
+ * with the Plan Manager's mutex + sequence-retry semantics works. Consumer
+ * routes layer SSE (`res.write('data: ...\n\n')`) on top of these events.
+ *
+ * @param {number|string} planId
+ * @param {object} opts
+ * @param {string} opts.granterAddress - Plan owner paying fees
+ * @param {string} opts.lcdUrl - LCD endpoint
+ * @param {(msgs: Array, memo: string) => Promise<{code:number, rawLog?:string, transactionHash?:string}>} opts.broadcast
+ * @param {object} [opts.grantOpts] - { spendLimit, expiration } for BasicAllowance
+ * @param {number} [opts.batchSize=5] - Msgs per TX
+ * @param {() => boolean} [opts.isCancelled] - Return true to abort between batches
+ * @yields {{type: string, [key: string]: any}}
+ */
+export async function* streamGrantPlanSubscribers(planId, opts = {}) {
+  const {
+    granterAddress,
+    lcdUrl,
+    broadcast,
+    grantOpts = {},
+    batchSize = 5,
+    isCancelled = () => false,
+  } = opts;
+
+  if (!granterAddress) throw new ValidationError(ErrorCodes.INVALID_OPTIONS, 'granterAddress is required');
+  if (typeof broadcast !== 'function') throw new ValidationError(ErrorCodes.INVALID_OPTIONS, 'broadcast function is required');
+
+  try {
+    yield { type: 'status', msg: 'Fetching plan subscribers...' };
+    const { subscribers } = await queryPlanSubscribers(planId, { lcdUrl });
+
+    const now = new Date();
+    const activeSubs = subscribers.filter(s => {
+      if (s.status && s.status !== 'active') return false;
+      if (s.inactive_at && new Date(s.inactive_at) <= now) return false;
+      return true;
+    });
+    const uniqueAddrs = [...new Set(activeSubs.map(s => s.acc_address || s.address))]
+      .filter(a => a && a !== granterAddress && !isSameKey(a, granterAddress));
+
+    yield { type: 'status', msg: `Found ${activeSubs.length} active subscribers (${uniqueAddrs.length} unique, excl. self)` };
+
+    if (uniqueAddrs.length === 0) {
+      yield { type: 'done', granted: 0, skipped: 0, total: 0, msg: 'No active subscribers (excluding self)' };
+      return;
+    }
+
+    yield { type: 'status', msg: 'Checking existing grants...' };
+    const existing = await queryFeeGrantsIssued(lcdUrl || LCD_ENDPOINTS[0].url, granterAddress);
+    const existingGrantees = new Set(existing.map(g => g.grantee));
+    const needGrant = uniqueAddrs.filter(a => !existingGrantees.has(a));
+    const skipped = uniqueAddrs.length - needGrant.length;
+
+    yield { type: 'status', msg: `${existingGrantees.size} existing grants found. ${needGrant.length} need granting, ${skipped} already covered.` };
+
+    if (needGrant.length === 0) {
+      yield { type: 'done', granted: 0, skipped, total: 0, msg: 'All subscribers already have grants' };
+      return;
+    }
+
+    const totalBatches = Math.ceil(needGrant.length / batchSize);
+    let granted = 0;
+    const errors = [];
+
+    for (let i = 0; i < needGrant.length; i += batchSize) {
+      if (isCancelled()) break;
+
+      const batchNum = Math.floor(i / batchSize) + 1;
+      const batch = needGrant.slice(i, i + batchSize);
+      const shortAddrs = batch.map(a => a.slice(0, 12) + '...' + a.slice(-6)).join(', ');
+
+      yield { type: 'batch_start', batch: batchNum, total: totalBatches, count: batch.length, addresses: shortAddrs };
+
+      const msgs = batch.map(grantee => buildFeeGrantMsg(granterAddress, grantee, grantOpts));
+
+      const t0 = Date.now();
+      try {
+        const result = await broadcast(msgs, `Fee grant batch ${batchNum}/${totalBatches}`);
+        const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+
+        if (result.code !== 0) {
+          const errMsg = result.rawLog || `TX failed code=${result.code}`;
+          yield { type: 'batch_error', batch: batchNum, total: totalBatches, error: errMsg, elapsed };
+          errors.push(`Batch ${batchNum}: ${errMsg}`);
+        } else {
+          granted += batch.length;
+          yield {
+            type: 'batch_ok',
+            batch: batchNum,
+            total: totalBatches,
+            granted: batch.length,
+            totalGranted: granted,
+            txHash: result.transactionHash,
+            elapsed,
+          };
+        }
+      } catch (e) {
+        const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+        yield { type: 'batch_error', batch: batchNum, total: totalBatches, error: e.message, elapsed };
+        errors.push(`Batch ${batchNum}: ${e.message}`);
+      }
+    }
+
+    yield {
+      type: 'done',
+      granted,
+      skipped,
+      total: needGrant.length,
+      errors: errors.length ? errors : undefined,
+    };
+  } catch (e) {
+    yield { type: 'error', msg: e.message };
+  }
+}
+
+// ─── Gas Cost Analytics ──────────────────────────────────────────────────────
+
+/**
+ * Compute how many udvpn the granter has spent on fee-granted transactions
+ * for a plan's subscribers. Iterates each subscriber, pulls their outgoing
+ * TXs via LCD, and sums fees where `fee.granter === granterAddress`.
+ *
+ * @param {number|string} planId
+ * @param {object} opts
+ * @param {string} opts.granterAddress - Address that paid the fees (plan owner)
+ * @param {string} opts.lcdUrl - LCD endpoint
+ * @param {number} [opts.txLimit=100] - Max TXs to inspect per subscriber
+ * @param {(info: {processed:number, total:number, address:string}) => void} [opts.onProgress]
+ * @returns {Promise<{ totalUdvpn: number, txCount: number, byAddress: Record<string, {udvpn:number, txCount:number}>, subscriberCount: number }>}
+ */
+export async function computeFeeGrantGasCosts(planId, opts = {}) {
+  const { granterAddress, lcdUrl, txLimit = 100, onProgress } = opts;
+  if (!granterAddress) throw new ValidationError(ErrorCodes.INVALID_OPTIONS, 'granterAddress is required');
+
+  const { subscribers } = await queryPlanSubscribers(planId, { lcdUrl });
+  const subscriberAddrs = [...new Set(subscribers.map(s => s.acc_address || s.address))]
+    .filter(a => a && a !== granterAddress);
+
+  if (subscriberAddrs.length === 0) {
+    return { totalUdvpn: 0, txCount: 0, byAddress: {}, subscriberCount: 0 };
+  }
+
+  let totalUdvpn = 0;
+  let txCount = 0;
+  const byAddress = {};
+
+  const base = lcdUrl || LCD_ENDPOINTS[0].url;
+  for (let idx = 0; idx < subscriberAddrs.length; idx++) {
+    const addr = subscriberAddrs[idx];
+    try {
+      const path =
+        `/cosmos/tx/v1beta1/txs?events=${encodeURIComponent("message.sender='" + addr + "'")}` +
+        `&pagination.limit=${txLimit}&order_by=2`;
+      const txData = await lcdQuery(path, { lcdUrl: base });
+      const rawTxs = txData.txs || [];
+
+      let addrGas = 0;
+      let addrTxCount = 0;
+
+      for (const tx of rawTxs) {
+        const fee = tx?.auth_info?.fee;
+        if (fee?.granter === granterAddress) {
+          const udvpnFee = (fee.amount || []).find(f => f.denom === 'udvpn');
+          if (udvpnFee) {
+            addrGas += parseInt(udvpnFee.amount, 10);
+            addrTxCount++;
+          }
+        }
+      }
+
+      if (addrTxCount > 0) {
+        byAddress[addr] = { udvpn: addrGas, txCount: addrTxCount };
+        totalUdvpn += addrGas;
+        txCount += addrTxCount;
+      }
+    } catch { /* skip this subscriber on LCD failure */ }
+
+    if (onProgress) onProgress({ processed: idx + 1, total: subscriberAddrs.length, address: addr });
+  }
+
+  return { totalUdvpn, txCount, byAddress, subscriberCount: subscriberAddrs.length };
+}

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,16 @@ 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.
+ * Delegates to chain/queries.js RPC-first implementation.
  *
- * 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) {
-  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;
+export async function findExistingSession(lcdUrl, walletAddr, nodeAddr, opts) {
+  return _rpcFindExistingSession(lcdUrl, walletAddr, nodeAddr, opts);
 }
 
 /**
@@ -377,176 +387,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 +639,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 +754,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 };