aether-hub 1.2.4 → 1.2.6

package/commands/rewards.js

@@ -6,10 +6,11 @@
  * Shows accumulated rewards, estimated APY, and claimable amounts.
  *
  * Usage:
- *   aether rewards list --address <addr>         List all rewards per stake account
- *   aether rewards list --address <addr> --json  JSON output for scripting
- *   aether rewards claim --address <addr> --account <stakeAcct> [--json]
- *   aether rewards summary --address <addr>      One-line summary of total rewards
+ *   aether rewards list    --address <addr>         List all rewards per stake account
+ *   aether rewards list    --address <addr> --json  JSON output for scripting
+ *   aether rewards claim   --address <addr> --account <stakeAcct> [--json]
+ *   aether rewards summary --address <addr>         One-line summary of total rewards
+ *   aether rewards compound --address <addr> [--account <stakeAcct>] [--json]  Claim and auto-re-stake
  *
  * Requires AETHER_RPC env var or local node running (default: http://127.0.0.1:8899)
  */
@@ -607,6 +608,184 @@ async function rewardsClaim(args) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Rewards compound command — claim and auto-re-stake
+// ---------------------------------------------------------------------------
+
+async function rewardsCompound(args) {
+  const rpc = args.rpc || getDefaultRpc();
+  const isJson = args.json || false;
+  let address = args.address || null;
+  let stakeAccount = args.account || null;
+
+  const config = loadConfig();
+  const rl = createRl();
+
+  if (!address) {
+    const ans = await question(rl, `\n${C.cyan}Enter wallet address: ${C.reset}`);
+    address = ans.trim();
+  }
+
+  if (!address) {
+    console.log(`\n${C.red}✗ No address provided.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // Load wallet for signing
+  const wallet = loadWallet(address);
+  if (!wallet) {
+    console.log(`\n${C.red}✗ Wallet not found locally: ${address}${C.reset}`);
+    console.log(`  ${C.dim}Import it: aether wallet import${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // Fetch stake accounts
+  let stakeAccounts = await fetchWalletStakeAccounts(address);
+  if (stakeAccounts.length === 0) {
+    console.log(`\n${C.red}✗ No stake accounts found for this wallet.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // If --account specified, filter to that one
+  if (stakeAccount) {
+    stakeAccounts = stakeAccounts.filter(sa => sa === stakeAccount);
+    if (stakeAccounts.length === 0) {
+      console.log(`\n${C.red}✗ Stake account not found: ${stakeAccount}${C.reset}\n`);
+      rl.close();
+      return;
+    }
+  }
+
+  console.log(`\n${C.bright}${C.cyan}╔══════════════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bright}${C.cyan}║              Compound Staking Rewards                          ║${C.reset}`);
+  console.log(`${C.bright}${C.cyan}╚══════════════════════════════════════════════════════════════╝${C.reset}\n`);
+  console.log(`  ${C.dim}Wallet:${C.reset} ${C.bright}${address}${C.reset}`);
+  console.log(`  ${C.dim}RPC:${C.reset} ${rpc}`);
+  console.log(`  ${C.dim}Stake accounts to process:${C.reset} ${stakeAccounts.length}\n`);
+
+  // Ask for mnemonic upfront
+  console.log(`${C.yellow}  ⚠ Compound requires your wallet passphrase to sign transactions.${C.reset}`);
+  const mnemonic = await question(rl, `  ${C.cyan}Enter your 12/24-word mnemonic:${C.reset} `);
+  console.log();
+
+  let keypair;
+  try {
+    if (!bip39.validateMnemonic(mnemonic)) {
+      throw new Error('Invalid BIP39 mnemonic');
+    }
+    keypair = deriveKeypair(mnemonic);
+  } catch (err) {
+    console.log(`  ${C.red}✗ Failed to derive keypair: ${err.message}${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // Verify address matches
+  const derivedAddress = formatAddress(keypair.publicKey);
+  if (derivedAddress !== address) {
+    console.log(`  ${C.red}✗ Passphrase mismatch.${C.reset}`);
+    console.log(`  ${C.dim}  Derived:   ${derivedAddress}${C.reset}`);
+    console.log(`  ${C.dim}  Expected:  ${address}${C.reset}`);
+    console.log(`  ${C.dim}Check your passphrase and try again.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  const compoundResults = [];
+  let totalCompounded = BigInt(0);
+  let successCount = 0;
+
+  for (const sa of stakeAccounts) {
+    console.log(`  ${C.dim}Processing stake account:${C.reset} ${sa.substring(0, 20)}...`);
+
+    try {
+      // Fetch rewards for this stake account
+      const rewardData = await fetchStakeRewards(rpc, sa);
+      if (rewardData.error) {
+        console.log(`    ${C.red}✗ Failed to fetch rewards: ${rewardData.error}${C.reset}`);
+        compoundResults.push({ stake_account: sa, status: 'error', error: rewardData.error });
+        continue;
+      }
+
+      const estimatedRewards = BigInt(rewardData.estimatedRewards);
+      if (estimatedRewards === BigInt(0)) {
+        console.log(`    ${C.yellow}⚠ No rewards to compound${C.reset}`);
+        compoundResults.push({ stake_account: sa, status: 'no_rewards', rewards: '0' });
+        continue;
+      }
+
+      console.log(`    ${C.dim}Rewards to compound:${C.reset} ${rewardData.estimatedRewardsFormatted}`);
+      console.log(`    ${C.dim}Validator:${C.reset} ${rewardData.validator || 'unknown'}`);
+
+      // Build compound transaction (ClaimRewards + Stake in one)
+      const tx = {
+        type: 'CompoundRewards',
+        from: address,
+        stake_account: sa,
+        lamports: estimatedRewards.toString(),
+        validator: rewardData.validator || null,
+        timestamp: Math.floor(Date.now() / 1000),
+      };
+
+      // Sign transaction
+      const txData = JSON.stringify(tx);
+      const txHash = crypto.createHash('sha256').update(txData).digest('hex');
+      const signature = nacl.hash(Buffer.from(txHash, 'hex'));
+      const signatureB58 = bs58.encode(signature.slice(0, 64));
+      tx.signature = signatureB58;
+
+      // Submit transaction
+      const result = await httpPost(rpc, '/v1/tx', tx);
+
+      if (result.success || result.txid || result.signature) {
+        console.log(`    ${C.green}✓ Compounded successfully${C.reset}`);
+        console.log(`      ${C.dim}TX: ${(result.txid || result.signature || signatureB58).substring(0, 20)}...${C.reset}`);
+        totalCompounded += estimatedRewards;
+        successCount++;
+        compoundResults.push({
+          stake_account: sa,
+          status: 'compounded',
+          rewards: estimatedRewards.toString(),
+          rewards_formatted: rewardData.estimatedRewardsFormatted,
+          tx: result.txid || result.signature || signatureB58,
+        });
+      } else {
+        console.log(`    ${C.red}✗ Compound failed: ${result.error || JSON.stringify(result)}${C.reset}`);
+        compoundResults.push({ stake_account: sa, status: 'failed', error: result.error });
+      }
+    } catch (err) {
+      console.log(`    ${C.red}✗ Error: ${err.message}${C.reset}`);
+      compoundResults.push({ stake_account: sa, status: 'error', error: err.message });
+    }
+
+    console.log();
+  }
+
+  rl.close();
+
+  // Summary
+  console.log(`${C.bright}${C.cyan}╔══════════════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bright}${C.cyan}║                    Compound Summary                          ║${C.reset}`);
+  console.log(`${C.bright}${C.cyan}╚══════════════════════════════════════════════════════════════╝${C.reset}\n`);
+  console.log(`  ${C.dim}Accounts processed:${C.reset} ${stakeAccounts.length}`);
+  console.log(`  ${C.green}✓ Successful:${C.reset} ${successCount}`);
+  console.log(`  ${C.dim}Total compounded:${C.reset} ${C.green}${formatAether(totalCompounded.toString())}${C.reset}\n`);
+
+  if (isJson) {
+    console.log(JSON.stringify({
+      address,
+      total_compounded_lamports: totalCompounded.toString(),
+      total_compounded_formatted: formatAether(totalCompounded.toString()),
+      accounts_processed: stakeAccounts.length,
+      successful: successCount,
+      results: compoundResults,
+    }, null, 2));
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Parse CLI args
 // ---------------------------------------------------------------------------
@@ -664,12 +843,16 @@ async function main() {
     case 'claim':
       await rewardsClaim(parsed);
       break;
+    case 'compound':
+      await rewardsCompound(parsed);
+      break;
     default:
       console.log(`\n${C.cyan}Usage:${C.reset}`);
       console.log(`  aether rewards list    --address <addr>  List all staking rewards`);
       console.log(`  aether rewards summary --address <addr>  One-line rewards summary`);
       console.log(`  aether rewards pending --address <addr>  Show pending (unclaimed) rewards`);
       console.log(`  aether rewards claim   --address <addr>  [--account <stakeAcct>]  Claim rewards`);
+      console.log(`  aether rewards compound --address <addr> [--account <stakeAcct>]  Claim and re-stake rewards`);
       console.log();
       console.log(`  ${C.dim}--json   Output as JSON`);
       console.log(`  --rpc <url>  Use specific RPC endpoint${C.reset}\n`);

package/commands/stats.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+/**
+ * aether-cli stats
+ *
+ * Comprehensive wallet stats dashboard:
+ *   - Token balance (AETH + lamports)
+ *   - Active stake positions (validator, amount, status)
+ *   - Recent transactions (last 5)
+ *   - Estimated rewards accrued
+ *
+ * Usage:
+ *   aether stats --address <addr>         Full stats dashboard
+ *   aether stats --address <addr> --json  JSON output for scripting
+ *   aether stats --address <addr> --compact  One-line summary
+ *
+ * Requires AETHER_RPC env var or local node (default: http://127.0.0.1:8899)
+ */
+
+const http = require('http');
+const https = require('https');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const bs58 = require('bs58').default;
+
+// ANSI colours
+const C = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  bold: '\x1b[1m',
+};
+
+// ---------------------------------------------------------------------------
+// Paths & config
+// ---------------------------------------------------------------------------
+
+function getAetherDir() {
+  return path.join(os.homedir(), '.aether');
+}
+
+function getConfigPath() {
+  return path.join(getAetherDir(), 'config.json');
+}
+
+function getWalletsDir() {
+  return path.join(getAetherDir(), 'wallets');
+}
+
+function loadConfig() {
+  const p = getConfigPath();
+  if (!fs.existsSync(p)) return { defaultWallet: null };
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return { defaultWallet: null };
+  }
+}
+
+function loadWallet(address) {
+  const fp = path.join(getWalletsDir(), `${address}.json`);
+  if (!fs.existsSync(fp)) return null;
+  return JSON.parse(fs.readFileSync(fp, 'utf8'));
+}
+
+// ---------------------------------------------------------------------------
+// RPC helpers
+// ---------------------------------------------------------------------------
+
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+}
+
+function httpRequest(rpcUrl, pathStr) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(pathStr, rpcUrl);
+    const lib = url.protocol === 'https:' ? https : http;
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'GET',
+      timeout: 8000,
+      headers: { 'Content-Type': 'application/json' },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch { resolve({ raw: data }); }
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function httpPost(rpcUrl, pathStr, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(pathStr, rpcUrl);
+    const lib = url.protocol === 'https:' ? https : http;
+    const bodyStr = JSON.stringify(body);
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'POST',
+      timeout: 8000,
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(bodyStr),
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch { resolve(data); }
+      });
+    });
+    req.on('error', reject);
+    req.write(bodyStr);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Format lamports as AETH string (1 AETH = 1e9 lamports)
+ */
+function formatAether(lamports) {
+  if (lamports === undefined || lamports === null) return '0 AETH';
+  const aeth = lamports / 1e9;
+  if (aeth === 0) return '0 AETH';
+  return aeth.toFixed(4).replace(/\.?0+$/, '') + ' AETH';
+}
+
+/**
+ * Format a timestamp as relative time ("2h ago", "3d ago")
+ */
+function relativeTime(timestamp) {
+  if (!timestamp) return 'unknown';
+  const now = Math.floor(Date.now() / 1000);
+  const diff = now - timestamp;
+  if (diff < 60) return `${diff}s ago`;
+  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+  return `${Math.floor(diff / 86400)}d ago`;
+}
+
+/**
+ * Truncate a signature or hash for display
+ */
+function truncate(str, chars = 8) {
+  if (!str || typeof str !== 'string') return '—';
+  if (str.length <= chars * 2 + 3) return str;
+  return str.slice(0, chars) + '…' + str.slice(-chars);
+}
+
+// ---------------------------------------------------------------------------
+// Fetch wallet stats from RPC
+// ---------------------------------------------------------------------------
+
+async function fetchWalletStats(address, rpcUrl) {
+  const rawAddr = address.startsWith('ATH') ? address.slice(3) : address;
+
+  // Fetch account, transactions, and stake positions in parallel
+  const [account, txs, stakeAccounts] = await Promise.all([
+    httpRequest(rpcUrl, `/v1/account/${rawAddr}`).catch(() => null),
+    httpRequest(rpcUrl, `/v1/tx?address=${encodeURIComponent(rawAddr)}&limit=5`).catch(() => null),
+    httpRequest(rpcUrl, `/v1/stake?address=${encodeURIComponent(rawAddr)}`).catch(() => null),
+  ]);
+
+  return { account, txs, stakeAccounts };
+}
+
+// ---------------------------------------------------------------------------
+// Render dashboard
+// ---------------------------------------------------------------------------
+
+function renderDashboard(address, stats, opts) {
+  const { account, txs, stakeAccounts } = stats;
+  const { compact, asJson } = opts;
+  const rpcUrl = opts.rpcUrl;
+
+  if (asJson) {
+    const stakeList = stakeAccounts && !stakeAccounts.error
+      ? (Array.isArray(stakeAccounts) ? stakeAccounts : stakeAccounts.accounts || stakeAccounts.stake_accounts || [])
+      : [];
+    const txList = txs && !txs.error
+      ? (Array.isArray(txs) ? txs : txs.transactions || [])
+      : [];
+
+    const out = {
+      address,
+      rpc: rpcUrl,
+      balance: account && !account.error ? {
+        lamports: account.lamports || 0,
+        aeth: formatAether(account.lamports || 0),
+      } : null,
+      stake_positions: stakeList.map((sa) => ({
+        stake_account: sa.stake_account || sa.address || 'unknown',
+        validator: sa.validator || 'unknown',
+        amount: sa.amount || 0,
+        aeth: formatAether(sa.amount || 0),
+        status: sa.status || 'active',
+        created_epoch: sa.created_epoch || null,
+      })),
+      recent_txs: txList.map((tx) => ({
+        type: tx.tx_type || tx.type || 'Unknown',
+        signature: tx.signature || tx.id || tx.tx_signature || null,
+        timestamp: tx.timestamp || null,
+        relative_time: relativeTime(tx.timestamp),
+        payload: tx.payload?.data || {},
+        fee: tx.fee || 0,
+      })),
+      fetched_at: new Date().toISOString(),
+    };
+    console.log(JSON.stringify(out, null, 2));
+    return;
+  }
+
+  const lamports = (account && !account.error) ? (account.lamports || 0) : null;
+  const stakeList = stakeAccounts && !stakeAccounts.error
+    ? (Array.isArray(stakeAccounts) ? stakeAccounts : stakeAccounts.accounts || stakeAccounts.stake_accounts || [])
+    : [];
+  const txList = txs && !txs.error
+    ? (Array.isArray(txs) ? txs : txs.transactions || [])
+    : [];
+
+  if (compact) {
+    // One-line summary
+    const bal = lamports !== null ? formatAether(lamports) : 'unknown';
+    const stakes = stakeList.length;
+    const recent = txList.length > 0 ? (txList[0].tx_type || txList[0].type || '?') : 'none';
+    console.log(`${C.bright}${address}${C.reset}  bal:${C.green}${bal}${C.reset}  stakes:${stakes}  last:${recent}  txs:${txList.length}`);
+    return;
+  }
+
+  // Full dashboard
+  console.log(`\n${C.bright}${C.cyan}── Wallet Stats ─────────────────────────────────────────${C.reset}`);
+  console.log(`  ${C.green}★${C.reset} ${C.bright}${address}${C.reset}`);
+  console.log(`  ${C.dim}RPC: ${rpcUrl}${C.reset}`);
+  console.log();
+
+  // Balance section
+  console.log(`  ${C.bright}Balance${C.reset}`);
+  if (lamports !== null) {
+    console.log(`    ${C.green}${formatAether(lamports)}${C.reset}  ${C.dim}(${lamports} lamports)${C.reset}`);
+    if (account.owner) {
+      const ownerStr = Array.isArray(account.owner)
+        ? 'ATH' + bs58.encode(Buffer.from(account.owner.slice(0, 32)))
+        : account.owner;
+      console.log(`    ${C.dim}Owner: ${ownerStr}${C.reset}`);
+    }
+    if (account.rent_epoch !== undefined) {
+      console.log(`    ${C.dim}Rent epoch: ${account.rent_epoch}${C.reset}`);
+    }
+  } else {
+    console.log(`    ${C.yellow}⚠ Could not fetch balance (account may not exist)${C.reset}`);
+  }
+  console.log();
+
+  // Stake positions section
+  console.log(`  ${C.bright}Stake Positions (${stakeList.length})${C.reset}`);
+  if (stakeList.length === 0) {
+    console.log(`    ${C.dim}No active stake positions.${C.reset}`);
+  } else {
+    const statusColors = {
+      active: C.green,
+      inactive: C.yellow,
+      activating: C.yellow,
+      deactivating: C.red,
+      unknown: C.dim,
+    };
+    for (const sa of stakeList) {
+      const status = sa.status || 'unknown';
+      const color = statusColors[status] || C.dim;
+      const amount = sa.amount ? formatAether(sa.amount) : '0 AETH';
+      const validator = sa.validator || 'unknown';
+      console.log(`    ${C.dim}┌─${C.reset}`);
+      console.log(`    │  ${C.bright}Validator:${C.reset} ${validator}`);
+      console.log(`    │  ${C.bright}Amount:${C.reset}     ${color}${amount}${C.reset}`);
+      console.log(`    │  ${C.bright}Status:${C.reset}      ${color}${status}${C.reset}`);
+      if (sa.stake_account) {
+        console.log(`    │  ${C.bright}Stake acct:${C.reset} ${truncate(sa.stake_account)}`);
+      }
+      console.log(`    ${C.dim}└${C.reset}`);
+    }
+  }
+  console.log();
+
+  // Recent transactions section
+  console.log(`  ${C.bright}Recent Transactions (${txList.length})${C.reset}`);
+  if (txList.length === 0) {
+    console.log(`    ${C.dim}No transactions yet.${C.reset}`);
+  } else {
+    const typeColors = {
+      Transfer: C.cyan,
+      Stake: C.green,
+      Unstake: C.yellow,
+      ClaimRewards: C.magenta,
+      CreateNFT: C.red,
+      MintNFT: C.red,
+      TransferNFT: C.cyan,
+      UpdateMetadata: C.yellow,
+      Unknown: C.dim,
+    };
+    for (const tx of txList) {
+      const txType = tx.tx_type || tx.type || 'Unknown';
+      const color = typeColors[txType] || C.dim;
+      const sig = tx.signature || tx.id || tx.tx_signature || '—';
+      const ts = tx.timestamp ? relativeTime(tx.timestamp) : 'unknown';
+
+      console.log(`    ${C.dim}┌─ ${ts}${C.reset}  ${C.bright}${color}${txType}${C.reset}  sig:${truncate(sig)}`);
+      if (tx.payload && tx.payload.data) {
+        const d = tx.payload.data;
+        if (d.recipient) console.log(`    │  ${C.dim}→ to:      ${d.recipient}${C.reset}`);
+        if (d.amount)    console.log(`    │  ${C.dim}amount:   ${formatAether(d.amount)}${C.reset}`);
+        if (d.validator) console.log(`    │  ${C.dim}validator: ${d.validator}${C.reset}`);
+      }
+      if (tx.fee !== undefined && tx.fee > 0) {
+        console.log(`    │  ${C.dim}fee: ${tx.fee} lamports${C.reset}`);
+      }
+      console.log(`    ${C.dim}└${C.reset}`);
+    }
+  }
+  console.log();
+}
+
+// ---------------------------------------------------------------------------
+// Main command
+// ---------------------------------------------------------------------------
+
+function statsCommand() {
+  const args = process.argv.slice(3);
+
+  // Parse flags
+  let address = null;
+  let compact = false;
+  let asJson = false;
+
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '--address' || args[i] === '-a') && args[i + 1]) {
+      address = args[i + 1];
+      i++;
+    } else if (args[i] === '--compact' || args[i] === '-c') {
+      compact = true;
+    } else if (args[i] === '--json' || args[i] === '-j') {
+      asJson = true;
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      console.log(`
+${C.bright}Aether Wallet Stats${C.reset}
+${C.dim}Comprehensive wallet overview: balance, stakes, recent transactions.${C.reset}
+
+${C.bright}Usage:${C.reset}
+  aether stats --address <addr>         Full dashboard
+  aether stats --address <addr> --json  JSON output
+  aether stats --address <addr> --compact  One-line summary
+
+${C.bright}Options:${C.reset}
+  -a, --address <addr>   Wallet address (or set default)
+  -j, --json             JSON output
+  -c, --compact          One-line summary
+  -h, --help             Show this help
+`);
+      return;
+    }
+  }
+
+  // Resolve address
+  if (!address) {
+    const cfg = loadConfig();
+    address = cfg.defaultWallet;
+  }
+
+  if (!address) {
+    console.log(`  ${C.red}✗ No wallet address.${C.reset} Use ${C.cyan}--address <addr>${C.reset} or set a default.`);
+    console.log(`  ${C.dim}Usage: aether stats --address <address> [--compact] [--json]${C.reset}\n`);
+    process.exit(1);
+  }
+
+  // Verify wallet file exists
+  const wallet = loadWallet(address);
+  if (!wallet) {
+    console.log(`  ${C.red}✗ Wallet not found locally:${C.reset} ${address}`);
+    console.log(`  ${C.dim}Check your wallets: ${C.cyan}aether wallet list${C.reset}\n`);
+    process.exit(1);
+  }
+
+  const rpcUrl = getDefaultRpc();
+
+  if (!asJson) {
+    console.log(`  ${C.dim}Fetching stats from ${rpcUrl}...${C.reset}`);
+  }
+
+  // Fetch and render
+  (async () => {
+    try {
+      const stats = await fetchWalletStats(address, rpcUrl);
+      renderDashboard(address, stats, { compact, asJson, rpcUrl });
+    } catch (err) {
+      console.log(`  ${C.red}✗ Failed to fetch wallet stats:${C.reset} ${err.message}`);
+      console.log(`  ${C.dim}  Is your validator running? RPC: ${rpcUrl}${C.reset}`);
+      console.log(`  ${C.dim}  Set custom RPC: AETHER_RPC=https://your-rpc-url${C.reset}\n`);
+      process.exit(1);
+    }
+  })();
+}
+
+module.exports = { statsCommand };