blue-js-sdk 2.0.0

package/test-every-connection.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * TEST EVERY CONNECTION TYPE
+ *
+ * 6 connection combinations:
+ * 1. WireGuard + per-GB + direct
+ * 2. WireGuard + per-Hour + direct
+ * 3. V2Ray + per-GB + direct
+ * 4. V2Ray + per-Hour + direct
+ * 5. WireGuard + plan + fee-granted
+ * 6. V2Ray + plan + fee-granted
+ *
+ * Plus: session cancel for each
+ */
+import 'dotenv/config';
+const mnemonic = process.env.MNEMONIC;
+if (!mnemonic) { console.error('Set MNEMONIC in .env'); process.exit(1); }
+
+import {
+  createWallet, generateWallet, createClient, broadcast,
+  fetchAllNodes, connectDirect, connectViaPlan, disconnect,
+  subscribeToPlan, sendTokens, buildFeeGrantMsg,
+  registerCleanupHandlers, nodeStatusV3, createNodeHttpsAgent,
+  DEFAULT_RPC, MSG_TYPES,
+} from './index.js';
+import { buildEndSessionMsg, sentToSentprov, extractId } from './cosmjs-setup.js';
+
+registerCleanupHandlers();
+
+const R = { pass: 0, fail: 0, errors: [] };
+async function t(name, fn) {
+  try {
+    const r = await fn();
+    if (r) { R.pass++; console.log('  ✓', name); return r; }
+    else { R.fail++; R.errors.push(name); console.log('  ✗', name); return null; }
+  } catch (e) {
+    R.fail++; R.errors.push(name + ': ' + e.message?.slice(0, 120));
+    console.log('  ✗', name, '→', e.message?.slice(0, 120));
+    return null;
+  }
+}
+
+console.log('═══════════════════════════════════════════');
+console.log('  EVERY CONNECTION TYPE — Live Mainnet');
+console.log('═══════════════════════════════════════════\n');
+
+const { wallet: opW, account: opA } = await createWallet(mnemonic);
+const opC = await createClient(DEFAULT_RPC, opW);
+const provAddr = sentToSentprov(opA.address);
+
+// Find one WG and one V2Ray node
+console.log('Finding nodes...');
+const allNodes = await fetchAllNodes();
+let wgNode = null, v2Node = null;
+
+for (const n of allNodes.slice(0, 60)) {
+  if (wgNode && v2Node) break;
+  try {
+    const url = 'https://' + (n.remote_addrs?.[0] || '');
+    if (!url || url === 'https://') continue;
+    const agent = createNodeHttpsAgent(n.address, 'tofu');
+    const s = await nodeStatusV3(url, agent);
+    if (!s.address || s.address === n.address) {
+      if (s.type === 'wireguard' && !wgNode) {
+        wgNode = n; console.log('  WG:', n.address, '-', s.moniker);
+      }
+      if (s.type === 'v2ray' && !v2Node) {
+        v2Node = n; console.log('  V2:', n.address, '-', s.moniker);
+      }
+    }
+  } catch {}
+}
+
+if (!wgNode) { console.log('No WG node found!'); process.exit(1); }
+if (!v2Node) { console.log('No V2Ray node found!'); process.exit(1); }
+
+const V2RAY = process.env.V2RAY_PATH || undefined; // SDK auto-detects
+const baseOpts = { fullTunnel: false, dns: 'handshake', v2rayExePath: V2RAY,
+  onProgress: (s, d) => console.log('     [' + s + ']', d) };
+
+// ═══ 1. WireGuard per-GB ═══
+console.log('\n═══ 1. WireGuard + per-GB + Direct ═══');
+await t('WG-GB', async () => {
+  const r = await connectDirect({ ...baseOpts, mnemonic, nodeAddress: wgNode.address, gigabytes: 1 });
+  console.log('      Session:', r.sessionId, '| Type:', r.serviceType);
+  await disconnect();
+  return r.serviceType === 'wireguard';
+});
+
+// ═══ 2. WireGuard per-Hour ═══
+console.log('\n═══ 2. WireGuard + per-Hour + Direct ═══');
+await t('WG-HOUR', async () => {
+  const r = await connectDirect({ ...baseOpts, mnemonic, nodeAddress: wgNode.address, hours: 1 });
+  console.log('      Session:', r.sessionId, '| Type:', r.serviceType, '(hourly)');
+  await disconnect();
+  return r.serviceType === 'wireguard';
+});
+
+// ═══ 3. V2Ray per-GB ═══
+console.log('\n═══ 3. V2Ray + per-GB + Direct ═══');
+await t('V2-GB', async () => {
+  const r = await connectDirect({ ...baseOpts, mnemonic, nodeAddress: v2Node.address, gigabytes: 1 });
+  console.log('      Session:', r.sessionId, '| Type:', r.serviceType, '| SOCKS:', r.socksPort);
+  await disconnect();
+  return r.serviceType === 'v2ray';
+});
+
+// ═══ 4. V2Ray per-Hour ═══
+console.log('\n═══ 4. V2Ray + per-Hour + Direct ═══');
+await t('V2-HOUR', async () => {
+  const r = await connectDirect({ ...baseOpts, mnemonic, nodeAddress: v2Node.address, hours: 1 });
+  console.log('      Session:', r.sessionId, '| Type:', r.serviceType, '| SOCKS:', r.socksPort, '(hourly)');
+  await disconnect();
+  return r.serviceType === 'v2ray';
+});
+
+// ═══ 5. WireGuard + Plan + Fee Grant ═══
+console.log('\n═══ 5. WireGuard + Plan + Fee-Granted ═══');
+
+// Recreate operator client to reset sequence cache after direct connection TXs
+const opC2 = await createClient(DEFAULT_RPC, opW);
+
+// Create plan with WG node
+console.log('  Setting up plan...');
+const planMsg = { typeUrl: MSG_TYPES.CREATE_PLAN, value: { from: provAddr, bytes: '100000000', duration: { seconds: 3600 }, prices: [{ denom: 'udvpn', base_value: '0.000000100000000000', quote_value: '100000' }] } };
+const planR = await broadcast(opC2 || opC, opA.address, [planMsg]);
+const wgPlanId = extractId(planR, /plan/i, ['plan_id', 'id']);
+console.log('  Plan:', wgPlanId);
+await new Promise(r => setTimeout(r, 7000));
+
+// Activate + lease + link WG node
+await broadcast(opC2 || opC, opA.address, [{ typeUrl: MSG_TYPES.UPDATE_PLAN_STATUS, value: { from: provAddr, id: parseInt(wgPlanId), status: 1 } }]);
+await new Promise(r => setTimeout(r, 7000));
+const wgHrPrice = wgNode.hourly_prices?.find(p => p.denom === 'udvpn');
+if (wgHrPrice) {
+  try { await broadcast(opC2 || opC, opA.address, [{ typeUrl: MSG_TYPES.START_LEASE, value: { from: provAddr, nodeAddress: wgNode.address, hours: 1, maxPrice: wgHrPrice, renewalPricePolicy: 0 } }]); } catch {}
+  await new Promise(r => setTimeout(r, 7000));
+}
+try { await broadcast(opC2 || opC, opA.address, [{ typeUrl: MSG_TYPES.LINK_NODE, value: { from: provAddr, id: parseInt(wgPlanId), nodeAddress: wgNode.address } }]); } catch {}
+await new Promise(r => setTimeout(r, 7000));
+
+// Create user + fund + subscribe + grant
+const { mnemonic: userMn1, account: userA1 } = await generateWallet();
+await sendTokens(opC2 || opC, opA.address, userA1.address, '3000000', 'udvpn');
+await new Promise(r => setTimeout(r, 8000));
+const { wallet: uW1 } = await createWallet(userMn1);
+const uC1 = await createClient(DEFAULT_RPC, uW1);
+await subscribeToPlan(uC1, userA1.address, wgPlanId);
+await new Promise(r => setTimeout(r, 7000));
+await broadcast(opC2 || opC, opA.address, [buildFeeGrantMsg(opA.address, userA1.address, { spendLimit: 5_000_000 })]);
+await new Promise(r => setTimeout(r, 5000));
+
+await t('WG-PLAN', async () => {
+  const r = await connectViaPlan({ ...baseOpts, mnemonic: userMn1, planId: parseInt(wgPlanId), nodeAddress: wgNode.address, feeGranter: opA.address });
+  console.log('      Session:', r.sessionId, '| Type:', r.serviceType, '(plan, fee-granted)');
+  await disconnect();
+  return r.serviceType === 'wireguard';
+});
+
+// ═══ 6. V2Ray + Plan + Fee Grant ═══
+console.log('\n═══ 6. V2Ray + Plan + Fee-Granted ═══');
+
+// Create plan with V2Ray node
+await new Promise(r => setTimeout(r, 7000));
+const planMsg2 = { typeUrl: MSG_TYPES.CREATE_PLAN, value: { from: provAddr, bytes: '100000000', duration: { seconds: 3600 }, prices: [{ denom: 'udvpn', base_value: '0.000000100000000000', quote_value: '100000' }] } };
+const planR2 = await broadcast(opC2 || opC, opA.address, [planMsg2]);
+const v2PlanId = extractId(planR2, /plan/i, ['plan_id', 'id']);
+console.log('  Plan:', v2PlanId);
+await new Promise(r => setTimeout(r, 7000));
+
+await broadcast(opC2 || opC, opA.address, [{ typeUrl: MSG_TYPES.UPDATE_PLAN_STATUS, value: { from: provAddr, id: parseInt(v2PlanId), status: 1 } }]);
+await new Promise(r => setTimeout(r, 7000));
+// Lease V2Ray node first (required before linking)
+const v2HrPrice = v2Node.hourly_prices?.find(p => p.denom === 'udvpn');
+if (v2HrPrice) {
+  try { await broadcast(opC2 || opC, opA.address, [{ typeUrl: MSG_TYPES.START_LEASE, value: { from: provAddr, nodeAddress: v2Node.address, hours: 1, maxPrice: v2HrPrice, renewalPricePolicy: 0 } }]); console.log('  V2Ray node leased'); } catch (e) { console.log('  Lease:', e.message?.includes('already') ? 'active' : e.message?.slice(0, 60)); }
+  await new Promise(r => setTimeout(r, 7000));
+}
+// Link V2Ray node to plan
+try { await broadcast(opC2 || opC, opA.address, [{ typeUrl: MSG_TYPES.LINK_NODE, value: { from: provAddr, id: parseInt(v2PlanId), nodeAddress: v2Node.address } }]); console.log('  V2Ray node linked'); } catch (e) { console.log('  Link:', e.message?.includes('duplicate') ? 'already linked' : e.message?.slice(0, 60)); }
+await new Promise(r => setTimeout(r, 7000));
+
+const { mnemonic: userMn2, account: userA2 } = await generateWallet();
+await sendTokens(opC2 || opC, opA.address, userA2.address, '3000000', 'udvpn');
+await new Promise(r => setTimeout(r, 8000));
+const { wallet: uW2 } = await createWallet(userMn2);
+const uC2 = await createClient(DEFAULT_RPC, uW2);
+await subscribeToPlan(uC2, userA2.address, v2PlanId);
+await new Promise(r => setTimeout(r, 7000));
+await broadcast(opC2 || opC, opA.address, [buildFeeGrantMsg(opA.address, userA2.address, { spendLimit: 5_000_000 })]);
+await new Promise(r => setTimeout(r, 5000));
+
+await t('V2-PLAN', async () => {
+  const r = await connectViaPlan({ ...baseOpts, mnemonic: userMn2, planId: parseInt(v2PlanId), nodeAddress: v2Node.address, feeGranter: opA.address });
+  console.log('      Session:', r.sessionId, '| Type:', r.serviceType, '| SOCKS:', r.socksPort, '(plan, fee-granted)');
+  await disconnect();
+  return r.serviceType === 'v2ray';
+});
+
+// ═══ RESULTS ═══
+console.log('\n═══════════════════════════════════════════');
+console.log('  RESULTS:', R.pass, '/', (R.pass + R.fail), 'passed');
+if (R.errors.length > 0) {
+  console.log('\n  FAILURES:');
+  for (const e of R.errors) console.log('    ✗', e);
+}
+console.log('═══════════════════════════════════════════');
+process.exit(R.fail > 0 ? 1 : 0);

