aether-hub 1.1.0 → 1.1.2

package/commands/validators.js

@@ -0,0 +1,326 @@
+/**
+ * aether-cli validators - Aether Validator Registry
+ *
+ * List and explore validators available for staking.
+ *   aether validators list         — Show all active validators
+ *   aether validators list --json  — JSON output for scripting
+ *   aether validators list --tier <full|lite|observer> — Filter by tier
+ *
+ * @see docs/MINING_VALIDATOR_TOOLS.md for spec
+ */
+
+const http = require('http');
+const https = require('https');
+
+// ANSI colours
+const C = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+};
+
+const DEFAULT_RPC = process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+
+// ---------------------------------------------------------------------------
+// HTTP helpers (mirrors network.js patterns)
+// ---------------------------------------------------------------------------
+
+function httpRequest(rpcUrl, path) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, rpcUrl);
+    const isHttps = url.protocol === 'https:';
+    const lib = isHttps ? https : http;
+
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 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.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+function parseArgs() {
+  const args = process.argv.slice(3); // skip 'validators' and subcommand
+  const opts = {
+    rpc: DEFAULT_RPC,
+    tier: null,
+    asJson: false,
+    sort: 'stake', // 'stake' | 'name' | 'uptime'
+    limit: 50,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--rpc' || args[i] === '-r') {
+      opts.rpc = args[++i];
+    } else if (args[i] === '--tier' || args[i] === '-t') {
+      opts.tier = args[++i]?.toLowerCase();
+    } else if (args[i] === '--json' || args[i] === '-j') {
+      opts.asJson = true;
+    } else if (args[i] === '--sort' || args[i] === '-s') {
+      opts.sort = args[++i]?.toLowerCase();
+    } else if (args[i] === '--limit' || args[i] === '-l') {
+      opts.limit = parseInt(args[++i], 10) || 50;
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      showHelp();
+      process.exit(0);
+    }
+  }
+
+  return opts;
+}
+
+function showHelp() {
+  console.log(`
+${C.bright}${C.cyan}aether-cli validators${C.reset} - Aether Validator Registry
+
+${C.bright}Usage:${C.reset}
+  aether validators list [options]
+
+${C.bright}Options:${C.reset}
+  -r, --rpc <url>      RPC endpoint (default: ${DEFAULT_RPC} or $AETHER_RPC)
+  -t, --tier <tier>    Filter by tier: full, lite, observer
+  -s, --sort <field>   Sort by: stake (default), name, uptime
+  -l, --limit <n>      Max validators to show (default: 50)
+  -j, --json           Output raw JSON
+  -h, --help           Show this help
+
+${C.bright}Examples:${C.reset}
+  aether validators list
+  aether validators list --tier full
+  aether validators list --sort stake --limit 20
+  aether validators list --json
+`.trim());
+}
+
+// ---------------------------------------------------------------------------
+// Data fetching
+// ---------------------------------------------------------------------------
+
+/** Fetch validators list from RPC */
+async function fetchValidators(rpc) {
+  try {
+    const res = await httpRequest(rpc, '/v1/validators');
+    if (Array.isArray(res)) return res;
+    if (res.validators && Array.isArray(res.validators)) return res.validators;
+    return [];
+  } catch (err) {
+    return [];
+  }
+}
+
+/** Fetch epoch info for context */
+async function fetchEpoch(rpc) {
+  try {
+    const res = await httpRequest(rpc, '/v1/epoch');
+    return res;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+function formatAether(lamports) {
+  if (!lamports && lamports !== 0) return '?';
+  const aeth = lamports / 1e9;
+  if (aeth === 0) return '0';
+  return aeth.toFixed(2).replace(/\.?0+$/, '');
+}
+
+function formatPct(n) {
+  if (n === undefined || n === null) return '?';
+  return n.toFixed(1) + '%';
+}
+
+function tierBadge(tier) {
+  const map = {
+    full: `${C.cyan}FULL${C.reset}`,
+    lite: `${C.yellow}LITE${C.reset}`,
+    observer: `${C.green}OBS${C.reset}`,
+  };
+  return map[tier?.toLowerCase()] || `${C.dim}?${C.reset}`;
+}
+
+function scoreColor(score) {
+  if (score === undefined || score === null) return C.dim;
+  if (score >= 90) return C.green;
+  if (score >= 70) return C.yellow;
+  return C.red;
+}
+
+function shortenAddr(addr, len = 16) {
+  if (!addr) return '?';
+  if (addr.length <= len) return addr;
+  return addr.slice(0, 8) + '…' + addr.slice(-6);
+}
+
+// ---------------------------------------------------------------------------
+// Renderers
+// ---------------------------------------------------------------------------
+
+function renderList(validators, epochData, opts, rpc) {
+  const filtered = opts.tier
+    ? validators.filter(v => (v.tier || v.node_type || '').toLowerCase() === opts.tier)
+    : validators;
+
+  // Sort
+  if (opts.sort === 'name') {
+    filtered.sort((a, b) => (a.name || a.address || '').localeCompare(b.name || b.address || ''));
+  } else if (opts.sort === 'uptime') {
+    filtered.sort((a, b) => (b.uptime || b.score || 0) - (a.uptime || a.score || 0));
+  } else {
+    // Default: by stake (descending)
+    filtered.sort((a, b) => (b.stake || b.stake_amount || 0) - (a.stake || a.stake_amount || 0));
+  }
+
+  const shown = filtered.slice(0, opts.limit);
+  const totalStake = validators.reduce((sum, v) => sum + (v.stake || v.stake_amount || 0), 0);
+  const networkScore = validators.reduce((sum, v) => sum + (v.score || v.uptime || 0) * (v.stake || 1), 0) / (totalStake || 1);
+
+  console.log();
+  console.log(`${C.bright}${C.cyan}╔═══════════════════════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bright}${C.cyan}║${C.reset}              ${C.bright}AETHER VALIDATOR REGISTRY${C.reset}${C.cyan}                           ║${C.reset}`);
+  console.log(`${C.bright}${C.cyan}╚═══════════════════════════════════════════════════════════════════════╝${C.reset}`);
+  console.log(`  ${C.dim}RPC:${C.reset} ${rpc}`);
+  console.log(`  ${C.dim}Total validators:${C.reset} ${C.bright}${validators.length}${C.reset}`);
+  if (opts.tier) console.log(`  ${C.dim}Filtered by tier:${C.reset} ${C.bright}${opts.tier}${C.reset}`);
+  console.log();
+
+  // Summary stats
+  console.log(`  ${C.bright}┌──────────────────────────────────────────────────────────────────────────┐${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset}  ${C.cyan}Total Stake${C.reset}         ${C.bright}│${C.reset}  ${C.green}${formatAether(totalStake).padEnd(20)} AETH${C.reset}`.padEnd(80) + `${C.bright}│${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset}  ${C.cyan}Network Uptime${C.reset}     ${C.bright}│${C.reset}  ${scoreColor(networkScore)}${formatPct(networkScore).padEnd(20)}${C.reset}`.padEnd(80) + `${C.bright}│${C.reset}`);
+  if (epochData && epochData.epoch !== undefined) {
+    console.log(`  ${C.bright}│${C.reset}  ${C.cyan}Current Epoch${C.reset}      ${C.bright}│${C.reset}  ${C.green}${epochData.epoch}${C.reset}`.padEnd(80) + `${C.bright}│${C.reset}`);
+  }
+  console.log(`  ${C.bright}└──────────────────────────────────────────────────────────────────────────┘${C.reset}`);
+  console.log();
+
+  if (shown.length === 0) {
+    console.log(`  ${C.yellow}⚠ No validators found${C.reset}${opts.tier ? ` for tier "${opts.tier}"` : ''}.`);
+    console.log(`  ${C.dim}Try without --tier filter or check RPC connectivity.${C.reset}`);
+    console.log();
+    return;
+  }
+
+  // Table header
+  console.log(`  ${C.bright}┌────┬────────────────────────┬────────┬─────────┬────────┬─────────────┐${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset} ${C.cyan}#${C.reset}  ${C.cyan}Validator${C.reset}                    ${C.cyan}Tier${C.reset}     ${C.cyan}Stake${C.reset}    ${C.cyan}Uptime${C.reset} ${C.cyan}Commission${C.reset} ${C.bright}│${C.reset}`);
+  console.log(`  ${C.bright}├────┼────────────────────────┼────────┼─────────┼────────┼─────────────┤${C.reset}`);
+
+  for (let i = 0; i < shown.length; i++) {
+    const v = shown[i];
+    const num = (i + 1).toString().padStart(3);
+    const addr = shortenAddr(v.address || v.pubkey || v.id);
+    const tierStr = tierBadge(v.tier || v.node_type);
+    const stake = formatAether(v.stake || v.stake_amount || 0);
+    const uptime = formatPct(v.uptime || v.score);
+    const commission = formatPct(v.commission || v.fee);
+    const row = `  ${C.bright}│${C.reset} ${C.dim}${num}${C.reset}  ${addr.padEnd(24)} ${tierStr.padEnd(8)} ${stake.padEnd(9)} ${scoreColor(v.uptime || v.score)}${uptime.padEnd(9)}${C.reset} ${C.dim}${commission}${C.reset} ${C.bright}│${C.reset}`;
+    console.log(row);
+  }
+
+  console.log(`  ${C.bright}└────┴────────────────────────┴────────┴─────────┴────────┴─────────────┘${C.reset}`);
+  console.log();
+
+  if (filtered.length > opts.limit) {
+    console.log(`  ${C.dim}Showing ${opts.limit} of ${filtered.length} validators. Use --limit to see more.${C.reset}`);
+  }
+
+  console.log();
+  console.log(`  ${C.dim}Stake to a validator:${C.reset}`);
+  console.log(`    ${C.cyan}aether stake --validator <address> --amount <aeth>${C.reset}`);
+  console.log(`    ${C.cyan}aether stake --validator <address> --amount <aeth> --dry-run${C.reset}  ${C.dim}(preview)${C.reset}`);
+  console.log();
+}
+
+function renderJson(validators, epochData, opts, rpc) {
+  const out = {
+    rpc,
+    fetchedAt: new Date().toISOString(),
+    total: validators.length,
+    epoch: epochData?.epoch ?? null,
+    validators: validators.map(v => ({
+      address: v.address || v.pubkey || v.id,
+      name: v.name || null,
+      tier: v.tier || v.node_type || null,
+      stake: v.stake || v.stake_amount || 0,
+      stakeAETH: formatAether(v.stake || v.stake_amount || 0),
+      uptime: v.uptime ?? v.score ?? null,
+      uptimePct: formatPct(v.uptime ?? v.score),
+      commission: v.commission ?? v.fee ?? null,
+      commissionPct: formatPct(v.commission ?? v.fee),
+      lastSeen: v.last_seen || v.lastActive || null,
+      version: v.version || v.clientVersion || null,
+    })),
+  };
+  console.log(JSON.stringify(out, null, 2));
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function validatorsListCommand() {
+  const opts = parseArgs();
+  const rpc = opts.rpc;
+
+  if (!opts.asJson) {
+    console.log(`\n${C.cyan}Fetching validators...${C.reset} ${C.dim}(${rpc})${C.reset}`);
+  }
+
+  const [validators, epochData] = await Promise.all([
+    fetchValidators(rpc),
+    fetchEpoch(rpc),
+  ]);
+
+  if (validators.length === 0 && !opts.asJson) {
+    console.log(`\n  ${C.yellow}⚠ No validator data returned from RPC.${C.reset}`);
+    console.log(`  ${C.dim}  Is your validator running and fully synced?${C.reset}`);
+    console.log(`  ${C.dim}  Check: aether-cli network${C.reset}`);
+    console.log(`  ${C.dim}  Set custom RPC: AETHER_RPC=http://your-rpc-url${C.reset}\n`);
+    return;
+  }
+
+  if (opts.asJson) {
+    renderJson(validators, epochData, opts, rpc);
+  } else {
+    renderList(validators, epochData, opts, rpc);
+  }
+}
+
+module.exports = { validatorsListCommand };
+
+if (require.main === module) {
+  validatorsListCommand().catch((err) => {
+    console.error(`\n${C.red}✗ Validators command failed:${C.reset} ${err.message}`);
+    console.error(`  ${C.dim}Check that your validator is running and RPC is accessible.${C.reset}\n`);
+    process.exit(1);
+  });
+}

package/commands/wallet.js

@@ -1106,6 +1106,171 @@ async function txHistory(rl) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// UNSTAKE
+// Submit an Unstake transaction via POST /v1/tx to deactivate stake
+// ---------------------------------------------------------------------------
+
+async function unstakeWallet(rl) {
+  console.log(`\n${C.bright}${C.cyan}── Unstake AETH ──────────────────────────────────────────${C.reset}\n`);
+
+  const args = process.argv.slice(4);
+  let address = null;
+  let stakeAccount = null;
+  let amountStr = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '--address' || args[i] === '-a') && args[i + 1]) {
+      address = args[i + 1];
+    }
+    if ((args[i] === '--account' || args[i] === '-s') && args[i + 1]) {
+      stakeAccount = args[i + 1];
+    }
+    if ((args[i] === '--amount' || args[i] === '-m') && args[i + 1]) {
+      amountStr = args[i + 1];
+    }
+  }
+
+  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 unstake --account <stakeAcct> [--amount <aeth>] [--address <addr>]${C.reset}\n`);
+    return;
+  }
+
+  const wallet = loadWallet(address);
+  if (!wallet) {
+    console.log(`  ${C.red}✗ Wallet not found:${C.reset} ${address}\n`);
+    return;
+  }
+
+  // Resolve stake account: --account flag, or query chain for first active stake
+  if (!stakeAccount) {
+    const rpcUrl = getDefaultRpc();
+    const rawAddr = address.startsWith('ATH') ? address.slice(3) : address;
+
+    let stakeAccounts = [];
+    try {
+      const res = await httpRequest(rpcUrl, `/v1/stake?address=${encodeURIComponent(rawAddr)}`);
+      if (res && !res.error) {
+        stakeAccounts = Array.isArray(res) ? res : (res.accounts || []);
+      }
+    } catch { /* no stake accounts */ }
+
+    if (stakeAccounts.length === 0) {
+      console.log(`  ${C.red}✗ No active stake accounts found for this wallet.${C.reset}`);
+      console.log(`  ${C.dim}Use ${C.cyan}--account <stakeAcct>${C.reset} ${C.dim}to specify a stake account.${C.reset}`);
+      console.log(`  ${C.dim}Check delegations: aether delegations list --address ${address}${C.reset}\n`);
+      return;
+    }
+
+    // Default to first active stake account
+    const active = stakeAccounts.find(s => !s.deactivation_epoch && (s.status === 'active' || s.state === 'active'));
+    stakeAccount = active
+      ? (active.pubkey || active.publicKey || active.account)
+      : (stakeAccounts[0].pubkey || stakeAccounts[0].publicKey || stakeAccounts[0].account);
+
+    console.log(`  ${C.cyan}Using stake account:${C.reset} ${C.bright}${stakeAccount}${C.reset}`);
+    console.log(`  ${C.dim}(override with ${C.cyan}--account <stakeAcct>${C.reset}${C.dim})${C.reset}\n`);
+  }
+
+  // Resolve amount: --amount flag, or prompt if partial unstake supported
+  // If no amount provided, unstake entire stake
+  let lamports = null;
+  if (amountStr) {
+    const amount = parseFloat(amountStr);
+    if (isNaN(amount) || amount <= 0) {
+      console.log(`  ${C.red}✗ Invalid amount:${C.reset} ${amountStr}\n`);
+      return;
+    }
+    lamports = Math.round(amount * 1e9);
+  }
+
+  console.log(`  ${C.green}★${C.reset} Wallet:       ${C.bright}${address}${C.reset}`);
+  console.log(`  ${C.green}★${C.reset} Stake acct: ${C.bright}${stakeAccount}${C.reset}`);
+  if (lamports !== null) {
+    console.log(`  ${C.green}★${C.reset} Amount:     ${C.bright}${(lamports / 1e9).toFixed(4)} AETH${C.reset} (${lamports} lamports)`);
+  } else {
+    console.log(`  ${C.green}★${C.reset} Amount:     ${C.bright}FULL STAKE${C.reset}`);
+  }
+  console.log();
+
+  // Ask for mnemonic to derive signing keypair
+  console.log(`${C.yellow}  ⚠ Signing requires your wallet passphrase.${C.reset}`);
+  const mnemonic = await askMnemonic(rl, 'Enter your 12/24-word passphrase to sign this transaction');
+  console.log();
+
+  let keyPair;
+  try {
+    keyPair = deriveKeypair(mnemonic, DERIVATION_PATH);
+  } catch (e) {
+    console.log(`  ${C.red}✗ Failed to derive keypair: ${e.message}${C.reset}`);
+    console.log(`  ${C.dim}Check your passphrase and try again.${C.reset}\n`);
+    return;
+  }
+
+  // Verify the derived address matches the wallet
+  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}\n`);
+    return;
+  }
+
+  const confirm = await question(rl, `  ${C.yellow}Confirm unstake? [y/N]${C.reset} > ${C.reset}`);
+  if (!confirm.trim().toLowerCase().startsWith('y')) {
+    console.log(`  ${C.dim}Cancelled.${C.reset}\n`);
+    return;
+  }
+
+  // Build the unstake transaction
+  const txData = {
+    type: 'Unstake',
+    data: {
+      stake_account: stakeAccount,
+    },
+  };
+  if (lamports !== null) {
+    txData.data.amount = lamports;
+  }
+
+  const tx = {
+    signer: address.startsWith('ATH') ? address.slice(3) : address,
+    tx_type: 'Unstake',
+    payload: txData,
+    fee: 0,
+    slot: 0,
+    timestamp: Math.floor(Date.now() / 1000),
+  };
+
+  const rpcUrl = getDefaultRpc();
+  console.log(`  ${C.dim}Submitting to ${rpcUrl}...${C.reset}`);
+
+  try {
+    const result = await httpPost(rpcUrl, '/v1/tx', tx);
+
+    if (result.error) {
+      console.log(`\n  ${C.red}✗ Unstake failed:${C.reset} ${result.error}\n`);
+      process.exit(1);
+    }
+
+    const sig = result.signature || result.tx_signature || result.id || JSON.stringify(result);
+    console.log(`\n${C.green}✓ Unstake transaction submitted!${C.reset}`);
+    console.log(`  ${C.dim}Signature:${C.reset} ${sig}`);
+    console.log(`  ${C.dim}Stake will deactivate over the next epoch.${C.reset}`);
+    console.log(`  ${C.dim}Check status: aether delegations list --address ${address}${C.reset}\n`);
+  } catch (err) {
+    console.log(`  ${C.red}✗ Failed to submit transaction:${C.reset} ${err.message}`);
+    console.log(`  ${C.dim}Is your validator running? RPC: ${rpcUrl}${C.reset}\n`);
+    process.exit(1);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Main dispatcher
 // ---------------------------------------------------------------------------
@@ -1133,6 +1298,8 @@ async function walletCommand() {
       await balanceWallet(rl);
     } else if (subcmd === 'stake') {
       await stakeWallet(rl);
+    } else if (subcmd === 'unstake') {
+      await unstakeWallet(rl);
     } else if (subcmd === 'transfer') {
       await transferWallet(rl);
     } else if (subcmd === 'history' || subcmd === 'tx') {
@@ -1147,6 +1314,7 @@ async function walletCommand() {
       console.log(`    ${C.cyan}aether wallet connect${C.reset}  Connect wallet via browser verification`);
       console.log(`    ${C.cyan}aether wallet balance${C.reset}  Query chain balance for an address`);
       console.log(`    ${C.cyan}aether wallet stake${C.reset}     Stake AETH to a validator`);
+      console.log(`    ${C.cyan}aether wallet unstake${C.reset}   Unstake AETH — deactivate a stake account`);
       console.log(`    ${C.cyan}aether wallet transfer${C.reset} Transfer AETH to another address`);
       console.log(`    ${C.cyan}aether wallet history${C.reset}  Show recent transactions for an address`);
       console.log();