@jellylegsai/aether-cli 1.8.0

package/commands/rewards.js

@@ -0,0 +1,931 @@
+#!/usr/bin/env node
+/**
+ * aether-cli rewards
+ *
+ * View staking rewards earned from delegated stake accounts.
+ * Shows accumulated rewards, estimated APY, and claimable amounts.
+ * 
+ * FULLY WIRED TO SDK - Uses @jellylegsai/aether-sdk for all blockchain calls.
+ * No manual HTTP - all calls go through AetherClient with real RPC.
+ *
+ * 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 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)
+ * 
+ * SDK Methods Used:
+ *   - client.getStakePositions(address)  → GET /v1/stake/<addr>
+ *   - client.getRewards(address)         → GET /v1/rewards/<addr>
+ *   - client.getEpochInfo()              → GET /v1/epoch
+ *   - client.getSlot()                   → GET /v1/slot
+ *   - client.sendTransaction(tx)         → POST /v1/transaction
+ */
+
+const path = require('path');
+const readline = require('readline');
+const crypto = require('crypto');
+const bs58 = require('bs58').default;
+const bip39 = require('bip39');
+const nacl = require('tweetnacl');
+
+// Import SDK for ALL blockchain RPC calls
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
+
+// 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',
+};
+
+const DERIVATION_PATH = "m/44'/7777777'/0'/0'";
+const CLI_VERSION = '1.1.0';
+
+// ---------------------------------------------------------------------------
+// SDK Client Setup
+// ---------------------------------------------------------------------------
+
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
+}
+
+function createClient(rpcUrl) {
+  return new aether.AetherClient({ rpcUrl });
+}
+
+// ---------------------------------------------------------------------------
+// Paths & config
+// ---------------------------------------------------------------------------
+
+function getAetherDir() {
+  return path.join(require('os').homedir(), '.aether');
+}
+
+function loadConfig() {
+  const p = path.join(getAetherDir(), 'config.json');
+  if (!require('fs').existsSync(p)) return { defaultWallet: null };
+  try {
+    return JSON.parse(require('fs').readFileSync(p, 'utf8'));
+  } catch {
+    return { defaultWallet: null };
+  }
+}
+
+function loadWallet(address) {
+  const fp = path.join(getAetherDir(), 'wallets', `${address}.json`);
+  if (!require('fs').existsSync(fp)) return null;
+  return JSON.parse(require('fs').readFileSync(fp, 'utf8'));
+}
+
+// ---------------------------------------------------------------------------
+// Crypto helpers
+// ---------------------------------------------------------------------------
+
+function deriveKeypair(mnemonic) {
+  if (!bip39.validateMnemonic(mnemonic)) throw new Error('Invalid mnemonic');
+  const seedBuffer = bip39.mnemonicToSeedSync(mnemonic, '');
+  const seed32 = seedBuffer.slice(0, 32);
+  const keyPair = nacl.sign.keyPair.fromSeed(seed32);
+  return { publicKey: Buffer.from(keyPair.publicKey), secretKey: Buffer.from(keyPair.secretKey) };
+}
+
+function formatAddress(publicKey) {
+  return 'ATH' + bs58.encode(publicKey);
+}
+
+function signTransaction(tx, secretKey) {
+  const txBytes = Buffer.from(JSON.stringify(tx));
+  const sig = nacl.sign.detached(txBytes, secretKey);
+  return bs58.encode(sig);
+}
+
+// ---------------------------------------------------------------------------
+// Format helpers
+// ---------------------------------------------------------------------------
+
+function formatAether(lamports) {
+  if (!lamports || lamports === '0') return '0 AETH';
+  const aeth = Number(lamports) / 1e9;
+  return aeth.toFixed(4).replace(/\.?0+$/, '') + ' AETH';
+}
+
+function formatAethFull(lamports) {
+  if (!lamports) return '0.000000 AETH';
+  return (Number(lamports) / 1e9).toFixed(6) + ' AETH';
+}
+
+function shortAddress(addr) {
+  if (!addr || addr.length < 20) return addr || 'unknown';
+  return addr.slice(0, 8) + '...' + addr.slice(-8);
+}
+
+// ---------------------------------------------------------------------------
+// Rewards calculation via SDK (REAL RPC CALLS)
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch stake positions and calculate rewards using SDK
+ * Makes real RPC calls: getStakePositions, getRewards, getEpochInfo
+ */
+async function fetchStakeRewards(rpcUrl, stakeAddress) {
+  const client = createClient(rpcUrl);
+  
+  try {
+    // Parallel SDK calls for stake data and epoch info
+    const [stakePositions, rewards, epochInfo] = await Promise.all([
+      client.getStakePositions(stakeAddress).catch(() => []),
+      client.getRewards(stakeAddress).catch(() => ({ total: 0, pending: 0 })),
+      client.getEpochInfo().catch(() => ({ epoch: 0, slotsInEpoch: 432000, slotIndex: 0 })),
+    ]);
+
+    // Find the specific stake account in positions
+    const stakeData = stakePositions.find(s => 
+      (s.pubkey || s.publicKey || s.account) === stakeAddress
+    ) || stakePositions[0] || {};
+
+    const delegatedStake = BigInt(stakeData.lamports || stakeData.stake_lamports || 0);
+    const activationEpoch = stakeData.activation_epoch || stakeData.activationEpoch || 0;
+    const deactivationEpoch = stakeData.deactivation_epoch || stakeData.deactivationEpoch || null;
+    const validator = stakeData.validator || stakeData.delegate || rewards.validator || 'unknown';
+    const stakeType = stakeData.stake_type || stakeData.type || 'delegated';
+
+    const currentEpoch = epochInfo.epoch || 0;
+    
+    // Calculate active epochs
+    const activeFromEpoch = activationEpoch;
+    const activeToEpoch = deactivationEpoch || currentEpoch;
+    const activeEpochs = Math.max(0, activeToEpoch - activeFromEpoch);
+
+    // Get rewards from SDK response
+    const totalRewards = BigInt(rewards.total || rewards.pending_rewards || rewards.amount || 0);
+    const pendingRewards = BigInt(rewards.pending || rewards.pending_rewards || 0);
+    
+    // Calculate APY from rewards data
+    const rewardsPerEpoch = BigInt(rewards.rewards_per_epoch || '2000000000');
+    const totalNetworkStake = BigInt(rewards.total_network_stake || '10000000000000');
+    const rewardsRate = totalNetworkStake > 0 
+      ? Number(rewardsPerEpoch * BigInt(365)) / Number(totalNetworkStake) 
+      : 0;
+    const apyBps = Math.round(rewardsRate * 10000);
+
+    return {
+      stakeAddress,
+      delegatedStake: delegatedStake.toString(),
+      delegatedStakeFormatted: formatAether(delegatedStake),
+      activationEpoch: activeFromEpoch,
+      deactivationEpoch,
+      isActive: deactivationEpoch === null,
+      activeEpochs,
+      totalRewards: totalRewards.toString(),
+      pendingRewards: pendingRewards.toString(),
+      totalRewardsFormatted: formatAether(totalRewards),
+      pendingRewardsFormatted: formatAether(pendingRewards),
+      apyBps,
+      validator,
+      stakeType,
+      currentEpoch,
+    };
+  } catch (err) {
+    return { stakeAddress, error: err.message };
+  }
+}
+
+/**
+ * Fetch all stake accounts for a wallet using SDK
+ * REAL RPC CALL: GET /v1/stake/<address>
+ */
+async function fetchWalletStakeAccounts(rpcUrl, walletAddress) {
+  const client = createClient(rpcUrl);
+  
+  try {
+    const rawAddr = walletAddress.startsWith('ATH') ? walletAddress.slice(3) : walletAddress;
+    const stakePositions = await client.getStakePositions(rawAddr);
+    
+    if (!Array.isArray(stakePositions)) return [];
+    
+    return stakePositions.map(s => ({
+      address: s.pubkey || s.publicKey || s.account,
+      validator: s.validator || s.delegate,
+      lamports: s.lamports || s.stake_lamports || 0,
+      activationEpoch: s.activation_epoch || s.activationEpoch,
+      deactivationEpoch: s.deactivation_epoch || s.deactivationEpoch,
+      status: s.status || s.state || 'active',
+    })).filter(s => s.address);
+  } catch (err) {
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Rewards list command - FULLY WIRED TO SDK
+// ---------------------------------------------------------------------------
+
+async function rewardsList(args) {
+  const rpc = args.rpc || getDefaultRpc();
+  const isJson = args.json || false;
+  let address = args.address || null;
+
+  // Interactive address prompt if not provided
+  if (!address) {
+    const config = loadConfig();
+    const rl = createRl();
+    const answer = await question(rl, `\n${C.cyan}Enter wallet address (or press Enter for default): ${C.reset}`);
+    rl.close();
+
+    if (!answer.trim()) {
+      if (!config.defaultWallet) {
+        console.log(`\n${C.red}✗ No default wallet and no address provided.${C.reset}`);
+        console.log(`  ${C.dim}Set a default wallet first: aether wallet default${C.reset}\n`);
+        return;
+      }
+      address = config.defaultWallet;
+    } else {
+      address = answer.trim();
+    }
+  }
+
+  // Validate address format
+  if (!address.startsWith('ATH') || address.length < 30) {
+    const config = loadConfig();
+    if (config.defaultWallet) address = config.defaultWallet;
+  }
+
+  console.log(`\n${C.bright}${C.cyan}╔═══════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bright}${C.cyan}║           Staking Rewards — ${shortAddress(address)}        ║${C.reset}`);
+  console.log(`${C.bright}${C.cyan}╚═══════════════════════════════════════════════════════╝${C.reset}\n`);
+  console.log(`  ${C.dim}RPC: ${rpc}${C.reset}\n`);
+
+  // Fetch stake accounts via SDK (REAL RPC)
+  const stakeAccounts = await fetchWalletStakeAccounts(rpc, address);
+
+  if (stakeAccounts.length === 0) {
+    console.log(`  ${C.yellow}⚠ No stake accounts found for this wallet.${C.reset}`);
+    console.log(`  ${C.dim}Stake AETH first: aether stake --address ${address} --validator <val> --amount <aeth>${C.reset}\n`);
+    return;
+  }
+
+  // Fetch rewards for each stake account via SDK (REAL RPC CALLS)
+  const rewardsResults = await Promise.all(
+    stakeAccounts.map(sa => fetchStakeRewards(rpc, sa.address))
+  );
+
+  let totalEstimatedRewards = BigInt(0);
+  let totalPendingRewards = BigInt(0);
+  let totalDelegatedStake = BigInt(0);
+  let activeCount = 0;
+  const rows = [];
+
+  for (const result of rewardsResults) {
+    if (result.error) {
+      rows.push({ status: 'error', ...result });
+      continue;
+    }
+
+    totalEstimatedRewards += BigInt(result.totalRewards || 0);
+    totalPendingRewards += BigInt(result.pendingRewards || 0);
+    totalDelegatedStake += BigInt(result.delegatedStake || 0);
+    if (result.isActive) activeCount++;
+
+    rows.push(result);
+  }
+
+  if (isJson) {
+    console.log(JSON.stringify({
+      address,
+      rpc,
+      totalRewards: totalEstimatedRewards.toString(),
+      totalRewardsFormatted: formatAether(totalEstimatedRewards),
+      totalPendingRewards: totalPendingRewards.toString(),
+      totalPendingRewardsFormatted: formatAether(totalPendingRewards),
+      totalDelegatedStake: totalDelegatedStake.toString(),
+      totalDelegatedStakeFormatted: formatAether(totalDelegatedStake),
+      activeStakeAccounts: activeCount,
+      totalStakeAccounts: rows.length,
+      stakeAccounts: rows.map(r => ({
+        stakeAccount: r.stakeAddress,
+        validator: r.validator,
+        delegatedStake: r.delegatedStake,
+        delegatedStakeFormatted: r.delegatedStakeFormatted,
+        totalRewards: r.totalRewards,
+        totalRewardsFormatted: r.totalRewardsFormatted,
+        pendingRewards: r.pendingRewards,
+        pendingRewardsFormatted: r.pendingRewardsFormatted,
+        apyBps: r.apyBps,
+        isActive: r.isActive,
+        activationEpoch: r.activationEpoch,
+        currentEpoch: r.currentEpoch,
+      })),
+      cli_version: CLI_VERSION,
+      fetched_at: new Date().toISOString(),
+    }, null, 2));
+    return;
+  }
+
+  // ASCII table header
+  console.log(`  ${C.dim}┌─────────────────────────────────────────────────────────────────────────┐${C.reset}`);
+  console.log(`  ${C.dim}│${C.reset}  ${C.bright}Stake Account${C.reset}          ${C.bright}Validator${C.reset}      ${C.bright}Delegated${C.reset}    ${C.bright}Total Rewards${C.reset}  ${C.bright}APY${C.reset}    ${C.dim}│${C.reset}`);
+  console.log(`  ${C.dim}├─────────────────────────────────────────────────────────────────────────┤${C.reset}`);
+
+  for (const r of rows) {
+    const shortAddr = shortAddress(r.stakeAddress);
+    const shortVal = shortAddress(r.validator);
+    const delegated = r.delegatedStakeFormatted || '—';
+    const totalRew = r.totalRewardsFormatted || '—';
+    const apy = r.apyBps ? `${(r.apyBps / 100).toFixed(2)}%` : '—';
+    const statusColor = r.isActive ? C.green : r.deactivationEpoch ? C.yellow : C.red;
+    const status = r.isActive ? '●' : r.deactivationEpoch ? '○' : '✗';
+
+    console.log(
+      `  ${C.dim}│${C.reset}  ${shortAddr.padEnd(18)} ${shortVal.padEnd(14)} ${delegated.padEnd(11)} ${totalRew.padEnd(13)} ${apy.padEnd(6)} ${statusColor}${status}${C.reset} ${C.dim}│${C.reset}`
+    );
+  }
+
+  console.log(`  ${C.dim}└─────────────────────────────────────────────────────────────────────────┘${C.reset}`);
+  console.log();
+  console.log(`  ${C.bright}Total Delegated:${C.reset}  ${C.cyan}${formatAether(totalDelegatedStake)}${C.reset}`);
+  console.log(`  ${C.bright}Total Rewards:${C.reset}    ${C.green}${formatAether(totalEstimatedRewards)}${C.reset}`);
+  console.log(`  ${C.bright}Pending Rewards:${C.reset}  ${C.magenta}${formatAether(totalPendingRewards)}${C.reset}`);
+  console.log(`  ${C.bright}Active Accounts:${C.reset}   ${activeCount} of ${rows.length}`);
+  console.log();
+  console.log(`  ${C.dim}SDK Methods: getStakePositions(), getRewards(), getEpochInfo()${C.reset}`);
+  console.log(`  ${C.dim}Run "aether rewards claim --address ${address}" to claim pending rewards.${C.reset}\n`);
+}
+
+// ---------------------------------------------------------------------------
+// Rewards summary command - SDK WIRED
+// ---------------------------------------------------------------------------
+
+async function rewardsSummary(args) {
+  const rpc = args.rpc || getDefaultRpc();
+  let address = args.address || null;
+
+  if (!address) {
+    const config = loadConfig();
+    if (!config.defaultWallet) {
+      console.log(`${C.red}✗ No default wallet and no address provided.${C.reset}`);
+      return;
+    }
+    address = config.defaultWallet;
+  }
+
+  // SDK calls
+  const stakeAccounts = await fetchWalletStakeAccounts(rpc, address);
+  if (stakeAccounts.length === 0) {
+    console.log(`${C.yellow}⚠ No stake accounts for ${shortAddress(address)}${C.reset}`);
+    return;
+  }
+
+  const results = await Promise.all(stakeAccounts.map(sa => fetchStakeRewards(rpc, sa.address)));
+  let totalRewards = BigInt(0);
+  let totalPending = BigInt(0);
+  let totalStake = BigInt(0);
+  let activeCount = 0;
+
+  for (const r of results) {
+    if (!r.error) {
+      totalRewards += BigInt(r.totalRewards || 0);
+      totalPending += BigInt(r.pendingRewards || 0);
+      totalStake += BigInt(r.delegatedStake || 0);
+      if (r.isActive) activeCount++;
+    }
+  }
+
+  console.log(`${C.cyan}${shortAddress(address)}${C.reset} │ Stake: ${C.cyan}${formatAether(totalStake)}${C.reset} │ Total Rewards: ${C.green}${formatAether(totalRewards)}${C.reset} │ Pending: ${C.magenta}${formatAether(totalPending)}${C.reset} │ Active: ${activeCount}/${results.length}`);
+}
+
+// ---------------------------------------------------------------------------
+// Rewards pending command - SDK WIRED
+// ---------------------------------------------------------------------------
+
+async function rewardsPending(args) {
+  const rpc = args.rpc || getDefaultRpc();
+  const isJson = args.json || false;
+  let address = args.address || 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;
+  }
+
+  rl.close();
+
+  // SDK calls
+  const stakeAccounts = await fetchWalletStakeAccounts(rpc, address);
+  if (stakeAccounts.length === 0) {
+    if (isJson) {
+      console.log(JSON.stringify({ address, pending: [], total_pending: '0', sdk_version: CLI_VERSION }, null, 2));
+    } else {
+      console.log(`\n${C.red}✗ No stake accounts found for ${address}${C.reset}\n`);
+    }
+    return;
+  }
+
+  const results = [];
+  let totalPending = BigInt(0);
+
+  // SDK calls for each stake account
+  for (const sa of stakeAccounts) {
+    const rd = await fetchStakeRewards(rpc, sa.address);
+    if (!rd.error) {
+      const pending = BigInt(rd.pendingRewards || 0);
+      totalPending += pending;
+      results.push({
+        stake_account: sa.address,
+        validator: sa.validator || rd.validator || 'unknown',
+        delegated_stake: rd.delegatedStakeFormatted || '0',
+        pending_rewards: rd.pendingRewardsFormatted || '0',
+        pending_lamports: pending.toString(),
+        apy_bps: rd.apyBps || 0,
+        is_active: rd.isActive,
+      });
+    }
+  }
+
+  if (isJson) {
+    console.log(JSON.stringify({
+      address,
+      rpc,
+      total_pending: totalPending.toString(),
+      total_pending_formatted: formatAether(totalPending.toString()),
+      accounts: results,
+      cli_version: CLI_VERSION,
+      fetched_at: new Date().toISOString(),
+    }, null, 2));
+    return;
+  }
+
+  console.log(`\n${C.bright}${C.cyan}╔══════════════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bright}${C.cyan}║              Pending Staking Rewards (SDK-Wired)             ║${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();
+  console.log(`  ${C.yellow}Stake Account${C.reset.padEnd(48)} ${C.yellow}Pending${C.reset}      ${C.yellow}APY${C.reset}`);
+  console.log(`  ${C.dim}${'─'.repeat(72)}${C.reset}`);
+
+  for (const r of results) {
+    const shortSa = shortAddress(r.stake_account);
+    console.log(`  ${C.cyan}${shortSa}${C.reset.padEnd(52)} ${C.green}${r.pending_rewards.padStart(12)}${C.reset}  ${(r.apy_bps / 100).toFixed(2)}%`);
+  }
+
+  console.log(`  ${C.dim}${'─'.repeat(72)}${C.reset}`);
+  console.log(`  ${C.bright}TOTAL PENDING${C.reset.padEnd(52)} ${C.magenta}${formatAethFull(totalPending.toString()).padStart(12)}${C.reset}`);
+  console.log();
+  console.log(`  ${C.dim}SDK: getStakePositions(), getRewards()${C.reset}`);
+  console.log(`  ${C.dim}Run ${C.cyan}aether rewards claim --address ${address}${C.dim} to claim.${C.reset}\n`);
+}
+
+// ---------------------------------------------------------------------------
+// Rewards claim command - SDK WIRED with sendTransaction
+// ---------------------------------------------------------------------------
+
+async function rewardsClaim(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 (!stakeAccount) {
+    // SDK call to fetch stake accounts
+    const stakeAccounts = await fetchWalletStakeAccounts(rpc, address);
+    if (stakeAccounts.length === 0) {
+      console.log(`\n${C.red}✗ No stake accounts found for this wallet.${C.reset}\n`);
+      rl.close();
+      return;
+    }
+    if (stakeAccounts.length === 1) {
+      stakeAccount = stakeAccounts[0].address;
+    } else {
+      console.log(`\n${C.cyan}Select stake account:${C.reset}`);
+      stakeAccounts.forEach((sa, i) => {
+        console.log(`  ${i + 1}) ${shortAddress(sa.address)} → ${shortAddress(sa.validator || 'unknown')}`);
+      });
+      const ans = await question(rl, `${C.cyan}Enter number: ${C.reset}`);
+      const idx = parseInt(ans.trim()) - 1;
+      if (idx < 0 || idx >= stakeAccounts.length) {
+        console.log(`\n${C.red}Invalid selection.${C.reset}\n`);
+        rl.close();
+        return;
+      }
+      stakeAccount = stakeAccounts[idx].address;
+    }
+  }
+
+  // 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;
+  }
+
+  console.log(`\n${C.bright}${C.cyan}╔════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bright}${C.cyan}║        Claim Staking Rewards             ║${C.reset}`);
+  console.log(`${C.bright}${C.cyan}╚════════════════════════════════════════╝${C.reset}\n`);
+  console.log(`  ${C.dim}Wallet:${C.reset} ${address}`);
+  console.log(`  ${C.dim}Stake Account:${C.reset} ${stakeAccount}`);
+
+  // SDK call to fetch current rewards
+  const client = createClient(rpc);
+  const rewardData = await fetchStakeRewards(rpc, stakeAccount);
+  if (rewardData.error) {
+    console.log(`\n${C.red}✗ Failed to fetch stake account: ${rewardData.error}${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  console.log(`  ${C.dim}Delegated Stake:${C.reset} ${rewardData.delegatedStakeFormatted}`);
+  console.log(`  ${C.dim}Est. Pending Rewards:${C.reset} ${C.green}${rewardData.pendingRewardsFormatted}${C.reset}`);
+  console.log(`  ${C.dim}Validator:${C.reset} ${rewardData.validator}`);
+  console.log(`  ${C.dim}APY:${C.reset} ${(rewardData.apyBps / 100).toFixed(2)}%`);
+
+  const pendingRewards = BigInt(rewardData.pendingRewards || 0);
+  if (pendingRewards === BigInt(0)) {
+    console.log(`\n${C.yellow}⚠ No rewards accumulated yet.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  const confirm = await question(rl, `\n  ${C.yellow}Claim ${rewardData.pendingRewardsFormatted}? [y/N]${C.reset} > `);
+  if (confirm.trim().toLowerCase() !== 'y') {
+    console.log(`${C.dim}Cancelled.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // Ask for mnemonic to derive signing keypair
+  let keypair;
+  try {
+    const mnemonic = await askMnemonic(rl, 'Enter your 12/24-word passphrase to sign the claim');
+    keypair = deriveKeypair(mnemonic);
+    
+    // Verify derived address matches
+    const derivedAddress = formatAddress(keypair.publicKey);
+    if (derivedAddress !== address) {
+      console.log(`\n${C.red}✗ Passphrase mismatch!${C.reset}`);
+      console.log(`  ${C.dim}Derived: ${derivedAddress}${C.reset}`);
+      console.log(`  ${C.dim}Expected: ${address}${C.reset}\n`);
+      rl.close();
+      return;
+    }
+  } catch (err) {
+    console.log(`\n${C.red}✗ Failed to derive keypair: ${err.message}${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // Build claim transaction for SDK
+  const tx = {
+    signer: address.startsWith('ATH') ? address.slice(3) : address,
+    tx_type: 'ClaimRewards',
+    payload: {
+      type: 'ClaimRewards',
+      data: {
+        stake_account: stakeAccount,
+        lamports: pendingRewards.toString(),
+      },
+    },
+    fee: 5000,
+    slot: await client.getSlot().catch(() => 0),
+    timestamp: Math.floor(Date.now() / 1000),
+  };
+
+  // Sign transaction
+  tx.signature = signTransaction(tx, keypair.secretKey);
+
+  console.log(`\n  ${C.dim}Submitting via SDK to ${rpc}...${C.reset}`);
+
+  // SDK call: sendTransaction (REAL RPC POST /v1/transaction)
+  try {
+    const result = await client.sendTransaction(tx);
+
+    if (result.error) {
+      throw new Error(result.error.message || JSON.stringify(result.error));
+    }
+
+    if (isJson) {
+      console.log(JSON.stringify({
+        success: true,
+        address,
+        stake_account: stakeAccount,
+        claimed_lamports: pendingRewards.toString(),
+        claimed_formatted: rewardData.pendingRewardsFormatted,
+        tx_signature: result.signature || result.txid,
+        slot: result.slot,
+        rpc,
+        cli_version: CLI_VERSION,
+        timestamp: new Date().toISOString(),
+      }, null, 2));
+    } else {
+      console.log(`\n${C.green}✓ Rewards claimed successfully!${C.reset}`);
+      console.log(`  ${C.dim}TX Signature: ${C.cyan}${result.signature || result.txid}${C.reset}`);
+      console.log(`  ${C.dim}Amount Claimed: ${C.green}${rewardData.pendingRewardsFormatted}${C.reset}`);
+      console.log(`  ${C.dim}Slot: ${result.slot}${C.reset}`);
+      console.log(`  ${C.dim}SDK Method: sendTransaction()${C.reset}`);
+      console.log(`  ${C.dim}Check balance: aether wallet balance --address ${address}${C.reset}\n`);
+    }
+  } catch (err) {
+    if (isJson) {
+      console.log(JSON.stringify({ success: false, error: err.message, address, stake_account: stakeAccount }, null, 2));
+    } else {
+      console.log(`\n${C.red}✗ Failed to submit claim transaction: ${err.message}${C.reset}`);
+      console.log(`  ${C.dim}The rewards are accumulated on-chain and can be claimed later.${C.reset}\n`);
+    }
+  }
+  
+  rl.close();
+}
+
+// ---------------------------------------------------------------------------
+// Rewards compound command - SDK WIRED
+// ---------------------------------------------------------------------------
+
+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;
+  }
+
+  // SDK call to fetch stake accounts
+  let stakeAccounts = await fetchWalletStakeAccounts(rpc, 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.address === 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 (SDK-Wired)            ║${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}`);
+  let keypair;
+  try {
+    const mnemonic = await askMnemonic(rl, 'Enter your 12/24-word passphrase:');
+    keypair = deriveKeypair(mnemonic);
+    
+    // Verify address matches
+    const derivedAddress = formatAddress(keypair.publicKey);
+    if (derivedAddress !== address) {
+      console.log(`\n${C.red}✗ Passphrase mismatch.${C.reset}`);
+      console.log(`  ${C.dim}Derived: ${derivedAddress}${C.reset}`);
+      console.log(`  ${C.dim}Expected: ${address}${C.reset}\n`);
+      rl.close();
+      return;
+    }
+  } catch (err) {
+    console.log(`\n${C.red}✗ Failed to derive keypair: ${err.message}${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  const client = createClient(rpc);
+  const compoundResults = [];
+  let totalCompounded = BigInt(0);
+  let successCount = 0;
+
+  for (const sa of stakeAccounts) {
+    console.log(`  ${C.dim}Processing:${C.reset} ${shortAddress(sa.address)}`);
+
+    try {
+      // SDK call to fetch rewards
+      const rewardData = await fetchStakeRewards(rpc, sa.address);
+      if (rewardData.error) {
+        console.log(`    ${C.red}✗ Failed to fetch: ${rewardData.error}${C.reset}`);
+        compoundResults.push({ stake_account: sa.address, status: 'error', error: rewardData.error });
+        continue;
+      }
+
+      const estimatedRewards = BigInt(rewardData.pendingRewards || 0);
+      if (estimatedRewards === BigInt(0)) {
+        console.log(`    ${C.yellow}⚠ No rewards to compound${C.reset}`);
+        compoundResults.push({ stake_account: sa.address, status: 'no_rewards', rewards: '0' });
+        continue;
+      }
+
+      console.log(`    ${C.dim}Rewards:${C.reset} ${rewardData.pendingRewardsFormatted} → ${shortAddress(sa.validator || rewardData.validator || 'unknown')}`);
+
+      // Build compound transaction (ClaimRewards + Stake in one)
+      const tx = {
+        signer: address.startsWith('ATH') ? address.slice(3) : address,
+        tx_type: 'CompoundRewards',
+        payload: {
+          type: 'CompoundRewards',
+          data: {
+            stake_account: sa.address,
+            lamports: estimatedRewards.toString(),
+            validator: sa.validator || rewardData.validator,
+          },
+        },
+        fee: 5000,
+        slot: await client.getSlot().catch(() => 0),
+        timestamp: Math.floor(Date.now() / 1000),
+      };
+
+      // Sign transaction
+      tx.signature = signTransaction(tx, keypair.secretKey);
+
+      // SDK call: sendTransaction
+      const result = await client.sendTransaction(tx);
+
+      if (result.signature || result.txid || result.success) {
+        console.log(`    ${C.green}✓ Compounded${C.reset}`);
+        totalCompounded += estimatedRewards;
+        successCount++;
+        compoundResults.push({
+          stake_account: sa.address,
+          status: 'compounded',
+          rewards: estimatedRewards.toString(),
+          rewards_formatted: rewardData.pendingRewardsFormatted,
+          tx: result.signature || result.txid,
+        });
+      } else {
+        console.log(`    ${C.red}✗ Failed: ${result.error || 'Unknown error'}${C.reset}`);
+        compoundResults.push({ stake_account: sa.address, status: 'failed', error: result.error });
+      }
+    } catch (err) {
+      console.log(`    ${C.red}✗ Error: ${err.message}${C.reset}`);
+      compoundResults.push({ stake_account: sa.address, 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}`);
+  console.log(`  ${C.dim}SDK: getStakePositions(), getRewards(), sendTransaction()${C.reset}\n`);
+
+  if (isJson) {
+    console.log(JSON.stringify({
+      address,
+      rpc,
+      total_compounded_lamports: totalCompounded.toString(),
+      total_compounded_formatted: formatAether(totalCompounded.toString()),
+      accounts_processed: stakeAccounts.length,
+      successful: successCount,
+      results: compoundResults,
+      cli_version: CLI_VERSION,
+      timestamp: new Date().toISOString(),
+    }, null, 2));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Parse CLI args
+// ---------------------------------------------------------------------------
+
+function parseArgs() {
+  const rawArgs = process.argv.slice(3);
+  const subcmd = rawArgs[0] || 'list';
+  const allArgs = rawArgs.slice(1);
+  
+  const rpcIndex = allArgs.findIndex(a => a === '--rpc');
+  const rpc = rpcIndex !== -1 ? allArgs[rpcIndex + 1] : getDefaultRpc();
+
+  const parsed = {
+    subcmd,
+    rpc,
+    json: allArgs.includes('--json') || allArgs.includes('-j'),
+    address: null,
+    account: null,
+  };
+
+  const addrIdx = allArgs.findIndex(a => a === '--address' || a === '-a');
+  if (addrIdx !== -1 && allArgs[addrIdx + 1]) parsed.address = allArgs[addrIdx + 1];
+
+  const acctIdx = allArgs.findIndex(a => a === '--account' || a === '-s');
+  if (acctIdx !== -1 && allArgs[acctIdx + 1]) parsed.account = allArgs[acctIdx + 1];
+
+  return parsed;
+}
+
+function createRl() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function question(rl, q) {
+  return new Promise((res) => rl.question(q, res));
+}
+
+async function askMnemonic(rl, prompt) {
+  console.log(`\n${C.cyan}${prompt}${C.reset}`);
+  console.log(`${C.dim}Enter your 12 or 24-word passphrase, one space-separated line:${C.reset}`);
+  const raw = await question(rl, `  > ${C.reset}`);
+  return raw.trim().toLowerCase();
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const args = parseArgs();
+
+  switch (args.subcmd) {
+    case 'list':
+      await rewardsList(args);
+      break;
+    case 'summary':
+      await rewardsSummary(args);
+      break;
+    case 'pending':
+      await rewardsPending(args);
+      break;
+    case 'claim':
+      await rewardsClaim(args);
+      break;
+    case 'compound':
+      await rewardsCompound(args);
+      break;
+    default:
+      console.log(`\n${C.cyan}Usage:${C.reset}`);
+      console.log(`  aether rewards list    --address <addr>  List all staking rewards (SDK-wired)`);
+      console.log(`  aether rewards summary --address <addr>  One-line rewards summary`);
+      console.log(`  aether rewards pending --address <addr>  Show pending 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`);
+      console.log();
+      console.log(`  ${C.dim}--json   Output as JSON`);
+      console.log(`  --rpc <url>  Use specific RPC endpoint${C.reset}`);
+      console.log();
+      console.log(`  ${C.green}✓ Fully wired to @jellylegsai/aether-sdk${C.reset}`);
+      console.log(`  ${C.dim}SDK: getStakePositions(), getRewards(), getEpochInfo(), sendTransaction()${C.reset}\n`);
+  }
+}
+
+main().catch(err => {
+  console.error(`\n${C.red}Error running rewards command:${C.reset}`, err.message, '\n');
+});
+
+module.exports = { rewardsCommand: main };