package/test-feegrant-connect.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * Test: Fee-granted plan connection (the step that failed before).
+ * Uses existing Plan #44 with linked node.
+ * Creates new user, funds, subscribes, grants, connects — all fee-granted.
+ */
+import 'dotenv/config';
+const opMnemonic = process.env.MNEMONIC;
+if (!opMnemonic) { console.error('Set MNEMONIC in .env'); process.exit(1); }
+
+import {
+  createWallet, generateWallet, getBalance, formatP2P, sendTokens,
+  createClient, broadcast, broadcastWithFeeGrant,
+  subscribeToPlan, hasActiveSubscription, queryFeeGrants,
+  buildFeeGrantMsg, connectViaPlan, disconnect,
+  registerCleanupHandlers, DEFAULT_RPC, LCD_ENDPOINTS, MSG_TYPES,
+} from './index.js';
+
+registerCleanupHandlers();
+const PLAN_ID = 44;
+const NODE = 'sentnode1qqywpumwtxxgffqqr9eg94w72tlragzjg0zxs4';
+
+console.log('═══ FEE GRANT CONNECT TEST ═══\n');
+
+// 1. Operator setup
+const { wallet: opW, account: opA } = await createWallet(opMnemonic);
+const opC = await createClient(DEFAULT_RPC, opW);
+console.log('Operator:', opA.address);
+
+// 2. New user
+const { mnemonic: userMnemonic, account: userA } = await generateWallet();
+console.log('User:', userA.address);
+
+// 3. Fund user with 3 P2P (subscription=1P2P + gas for sub TX ~0.3P2P + buffer)
+console.log('\nFunding user with 3 P2P...');
+const sendResult = await sendTokens(opC, opA.address, userA.address, '3000000', 'udvpn');
+console.log('  TX:', sendResult.transactionHash, 'Code:', sendResult.code);
+await new Promise(r => setTimeout(r, 5000));
+
+// 4. Subscribe user to plan
+console.log('\nSubscribing to plan #' + PLAN_ID + '...');
+const { wallet: uW } = await createWallet(userMnemonic);
+const uC = await createClient(DEFAULT_RPC, uW);
+const subResult = await subscribeToPlan(uC, userA.address, PLAN_ID);
+console.log('  Subscription:', subResult.subscriptionId, 'TX:', subResult.txHash);
+await new Promise(r => setTimeout(r, 5000));
+
+// 5. Verify subscription
+const hasSub = await hasActiveSubscription(userA.address, PLAN_ID);
+console.log('  Has subscription:', hasSub.has);
+
+// 6. Fee grant from operator to user
+console.log('\nIssuing fee grant...');
+const grantMsg = buildFeeGrantMsg(opA.address, userA.address, { spendLimit: 5_000_000 });
+const grantResult = await broadcast(opC, opA.address, [grantMsg]);
+console.log('  TX:', grantResult.transactionHash, 'Code:', grantResult.code);
+await new Promise(r => setTimeout(r, 3000));
+
+// 7. Verify fee grant
+const lcd = LCD_ENDPOINTS[0]?.url || LCD_ENDPOINTS[0];
+const grants = await queryFeeGrants(lcd, userA.address);
+console.log('  Grants:', grants.length, grants.length > 0 ? 'from ' + grants[0].granter : '');
+
+// 8. User balance check
+const uBal = await getBalance(uC, userA.address);
+console.log('\nUser balance before connect:', formatP2P(uBal.udvpn));
+
+// 9. Connect via plan with fee grant
+console.log('\nConnecting via plan with fee grant...');
+try {
+  const conn = await connectViaPlan({
+    mnemonic: userMnemonic,
+    planId: PLAN_ID,
+    nodeAddress: NODE,
+    feeGranter: opA.address,
+    fullTunnel: false,
+    dns: 'handshake',
+    v2rayExePath: process.env.V2RAY_PATH || undefined, // SDK auto-detects
+    onProgress: (step, detail) => console.log('  [' + step + ']', detail),
+  });
+
+  console.log('\n✓ CONNECTED!');
+  console.log('  Session:', conn.sessionId);
+  console.log('  Type:', conn.serviceType);
+
+  // Check user balance after (should be same — gas was free)
+  const uBalAfter = await getBalance(uC, userA.address);
+  console.log('  User balance after connect:', formatP2P(uBalAfter.udvpn));
+  console.log('  Gas cost to user:', formatP2P(uBal.udvpn - uBalAfter.udvpn));
+
+  await disconnect();
+  console.log('  Disconnected');
+  console.log('\n═══ TEST PASSED ═══');
+} catch (e) {
+  console.error('\n✗ CONNECT FAILED:', e.message);
+  console.log('\n═══ TEST FAILED ═══');
+  process.exit(1);
+}

package/test-logic.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * Pure logic tests — matches Go's 45 tests exactly.
+ * NO chain calls, NO network, NO tokens. Instant and safe.
+ */
+import {
+  formatP2P, formatPriceP2P, formatNodePricing, estimateSessionPrice,
+  formatBytes, formatUptime, shortAddress, computeSessionAllocation,
+  countryNameToCode, getFlagUrl, getFlagEmoji,
+  GB_OPTIONS, HOUR_OPTIONS,
+  DNS_PRESETS, DEFAULT_DNS_PRESET, DNS_FALLBACK_ORDER, resolveDnsServers,
+  ErrorCodes, ERROR_SEVERITY, isRetryable, userMessage,
+  APP_TYPES, APP_TYPE_CONFIG, validateAppConfig,
+  cached, cacheInvalidate, diskSave, diskLoad,
+  trackSession, getSessionMode, loadAppSettings, APP_SETTINGS_DEFAULTS,
+} from './index.js';
+
+let pass = 0, fail = 0;
+function t(name, result) {
+  if (result) { pass++; }
+  else { fail++; console.log('  ✗', name); }
+}
+
+console.log('═══ HELPERS (19 tests) ═══');
+// FormatP2P
+t('formatP2P 40152030', formatP2P(40152030) === '40.15 P2P');
+t('formatP2P 1000000', formatP2P(1000000) === '1.00 P2P');
+t('formatP2P 0', formatP2P(0) === '0.00 P2P');
+
+// FormatPriceP2P
+t('formatPriceP2P 40152030', formatPriceP2P(40152030) === '40.15');
+t('formatPriceP2P string', formatPriceP2P('1000000') === '1.00');
+
+// FormatBytes
+t('formatBytes 1.5GB', formatBytes(1500000000).includes('GB'));
+t('formatBytes 250MB', formatBytes(250000000).includes('MB'));
+t('formatBytes 1000', formatBytes(1000) === '1000 B' || formatBytes(1000).includes('KB'));
+t('formatBytes 0', formatBytes(0) === '0 B');
+
+// FormatUptime
+t('formatUptime 2h2m', formatUptime(7350000) === '2h 2m');
+t('formatUptime 1m30s', formatUptime(90000) === '1m 30s');
+t('formatUptime 45s', formatUptime(45000) === '45s');
+t('formatUptime 0', formatUptime(0) === '0s');
+
+// ShortAddress
+t('shortAddress', shortAddress('sent1example9pqrse8q4m6lz8alxqv5hkx3fkxe0q', 12, 6).includes('...'));
+
+// ComputeAllocation GB-based
+const allocGb = computeSessionAllocation({ downloadBytes: '500000000', uploadBytes: '100000000', maxBytes: '1000000000', max_duration: '0s' });
+t('allocation GB percent', allocGb.usedPercent === 60);
+t('allocation GB isGbBased', allocGb.isGbBased === true);
+
+// ComputeAllocation hourly
+const allocHr = computeSessionAllocation({ downloadBytes: '100000', uploadBytes: '50000', maxBytes: '1000000000', max_duration: '3600s' });
+t('allocation hourly', allocHr.isHourlyBased === true);
+
+// Options
+t('GB_OPTIONS has 1 and 50', GB_OPTIONS.includes(1) && GB_OPTIONS.includes(50));
+t('HOUR_OPTIONS has 1 and 24', HOUR_OPTIONS.includes(1) && HOUR_OPTIONS.includes(24));
+
+console.log('═══ COUNTRY & FLAGS (13 tests) ═══');
+t('Netherlands → NL', countryNameToCode('The Netherlands') === 'NL');
+t('Türkiye → TR', countryNameToCode('Türkiye') === 'TR');
+t('DR Congo → CD', countryNameToCode('DR Congo') === 'CD');
+t('Czechia → CZ', countryNameToCode('Czechia') === 'CZ');
+t('Russian Federation → RU', countryNameToCode('Russian Federation') === 'RU');
+t('Viet Nam → VN', countryNameToCode('Viet Nam') === 'VN');
+t('South Korea → KR', countryNameToCode('South Korea') === 'KR');
+t('UAE → AE', countryNameToCode('UAE') === 'AE');
+t('us → US', countryNameToCode('us') === 'US');
+t('Atlantis → null', countryNameToCode('Atlantis') === null);
+t('empty → null', countryNameToCode('') === null);
+t('getFlagUrl US', getFlagUrl('US').includes('flagcdn.com'));
+t('getFlagEmoji DE', getFlagEmoji('DE') === '🇩🇪');
+
+console.log('═══ DNS (11 tests) ═══');
+t('default is handshake', DEFAULT_DNS_PRESET === 'handshake');
+t('3 presets', Object.keys(DNS_PRESETS).length === 3);
+t('fallback order 3', DNS_FALLBACK_ORDER.length === 3);
+t('resolve default has handshake', resolveDnsServers().includes('103.196.38.38'));
+t('resolve default has google fallback', resolveDnsServers().includes('8.8.8.8'));
+t('resolve default has cloudflare fallback', resolveDnsServers().includes('1.1.1.1'));
+t('resolve google starts with 8.8.8.8', resolveDnsServers('google').startsWith('8.8.8.8'));
+t('resolve google has handshake fallback', resolveDnsServers('google').includes('103.196.38.38'));
+t('resolve cloudflare starts with 1.1.1.1', resolveDnsServers('cloudflare').startsWith('1.1.1.1'));
+t('resolve custom has fallbacks', resolveDnsServers('9.9.9.9').includes('103.196.38.38'));
+const dnsServers = resolveDnsServers().split(', ');
+t('no duplicate DNS servers', dnsServers.length === new Set(dnsServers).size);
+
+console.log('═══ ERRORS (15 tests) ═══');
+const allCodes = Object.values(ErrorCodes);
+t('33 error codes', allCodes.length === 33);
+t('all have user messages', allCodes.every(c => userMessage(c) !== 'An unexpected error occurred.'));
+t('unknown code → default', userMessage('FAKE_CODE') === 'An unexpected error occurred.');
+t('INSUFFICIENT_BALANCE is fatal', ERROR_SEVERITY[ErrorCodes.INSUFFICIENT_BALANCE] === 'fatal');
+t('NODE_OFFLINE is retryable', ERROR_SEVERITY[ErrorCodes.NODE_OFFLINE] === 'retryable');
+t('SESSION_EXISTS is recoverable', ERROR_SEVERITY[ErrorCodes.SESSION_EXISTS] === 'recoverable');
+t('V2RAY_NOT_FOUND is infrastructure', ERROR_SEVERITY[ErrorCodes.V2RAY_NOT_FOUND] === 'infrastructure');
+t('isRetryable NODE_OFFLINE', isRetryable(ErrorCodes.NODE_OFFLINE) === true);
+t('isRetryable INVALID_MNEMONIC', isRetryable(ErrorCodes.INVALID_MNEMONIC) === false);
+t('userMessage INSUFFICIENT_BALANCE', userMessage(ErrorCodes.INSUFFICIENT_BALANCE).includes('P2P'));
+t('userMessage NODE_OFFLINE', userMessage(ErrorCodes.NODE_OFFLINE).includes('offline'));
+t('userMessage V2RAY_NOT_FOUND', userMessage(ErrorCodes.V2RAY_NOT_FOUND).includes('V2Ray'));
+t('userMessage ABORTED', userMessage(ErrorCodes.ABORTED).includes('cancelled'));
+t('userMessage INVALID_ASSIGNED_IP', userMessage(ErrorCodes.INVALID_ASSIGNED_IP).includes('invalid'));
+t('userMessage CHAIN_LAG', userMessage(ErrorCodes.CHAIN_LAG).includes('confirmed'));
+
+console.log('═══ APP TYPES (6 tests) ═══');
+t('3 app types', Object.keys(APP_TYPES).length === 3);
+t('WHITE_LABEL exists', APP_TYPES.WHITE_LABEL === 'white_label');
+t('DIRECT_P2P exists', APP_TYPES.DIRECT_P2P === 'direct_p2p');
+t('validate valid', validateAppConfig('white_label', { planId: 42, mnemonic: 'x' }).valid === true);
+t('validate invalid', validateAppConfig('white_label', {}).valid === false);
+t('validate bad type', validateAppConfig('fake', {}).valid === false);
+
+console.log('═══ CACHE & SETTINGS (6 tests) ═══');
+const v1 = await cached('logic-test', 5000, async () => 42);
+const v2 = await cached('logic-test', 5000, async () => 99);
+t('cached returns first', v1 === 42 && v2 === 42);
+cacheInvalidate('logic-test');
+const v3 = await cached('logic-test', 5000, async () => 77);
+t('cache invalidate works', v3 === 77);
+diskSave('logic-test-rt', { x: 1 });
+t('diskSave + diskLoad', diskLoad('logic-test-rt', 60000)?.data?.x === 1);
+trackSession('99999', 'hour');
+t('trackSession', getSessionMode('99999') === 'hour');
+const settings = loadAppSettings();
+t('default settings', settings.dnsPreset === 'handshake' && settings.fullTunnel === true);
+t('APP_SETTINGS_DEFAULTS', APP_SETTINGS_DEFAULTS.statusPollSec === 3);
+
+// ═══ PRICING (5 tests) ═══
+console.log('═══ PRICING (5 tests) ═══');
+const mockNode = {
+  gigabyte_prices: [{ denom: 'udvpn', quote_value: '40152030' }],
+  hourly_prices: [{ denom: 'udvpn', quote_value: '18384000' }],
+};
+const pricing = formatNodePricing(mockNode);
+t('formatNodePricing perGb', pricing.perGb?.includes('P2P/GB'));
+t('formatNodePricing perHour', pricing.perHour?.includes('P2P/hr'));
+t('formatNodePricing cheapest', pricing.cheapest === 'hour');
+const gbCost = estimateSessionPrice(mockNode, 'gb', 5);
+t('estimateSessionPrice gb', gbCost.costUdvpn > 0);
+const hrCost = estimateSessionPrice(mockNode, 'hour', 4);
+t('estimateSessionPrice hour', hrCost.costUdvpn > 0);
+
+console.log(`\n═══ RESULTS: ${pass} passed, ${fail} failed (${pass + fail} total) ═══`);
+process.exit(fail > 0 ? 1 : 0);

package/test-mainnet.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+/**
+ * Live mainnet verification — tests every SDK feature against the real chain.
+ * Uses the node-tester wallet. Costs ~1-2 P2P per run (one session).
+ */
+
+import 'dotenv/config';
+const mnemonic = process.env.MNEMONIC;
+if (!mnemonic) { console.error('Set MNEMONIC in .env'); process.exit(1); }
+
+import {
+  createWallet, getBalance, formatP2P, fetchAllNodes,
+  formatNodePricing, estimateSessionPrice, countryNameToCode, getFlagUrl,
+  GB_OPTIONS, HOUR_OPTIONS, discoverPlans, preflight,
+  validateAppConfig, cached, diskSave, diskLoad, trackSession, getSessionMode,
+  loadAppSettings, formatUptime, computeSessionAllocation,
+  resolveDnsServers, APP_TYPES, connectDirect, disconnect,
+  registerCleanupHandlers, nodeStatusV3, createNodeHttpsAgent,
+  DEFAULT_RPC, userMessage, ErrorCodes,
+} from './index.js';
+import { createClient } from './cosmjs-setup.js';
+
+registerCleanupHandlers();
+
+const R = { pass: 0, fail: 0, errors: [] };
+async function t(name, fn) {
+  try {
+    const r = await fn();
+    if (r) { R.pass++; console.log('  ✓', name); }
+    else { R.fail++; R.errors.push(name); console.log('  ✗', name, '→ falsy'); }
+  } catch (e) {
+    R.fail++; R.errors.push(name + ': ' + e.message?.slice(0, 120));
+    console.log('  ✗', name, '→', e.message?.slice(0, 120));
+  }
+}
+
+// ═══ WALLET ═══
+console.log('\n═══ WALLET ═══');
+const { wallet, account } = await createWallet(mnemonic);
+await t('1.1 address starts with sent1', async () => account.address.startsWith('sent1'));
+const client = await createClient(DEFAULT_RPC, wallet);
+const bal = await getBalance(client, account.address);
+await t('1.2 balance > 0', async () => { console.log('      Balance:', formatP2P(bal.udvpn)); return bal.udvpn > 0; });
+
+// ═══ CHAIN QUERIES ═══
+console.log('\n═══ CHAIN QUERIES ═══');
+const allNodes = await fetchAllNodes();
+await t('2.1 fetchAllNodes > 900', async () => { console.log('      Nodes:', allNodes.length); return allNodes.length > 900; });
+await t('2.2 nodes have pricing', async () => allNodes.filter(n => n.gigabyte_prices?.length > 0).length > 500);
+const plans = await discoverPlans(undefined, { maxId: 30 });
+await t('2.5 discoverPlans finds plans', async () => { console.log('      Plans:', plans.length); return plans.length > 0; });
+
+// ═══ PRICING ═══
+console.log('\n═══ PRICING ═══');
+const dualNode = allNodes.find(n => n.gigabyte_prices?.length > 0 && n.hourly_prices?.length > 0);
+await t('7.1 formatNodePricing both', async () => {
+  const p = formatNodePricing(dualNode);
+  console.log('      GB:', p.perGb, '| Hr:', p.perHour);
+  return p.perGb && p.perHour;
+});
+await t('7.2 estimateSessionPrice gb', async () => estimateSessionPrice(dualNode, 'gb', 5).costUdvpn > 0);
+await t('7.3 estimateSessionPrice hour', async () => estimateSessionPrice(dualNode, 'hour', 4).costUdvpn > 0);
+
+// ═══ COUNTRY ═══
+console.log('\n═══ COUNTRY & FLAGS ═══');
+await t('8.1 The Netherlands → NL', async () => countryNameToCode('The Netherlands') === 'NL');
+await t('8.2 Türkiye → TR', async () => countryNameToCode('Türkiye') === 'TR');
+await t('8.3 DR Congo → CD', async () => countryNameToCode('DR Congo') === 'CD');
+await t('8.4 getFlagUrl', async () => getFlagUrl('US').includes('flagcdn.com'));
+await t('8.6 unknown → null', async () => countryNameToCode('Atlantis') === null);
+
+// ═══ CACHE ═══
+console.log('\n═══ CACHE & PERSISTENCE ═══');
+await t('9.1 cached TTL + dedup', async () => {
+  let calls = 0;
+  const v1 = await cached('t1', 5000, async () => { calls++; return 42; });
+  const v2 = await cached('t1', 5000, async () => { calls++; return 99; });
+  return v1 === 42 && v2 === 42 && calls === 1;
+});
+await t('9.3 cached stale fallback', async () => {
+  await cached('t2', 1, async () => 'good'); // cache with 1ms TTL
+  await new Promise(r => setTimeout(r, 5)); // expire it
+  const val = await cached('t2', 1, async () => { throw new Error('fail'); });
+  return val === 'good'; // stale fallback
+});
+await t('9.4 diskSave + diskLoad', async () => {
+  diskSave('test-rt', { x: 1 });
+  return diskLoad('test-rt', 60000)?.data?.x === 1;
+});
+await t('9.5 trackSession persist', async () => {
+  trackSession('88888', 'hour');
+  return getSessionMode('88888') === 'hour';
+});
+await t('9.6 loadAppSettings defaults', async () => {
+  const s = loadAppSettings();
+  return s.dnsPreset === 'handshake' && s.fullTunnel === true;
+});
+
+// ═══ DISPLAY ═══
+console.log('\n═══ DISPLAY HELPERS ═══');
+await t('10.1 formatUptime', async () => formatUptime(7350000) === '2h 2m');
+await t('10.3 computeSessionAllocation', async () => {
+  const a = computeSessionAllocation({ downloadBytes: '500000000', uploadBytes: '100000000', maxBytes: '1000000000', max_duration: '0s' });
+  return a.usedPercent === 60 && a.isGbBased;
+});
+await t('10.5 userMessage covers all codes', async () => {
+  const codes = Object.values(ErrorCodes);
+  const covered = codes.filter(c => userMessage(c) !== 'An unexpected error occurred.');
+  console.log('      Covered:', covered.length + '/' + codes.length);
+  return covered.length === codes.length;
+});
+
+// ═══ APP TYPES ═══
+console.log('\n═══ APP TYPES ═══');
+await t('11.1 white_label valid', async () => validateAppConfig('white_label', { planId: 42, mnemonic: 'x' }).valid);
+await t('11.2 white_label missing → errors', async () => !validateAppConfig('white_label', {}).valid);
+await t('11.3 direct_p2p valid', async () => validateAppConfig('direct_p2p', { mnemonic: 'x' }).valid);
+
+// ═══ DNS ═══
+console.log('\n═══ DNS ═══');
+await t('DNS handshake default', async () => resolveDnsServers().includes('103.196.38.38'));
+await t('DNS fallback chain', async () => resolveDnsServers('google').includes('103.196.38.38'));
+
+// ═══ PREFLIGHT ═══
+console.log('\n═══ PREFLIGHT ═══');
+await t('6.5 preflight', async () => {
+  const r = preflight();
+  console.log('      WG:', r.ready.wireguard, '| V2:', r.ready.v2ray);
+  return r.ready.anyProtocol;
+});
+
+// ═══ LIVE CONNECTION ═══
+console.log('\n═══ LIVE WireGuard CONNECTION ═══');
+let wgNode = null;
+for (const n of allNodes.slice(0, 25)) {
+  try {
+    const url = 'https://' + (n.remote_addrs?.[0] || '');
+    if (!url || url === 'https://') continue;
+    const agent = createNodeHttpsAgent(n.address, 'tofu');
+    const status = await nodeStatusV3(url, agent);
+    if (status.type === 'wireguard' && (!status.address || status.address === n.address)) {
+      wgNode = n;
+      console.log('  Found WG:', n.address, '-', status.moniker);
+      break;
+    }
+  } catch {}
+}
+
+if (wgNode) {
+  await t('3.1 connectDirect WG per-GB', async () => {
+    const result = await connectDirect({
+      mnemonic, nodeAddress: wgNode.address, gigabytes: 1,
+      fullTunnel: false, dns: 'handshake',
+      v2rayExePath: process.env.V2RAY_PATH || undefined, // SDK auto-detects
+      onProgress: (step, detail) => console.log('     [' + step + ']', detail),
+    });
+    console.log('      Session:', result.sessionId, 'Type:', result.serviceType);
+    trackSession(result.sessionId, 'gb');
+    console.log('      Tracked mode:', getSessionMode(result.sessionId));
+    await disconnect();
+    console.log('      Disconnected OK');
+    return result.serviceType === 'wireguard';
+  });
+} else {
+  console.log('  SKIP: No WG node reachable in first 25');
+}
+
+// ═══ RESULTS ═══
+console.log('\n═══════════════════════════════════════');
+console.log('RESULTS:', R.pass, 'passed,', R.fail, 'failed');
+if (R.errors.length > 0) {
+  console.log('\nFAILURES:');
+  for (const e of R.errors) console.log('  ✗', e);
+}
+console.log('═══════════════════════════════════════');
+process.exit(R.fail > 0 ? 1 : 0);