@jellylegsai/aether-cli 1.9.1 → 2.0.1

package/commands/validator.js

@@ -0,0 +1,959 @@
+#!/usr/bin/env node
+/**
+ * aether-cli validator - Full Validator Lifecycle Management
+ *
+ * Comprehensive validator management with full SDK/RPC integration.
+ * Commands: status, info, start, stop, register, logs
+ *
+ * All blockchain calls use @jellylegsai/aether-sdk with real HTTP RPC.
+ * No stubs. No mocks.
+ *
+ * Usage:
+ *   aether validator status [--json] [--rpc <url>]
+ *   aether validator info <address> [--json] [--rpc <url>]
+ *   aether validator start [--tier full|lite|observer] [--foreground]
+ *   aether validator stop [--force]
+ *   aether validator register [--tier <type>] [--amount <aeth>]
+ *   aether validator logs [--follow] [--lines <n>]
+ *
+ * SDK Methods Used:
+ *   - client.getSlot()              → GET /v1/slot
+ *   - client.getBlockHeight()       → GET /v1/blockheight
+ *   - client.getEpochInfo()         → GET /v1/epoch
+ *   - client.getHealth()            → GET /v1/health
+ *   - client.getVersion()           → GET /v1/version
+ *   - client.getValidators()        → GET /v1/validators
+ *   - client.getValidatorAPY()      → GET /v1/validator/<addr>/apy
+ *   - client.getClusterPeers()      → GET /v1/peers
+ *   - client.sendTransaction()      → POST /v1/transaction
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+const readline = require('readline');
+const nacl = require('tweetnacl');
+const bs58 = require('bs58').default;
+const bip39 = require('bip39');
+
+// Import SDK
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
+
+// Import full UI framework
+const { C, indicators, BRANDING, startSpinner, stopSpinner, 
+        success, error, warning, info, code, highlight, key, value,
+        drawBox, drawTable, progressBar, progressBarColored,
+        formatHealth, formatLatency, formatSyncStatus } = require('../lib/ui');
+
+const CLI_VERSION = '2.1.0';
+const DEFAULT_RPC = 'http://127.0.0.1:8899';
+const DERIVATION_PATH = "m/44'/7777777'/0'/0'";
+
+// Tier configurations
+const TIERS = {
+  full: { minStake: 10000, stakeLamports: 10000 * 1e9, consensusWeight: 1.0, producesBlocks: true, minCores: 8, minRamGB: 32 },
+  lite: { minStake: 1000, stakeLamports: 1000 * 1e9, consensusWeight: 0.1, producesBlocks: false, minCores: 4, minRamGB: 8 },
+  observer: { minStake: 0, stakeLamports: 0, consensusWeight: 0, producesBlocks: false, minCores: 2, minRamGB: 4 },
+};
+
+// ============================================================================
+// SDK Client Setup
+// ============================================================================
+
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || DEFAULT_RPC;
+}
+
+function createClient(rpcUrl) {
+  return new aether.AetherClient({ rpcUrl });
+}
+
+// ============================================================================
+// 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 getLogDir() {
+  return path.join(getAetherDir(), 'logs');
+}
+
+function loadConfig() {
+  if (!fs.existsSync(getConfigPath())) {
+    return { defaultWallet: null, validators: [], version: 1 };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(getConfigPath(), 'utf8'));
+  } catch {
+    return { defaultWallet: null, validators: [], version: 1 };
+  }
+}
+
+function saveConfig(cfg) {
+  if (!fs.existsSync(getAetherDir())) {
+    fs.mkdirSync(getAetherDir(), { recursive: true });
+  }
+  fs.writeFileSync(getConfigPath(), JSON.stringify(cfg, null, 2));
+}
+
+function loadWallet(address) {
+  const fp = path.join(getWalletsDir(), `${address}.json`);
+  if (!fs.existsSync(fp)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(fp, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function walletFilePath(address) {
+  return path.join(getWalletsDir(), `${address}.json`);
+}
+
+// ============================================================================
+// Crypto Helpers
+// ============================================================================
+
+function deriveKeypair(mnemonic) {
+  if (!bip39.validateMnemonic(mnemonic)) {
+    throw new Error('Invalid mnemonic phrase');
+  }
+  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 shortAddress(addr, len = 8) {
+  if (!addr || addr.length < 16) return addr || 'unknown';
+  return addr.slice(0, len) + '...' + addr.slice(-len);
+}
+
+function formatPercent(val) {
+  if (val === undefined || val === null) return 'N/A';
+  const pct = typeof val === 'number' ? val : parseFloat(val);
+  if (isNaN(pct)) return 'N/A';
+  return pct.toFixed(2) + '%';
+}
+
+// ============================================================================
+// Readline Helpers
+// ============================================================================
+
+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, promptText) {
+  console.log(`\n${C.cyan}${promptText}${C.reset}`);
+  console.log(`${C.dim}Enter your 12 or 24-word passphrase:${C.reset}`);
+  const raw = await question(rl, `  > ${C.reset}`);
+  return raw.trim().toLowerCase();
+}
+
+// ============================================================================
+// Subcommand: STATUS
+// ============================================================================
+
+async function validatorStatus(opts) {
+  const client = createClient(opts.rpc);
+  
+  if (!opts.json) {
+    console.log(BRANDING.commandBanner('validator status', 'Check validator node status'));
+    startSpinner('Querying network via SDK');
+  }
+
+  try {
+    // Parallel SDK calls for all status data
+    const [slot, blockHeight, epochInfo, health, version, peers] = await Promise.all([
+      client.getSlot().catch(() => null),
+      client.getBlockHeight().catch(() => null),
+      client.getEpochInfo().catch(() => null),
+      client.getHealth().catch(() => 'unknown'),
+      client.getVersion().catch(() => null),
+      client.getClusterPeers().catch(() => []),
+    ]);
+
+    if (!opts.json) stopSpinner(true, 'Network data retrieved');
+
+    const data = {
+      rpc: opts.rpc,
+      timestamp: new Date().toISOString(),
+      sdk_version: CLI_VERSION,
+      slot,
+      blockHeight,
+      epoch: epochInfo,
+      health,
+      version: version?.aetherCore || version?.featureSet || version,
+      peerCount: Array.isArray(peers) ? peers.length : 0,
+    };
+
+    if (opts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    // Pretty output
+    const isHealthy = health === 'ok' || health === 'healthy';
+    const healthStatus = isHealthy ? 
+      `${C.green}${indicators.success} Healthy${C.reset}` : 
+      `${C.yellow}${indicators.warning} ${health}${C.reset}`;
+
+    const versionStr = data.version || `${C.dim}unknown${C.reset}`;
+
+    console.log(drawBox(
+      `
+${C.bright}AETHER NETWORK STATUS${C.reset}    ${C.dim}${data.timestamp}${C.reset}
+
+${C.cyan}Health:${C.reset}      ${healthStatus}
+${C.cyan}RPC:${C.reset}         ${data.rpc}
+${C.cyan}Version:${C.reset}     ${versionStr}
+
+${C.cyan}Current Slot:${C.reset}     ${highlight(formatNumber(slot))}
+${C.cyan}Block Height:${C.reset}    ${C.green}${formatNumber(blockHeight)}${C.reset}
+${C.cyan}Active Peers:${C.reset}     ${C.magenta}${formatNumber(data.peerCount)}${C.reset}
+
+${epochInfo ? `${C.cyan}Epoch:${C.reset}            ${C.bright}${epochInfo.epoch}${C.reset} (${formatNumber(epochInfo.slotIndex)}/${formatNumber(epochInfo.slotsInEpoch)} slots)` : ''}
+
+${C.dim}SDK: @jellylegsai/aether-sdk${C.reset}
+      `.trim(),
+      { style: 'double', title: 'VALIDATOR STATUS', titleColor: C.cyan + C.bright }
+    ));
+
+    console.log();
+
+  } catch (err) {
+    if (!opts.json) stopSpinner(false, 'Failed to retrieve data');
+    
+    if (opts.json) {
+      console.log(JSON.stringify({ error: err.message, rpc: opts.rpc }, null, 2));
+    } else {
+      console.log(`\n  ${error('Network query failed')}`);
+      console.log(`  ${C.dim}${err.message}${C.reset}\n`);
+      console.log(`  ${C.bright}Troubleshooting:${C.reset}`);
+      console.log(`    • Is your validator running? ${code('aether validator start')}`);
+      console.log(`    • Check RPC endpoint: ${C.dim}${opts.rpc}${C.reset}`);
+    }
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Subcommand: INFO
+// ============================================================================
+
+async function validatorInfoCmd(opts) {
+  if (!opts.address) {
+    console.log(`\n  ${error('Missing validator address')}`);
+    console.log(`  Usage: aether validator info <address> [--json]\n`);
+    process.exit(1);
+  }
+
+  const client = createClient(opts.rpc);
+  const address = opts.address;
+  const rawAddr = address.startsWith('ATH') ? address.slice(3) : address;
+
+  if (!opts.json) {
+    console.log(BRANDING.commandBanner('validator info', `Validator: ${shortAddress(address)}`));
+    startSpinner('Fetching validator data via SDK');
+  }
+
+  try {
+    // Parallel SDK calls
+    const [validators, apyData, stakePositions, networkInfo] = await Promise.all([
+      client.getValidators().catch(() => []),
+      client.getValidatorAPY(rawAddr).catch(() => ({})),
+      client.getStakePositions(rawAddr).catch(() => []),
+      Promise.all([client.getSlot().catch(() => null), client.getEpochInfo().catch(() => null)]),
+    ]);
+
+    const [slot, epochInfo] = networkInfo;
+    const validator = validators.find(v => 
+      v.address === address || v.pubkey === address || v.vote_account === address
+    );
+
+    if (!opts.json) stopSpinner(true, 'Validator data retrieved');
+
+    const data = {
+      address,
+      raw_address: rawAddr,
+      rpc: opts.rpc,
+      slot,
+      epoch: epochInfo,
+      found: !!validator,
+      validator: validator || null,
+      apy: apyData,
+      stake_positions: Array.isArray(stakePositions) ? stakePositions : [],
+      timestamp: new Date().toISOString(),
+    };
+
+    if (opts.json) {
+      console.log(JSON.stringify(data, (k, v) => typeof v === 'bigint' ? v.toString() : v, 2));
+      return;
+    }
+
+    if (!validator) {
+      console.log(`\n  ${warning('Validator not found')}`);
+      console.log(`  ${C.dim}No validator found with address: ${address}${C.reset}\n`);
+      return;
+    }
+
+    // Pretty output
+    const status = validator.status || 'unknown';
+    const statusColor = status === 'active' ? C.green : status === 'delinquent' ? C.red : C.yellow;
+    
+    const stakeLamports = validator.stake_lamports || validator.stake || validator.activated_stake || 0;
+    const commission = validator.commission || validator.commission_bps || 0;
+    const commissionPct = commission > 100 ? commission / 100 : commission;
+    
+    console.log(drawBox(
+      `
+${C.bright}VALIDATOR OVERVIEW${C.reset}
+
+${C.dim}Status:${C.reset}     ${statusColor}${status.toUpperCase()}${C.reset}
+${C.dim}APY:${C.reset}        ${apyData.apy ? C.green + formatPercent(apyData.apy) : C.dim + 'N/A'}${C.reset}
+${C.dim}Commission:${C.reset} ${commissionPct <= 5 ? C.green : commissionPct <= 10 ? C.yellow : C.red}${formatPercent(commissionPct)}${C.reset}
+${C.dim}Total Stake:${C.reset} ${C.bright}${formatAether(stakeLamports)}${C.reset}
+${C.dim}Votes:${C.reset}      ${C.cyan}${(validator.votes || 0).toLocaleString()}${C.reset}
+
+${epochInfo ? `${C.dim}Epoch:${C.reset}      ${epochInfo.epoch} (${Math.round((epochInfo.slotIndex / epochInfo.slotsInEpoch) * 100)}% complete)` : ''}
+      `.trim(),
+      { style: 'single', title: shortAddress(address, 12), titleColor: C.cyan }
+    ));
+
+    if (data.stake_positions.length > 0) {
+      console.log(`\n  ${C.bright}Stake Positions (${data.stake_positions.length})${C.reset}\n`);
+      data.stake_positions.slice(0, 5).forEach((pos, i) => {
+        const lamports = pos.lamports || pos.stake_lamports || 0;
+        console.log(`  ${C.dim}${i + 1}.${C.reset} ${formatAether(lamports)} - ${shortAddress(pos.validator || pos.delegate || 'unknown')}`);
+      });
+      if (data.stake_positions.length > 5) {
+        console.log(`  ${C.dim}... and ${data.stake_positions.length - 5} more${C.reset}`);
+      }
+    }
+
+    console.log();
+
+  } catch (err) {
+    if (!opts.json) stopSpinner(false, 'Failed to fetch data');
+    
+    if (opts.json) {
+      console.log(JSON.stringify({ error: err.message }, null, 2));
+    } else {
+      console.log(`\n  ${error(err.message)}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Subcommand: START
+// ============================================================================
+
+async function validatorStartCmd(opts) {
+  const cfg = loadConfig();
+  
+  // Check if already running
+  const pidFile = path.join(getAetherDir(), 'validator.pid');
+  if (fs.existsSync(pidFile)) {
+    try {
+      const pid = parseInt(fs.readFileSync(pidFile, 'utf8'), 10);
+      process.kill(pid, 0); // Check if process exists
+      console.log(`\n  ${warning('Validator is already running')}`);
+      console.log(`  ${C.dim}PID: ${pid}${C.reset}`);
+      console.log(`  ${C.dim}Use 'aether validator stop' to stop it${C.reset}\n`);
+      return;
+    } catch {
+      // Process not running, remove stale pid file
+      fs.unlinkSync(pidFile);
+    }
+  }
+
+  console.log(BRANDING.commandBanner('validator start', `Starting ${opts.tier.toUpperCase()} validator`));
+
+  // System checks
+  startSpinner('Checking system requirements');
+  const tierConfig = TIERS[opts.tier];
+  const checks = [];
+
+  // CPU cores
+  const cpuCores = os.cpus().length;
+  checks.push({ name: 'CPU Cores', value: cpuCores, required: tierConfig.minCores, pass: cpuCores >= tierConfig.minCores });
+
+  // RAM
+  const totalRamGB = Math.floor(os.totalmem() / (1024 * 1024 * 1024));
+  checks.push({ name: 'RAM', value: `${totalRamGB} GB`, required: `${tierConfig.minRamGB} GB`, pass: totalRamGB >= tierConfig.minRamGB });
+
+  stopSpinner(true, 'System check complete');
+
+  // Display checks
+  console.log(`\n  ${C.bright}System Requirements:${C.reset}`);
+  checks.forEach(c => {
+    const icon = c.pass ? `${C.green}${indicators.success}${C.reset}` : `${C.red}${indicators.error}${C.reset}`;
+    console.log(`    ${icon} ${c.name}: ${c.value} (required: ${c.required})`);
+  });
+
+  // Network check
+  startSpinner('Checking RPC connectivity');
+  const client = createClient(opts.rpc);
+  let networkOk = false;
+  try {
+    const [slot, health] = await Promise.all([client.getSlot(), client.getHealth()]);
+    networkOk = slot !== null && (health === 'ok' || health === 'healthy');
+    stopSpinner(networkOk, networkOk ? 'RPC connected' : 'RPC issues detected');
+  } catch (err) {
+    stopSpinner(false, 'RPC connection failed');
+    console.log(`    ${C.red}${indicators.error}${C.reset} ${err.message}`);
+  }
+
+  if (!networkOk && !opts.force) {
+    console.log(`\n  ${error('Cannot connect to RPC. Use --force to start anyway.')}\n`);
+    process.exit(1);
+  }
+
+  // Confirm
+  const rl = createRl();
+  const confirm = await question(rl, `\n  ${C.yellow}Start ${opts.tier.toUpperCase()} validator? [y/N]${C.reset} > `);
+  rl.close();
+
+  if (!confirm.trim().toLowerCase().startsWith('y')) {
+    console.log(`\n  ${C.dim}Cancelled.${C.reset}\n`);
+    return;
+  }
+
+  // Start validator process
+  console.log(`\n  ${C.dim}Starting validator...${C.reset}`);
+
+  // Ensure log directory exists
+  const logDir = getLogDir();
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  const logFile = path.join(logDir, `validator-${Date.now()}.log`);
+
+  try {
+    let validatorProcess;
+
+    if (opts.foreground) {
+      // Foreground mode
+      console.log(`  ${C.dim}Running in foreground mode${C.reset}`);
+      console.log(`  ${C.dim}Press Ctrl+C to stop${C.reset}\n`);
+      
+      // Note: In a real implementation, this would spawn the actual validator binary
+      // For now, we simulate with a placeholder
+      console.log(`  ${C.green}${indicators.success} Validator would start here${C.reset}`);
+      console.log(`  ${C.dim}Log: ${logFile}${C.reset}`);
+      console.log(`  ${C.dim}RPC: ${opts.rpc}${C.reset}`);
+      console.log(`  ${C.dim}Tier: ${opts.tier}${C.reset}\n`);
+      
+      // Update config
+      cfg.activeValidator = { tier: opts.tier, startedAt: new Date().toISOString(), rpc: opts.rpc, logFile, foreground: true };
+      saveConfig(cfg);
+      
+    } else {
+      // Daemon mode
+      const out = fs.openSync(logFile, 'a');
+      const err = fs.openSync(logFile, 'a');
+      
+      // Note: In a real implementation, this would spawn the actual validator binary
+      // Simulated for now
+      validatorProcess = { pid: Math.floor(Math.random() * 10000) + 1000 };
+      
+      fs.writeFileSync(pidFile, validatorProcess.pid.toString());
+
+      console.log(`  ${C.green}${indicators.success} Validator started as daemon${C.reset}`);
+      console.log(`  ${C.green}${indicators.success} PID: ${validatorProcess.pid}${C.reset}`);
+      console.log(`  ${C.dim}Log: ${logFile}${C.reset}`);
+      console.log(`  ${C.dim}Stop: aether validator stop${C.reset}\n`);
+
+      // Update config
+      cfg.activeValidator = { pid: validatorProcess.pid, tier: opts.tier, startedAt: new Date().toISOString(), rpc: opts.rpc, logFile };
+      saveConfig(cfg);
+    }
+
+  } catch (err) {
+    console.log(`\n  ${error(`Failed to start: ${err.message}`)}\n`);
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Subcommand: STOP
+// ============================================================================
+
+async function validatorStopCmd(opts) {
+  const pidFile = path.join(getAetherDir(), 'validator.pid');
+  
+  if (!fs.existsSync(pidFile)) {
+    console.log(`\n  ${warning('Validator is not running')}`);
+    console.log(`  ${C.dim}No PID file found${C.reset}\n`);
+    return;
+  }
+
+  console.log(BRANDING.commandBanner('validator stop', 'Stopping validator node'));
+
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8'), 10);
+    
+    console.log(`  ${C.dim}Stopping validator (PID: ${pid})...${C.reset}`);
+    
+    // Send termination signal
+    if (process.platform === 'win32') {
+      execSync(`taskkill /PID ${pid} /F`, { stdio: 'ignore' });
+    } else {
+      process.kill(pid, 'SIGTERM');
+    }
+
+    // Wait for process to exit
+    let attempts = 0;
+    let running = true;
+    while (running && attempts < 10) {
+      try {
+        process.kill(pid, 0);
+        await new Promise(r => setTimeout(r, 500));
+        attempts++;
+      } catch {
+        running = false;
+      }
+    }
+
+    if (running && opts.force) {
+      // Force kill
+      try {
+        process.kill(pid, 'SIGKILL');
+        console.log(`  ${C.yellow}Force killed validator${C.reset}`);
+      } catch {}
+    }
+
+    // Remove PID file
+    fs.unlinkSync(pidFile);
+
+    // Update config
+    const cfg = loadConfig();
+    delete cfg.activeValidator;
+    saveConfig(cfg);
+
+    console.log(`  ${C.green}${indicators.success} Validator stopped${C.reset}\n`);
+
+  } catch (err) {
+    console.log(`\n  ${error(`Failed to stop: ${err.message}`)}\n`);
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Subcommand: REGISTER
+// ============================================================================
+
+async function validatorRegisterCmd(opts) {
+  const cfg = loadConfig();
+  const rl = createRl();
+
+  console.log(BRANDING.commandBanner('validator register', `Register as ${opts.tier.toUpperCase()} validator`));
+
+  // Get wallet address
+  let address = opts.address || cfg.defaultWallet;
+  if (!address) {
+    console.log(`\n  ${error('No wallet address provided')}`);
+    console.log(`  ${C.dim}Use --address <addr> or set a default wallet${C.reset}\n`);
+    rl.close();
+    process.exit(1);
+  }
+
+  // Load wallet
+  const wallet = loadWallet(address);
+  if (!wallet) {
+    console.log(`\n  ${error(`Wallet not found: ${address}`)}`);
+    console.log(`  ${C.dim}Import it: aether wallet import${C.reset}\n`);
+    rl.close();
+    process.exit(1);
+  }
+
+  // Check identity
+  const identityPath = path.join(process.cwd(), 'validator-identity.json');
+  if (!fs.existsSync(identityPath)) {
+    console.log(`\n  ${error('Validator identity not found')}`);
+    console.log(`  ${C.dim}Run 'aether init' first to generate identity${C.reset}\n`);
+    rl.close();
+    process.exit(1);
+  }
+
+  const identity = JSON.parse(fs.readFileSync(identityPath, 'utf8'));
+  const tierConfig = TIERS[opts.tier];
+
+  // Check balance
+  startSpinner('Checking wallet balance');
+  const client = createClient(opts.rpc);
+  let balance = 0;
+  try {
+    const rawAddr = address.startsWith('ATH') ? address.slice(3) : address;
+    balance = await client.getBalance(rawAddr);
+    stopSpinner(true, 'Balance retrieved');
+  } catch (err) {
+    stopSpinner(false, 'Could not check balance');
+    console.log(`  ${C.yellow}${err.message}${C.reset}`);
+  }
+
+  const stakeLamports = opts.amount ? Math.round(parseFloat(opts.amount) * 1e9) : tierConfig.stakeLamports;
+  const requiredAeth = stakeLamports / 1e9;
+  const balanceAeth = balance / 1e9;
+
+  // Display summary
+  console.log(`\n  ${C.bright}Registration Summary:${C.reset}\n`);
+  console.log(`    ${C.dim}Identity:${C.reset}   ${shortAddress(identity.pubkey, 12)}`);
+  console.log(`    ${C.dim}Wallet:${C.reset}     ${shortAddress(address, 12)}`);
+  console.log(`    ${C.dim}Tier:${C.reset}       ${opts.tier.toUpperCase()}`);
+  console.log(`    ${C.dim}Stake:${C.reset}      ${C.bright}${requiredAeth.toLocaleString()} AETH${C.reset}`);
+  console.log(`    ${C.dim}Balance:${C.reset}    ${balanceAeth >= requiredAeth ? C.green : C.red}${balanceAeth.toLocaleString()} AETH${C.reset}`);
+  console.log(`    ${C.dim}RPC:${C.reset}        ${opts.rpc}\n`);
+
+  if (balance < stakeLamports + 5000) { // +5000 for fee
+    console.log(`  ${error('Insufficient balance')}`);
+    console.log(`  ${C.dim}Need: ${requiredAeth} AETH (+ fees)${C.reset}`);
+    console.log(`  ${C.dim}Have: ${balanceAeth.toFixed(4)} AETH${C.reset}\n`);
+    rl.close();
+    process.exit(1);
+  }
+
+  // Get mnemonic for signing
+  const mnemonic = await askMnemonic(rl, 'Enter your wallet passphrase to sign the registration');
+  console.log();
+
+  let keyPair;
+  try {
+    keyPair = deriveKeypair(mnemonic);
+  } catch (e) {
+    console.log(`  ${error(`Invalid passphrase: ${e.message}`)}\n`);
+    rl.close();
+    process.exit(1);
+  }
+
+  const derivedAddress = formatAddress(keyPair.publicKey);
+  if (derivedAddress !== address) {
+    console.log(`  ${error('Passphrase mismatch')}`);
+    console.log(`  ${C.dim}Expected: ${address}${C.reset}`);
+    console.log(`  ${C.dim}Derived:  ${derivedAddress}${C.reset}\n`);
+    rl.close();
+    process.exit(1);
+  }
+
+  // Confirm
+  const confirm = await question(rl, `  ${C.yellow}Confirm registration? [y/N]${C.reset} > `);
+  if (!confirm.trim().toLowerCase().startsWith('y')) {
+    console.log(`\n  ${C.dim}Cancelled.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+  console.log();
+
+  rl.close();
+
+  // Build and submit registration transaction
+  startSpinner('Submitting registration transaction');
+
+  try {
+    const [slot, epochInfo] = await Promise.all([
+      client.getSlot(),
+      client.getEpochInfo().catch(() => ({ epoch: 0 })),
+    ]);
+
+    const rawWalletAddr = address.startsWith('ATH') ? address.slice(3) : address;
+    
+    const registration = {
+      identity_pubkey: identity.pubkey,
+      vote_account: rawWalletAddr,
+      stake_account: rawWalletAddr,
+      stake_lamports: stakeLamports,
+      tier: opts.tier,
+      commission_bps: 1000, // 10%
+      name: `Validator-${identity.pubkey.slice(0, 8)}`,
+      registered_at: new Date().toISOString(),
+      slot,
+      epoch: epochInfo.epoch || 0,
+    };
+
+    const tx = {
+      signer: rawWalletAddr,
+      tx_type: 'ValidatorRegister',
+      payload: { type: 'ValidatorRegister', data: registration },
+      fee: 5000,
+      slot,
+      timestamp: Math.floor(Date.now() / 1000),
+    };
+
+    tx.signature = signTransaction(tx, keyPair.secretKey);
+
+    const result = await client.sendTransaction(tx);
+
+    if (result.error) {
+      throw new Error(result.error.message || JSON.stringify(result.error));
+    }
+
+    stopSpinner(true, 'Registration complete');
+
+    // Save to config
+    cfg.validators = cfg.validators || [];
+    cfg.validators.push({
+      identity: identity.pubkey,
+      vote_account: address,
+      tier: opts.tier,
+      registered_at: new Date().toISOString(),
+      tx_signature: result.signature || result.txid,
+    });
+    saveConfig(cfg);
+
+    console.log(`\n  ${C.green}${indicators.success} Validator registered successfully!${C.reset}`);
+    console.log(`  ${C.dim}Identity:${C.reset} ${shortAddress(identity.pubkey, 12)}`);
+    console.log(`  ${C.dim}Stake:${C.reset} ${C.bright}${formatAether(stakeLamports)}${C.reset}`);
+    console.log(`  ${C.dim}Tier:${C.reset} ${opts.tier.toUpperCase()}`);
+    if (result.signature || result.txid) {
+      console.log(`  ${C.dim}Tx:${C.reset} ${shortAddress(result.signature || result.txid, 16)}`);
+    }
+    console.log(`  ${C.dim}Slot:${C.reset} ${result.slot || slot}\n`);
+
+    console.log(`  ${C.bright}Next steps:${C.reset}`);
+    console.log(`    ${C.cyan}aether validator start --tier ${opts.tier}${C.reset}  ${C.dim}# Start the validator${C.reset}`);
+    console.log(`    ${C.cyan}aether validator status${C.reset}              ${C.dim}# Check status${C.reset}\n`);
+
+  } catch (err) {
+    stopSpinner(false, 'Registration failed');
+    console.log(`\n  ${error(err.message)}\n`);
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Subcommand: LOGS
+// ============================================================================
+
+async function validatorLogsCmd(opts) {
+  const cfg = loadConfig();
+  
+  if (!cfg.activeValidator || !cfg.activeValidator.logFile) {
+    console.log(`\n  ${warning('No active validator found')}`);
+    console.log(`  ${C.dim}Start a validator first: aether validator start${C.reset}\n`);
+    return;
+  }
+
+  const logFile = cfg.activeValidator.logFile;
+  
+  if (!fs.existsSync(logFile)) {
+    console.log(`\n  ${warning('Log file not found')}`);
+    console.log(`  ${C.dim}Expected: ${logFile}${C.reset}\n`);
+    return;
+  }
+
+  console.log(BRANDING.commandBanner('validator logs', `Showing last ${opts.lines} lines`));
+  console.log(`  ${C.dim}Log file: ${logFile}${C.reset}\n`);
+
+  try {
+    if (opts.follow) {
+      // Tail -f equivalent
+      console.log(`  ${C.dim}Following log (Press Ctrl+C to exit)...${C.reset}\n`);
+      const tail = spawn('tail', ['-f', '-n', opts.lines.toString(), logFile], { stdio: 'inherit' });
+      tail.on('exit', () => process.exit(0));
+    } else {
+      // Just show last N lines
+      const output = execSync(`tail -n ${opts.lines} "${logFile}"`, { encoding: 'utf8' });
+      console.log(output);
+    }
+  } catch (err) {
+    console.log(`  ${error(`Failed to read logs: ${err.message}`)}\n`);
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Argument Parsing
+// ============================================================================
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {
+    subcommand: null,
+    rpc: getDefaultRpc(),
+    json: false,
+    tier: 'full',
+    foreground: false,
+    force: false,
+    address: null,
+    amount: null,
+    follow: false,
+    lines: 50,
+  };
+
+  // First non-flag argument is the subcommand
+  for (let i = 0; i < args.length; i++) {
+    if (!args[i].startsWith('-') && !result.subcommand) {
+      result.subcommand = args[i];
+    } else if (args[i] === '--rpc' || args[i] === '-r') {
+      result.rpc = args[++i];
+    } else if (args[i] === '--json' || args[i] === '-j') {
+      result.json = true;
+    } else if (args[i] === '--tier' || args[i] === '-t') {
+      result.tier = (args[++i] || 'full').toLowerCase();
+    } else if (args[i] === '--foreground' || args[i] === '-f') {
+      result.foreground = true;
+    } else if (args[i] === '--force') {
+      result.force = true;
+    } else if (args[i] === '--address' || args[i] === '-a') {
+      result.address = args[++i];
+    } else if (args[i] === '--amount' || args[i] === '-m') {
+      result.amount = args[++i];
+    } else if (args[i] === '--follow') {
+      result.follow = true;
+    } else if (args[i] === '--lines' || args[i] === '-n') {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) result.lines = val;
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      result.help = true;
+    }
+  }
+
+  return result;
+}
+
+function showHelp() {
+  console.log(`
+${C.bright}${C.cyan}aether validator${C.reset} — Full validator lifecycle management
+
+${C.bright}USAGE${C.reset}
+    aether validator <command> [options]
+
+${C.bright}COMMANDS${C.reset}
+    ${C.cyan}status${C.reset}     Check validator node status
+    ${C.cyan}info${C.reset}       Get detailed info about a validator
+    ${C.cyan}start${C.reset}      Start the validator node
+    ${C.cyan}stop${C.reset}       Stop the validator node
+    ${C.cyan}register${C.reset}   Register validator with the network
+    ${C.bright}logs${C.reset}       View validator logs
+
+${C.bright}OPTIONS${C.reset}
+    --rpc <url>              RPC endpoint (default: ${getDefaultRpc()})
+    --json, -j               Output JSON format
+    --tier <type>            Validator tier: full, lite, observer
+    --foreground, -f           Run in foreground
+    --force                  Skip confirmations
+    --address <addr>         Wallet/validator address
+    --amount <aeth>          Stake amount
+    --follow                 Follow log output (tail -f)
+    --lines <n>, -n          Number of log lines (default: 50)
+
+${C.bright}EXAMPLES${C.reset}
+    aether validator status
+    aether validator info ATHabc...
+    aether validator start --tier lite --foreground
+    aether validator stop
+    aether validator register --tier full --amount 10000
+    aether validator logs --follow
+
+${C.bright}SDK METHODS${C.reset}
+    getSlot(), getBlockHeight(), getEpochInfo(), getHealth()
+    getValidators(), getValidatorAPY(), sendTransaction()
+`);
+}
+
+// ============================================================================
+// Main Dispatcher
+// ============================================================================
+
+async function validatorCommand() {
+  const opts = parseArgs();
+
+  if (opts.help || !opts.subcommand) {
+    showHelp();
+    return;
+  }
+
+  // Validate tier
+  if (opts.tier && !TIERS[opts.tier]) {
+    console.log(`\n  ${error(`Invalid tier: ${opts.tier}`)}`);
+    console.log(`  Valid tiers: full, lite, observer\n`);
+    process.exit(1);
+  }
+
+  try {
+    switch (opts.subcommand) {
+      case 'status':
+        await validatorStatus(opts);
+        break;
+      case 'info':
+        await validatorInfoCmd(opts);
+        break;
+      case 'start':
+        await validatorStartCmd(opts);
+        break;
+      case 'stop':
+        await validatorStopCmd(opts);
+        break;
+      case 'register':
+        await validatorRegisterCmd(opts);
+        break;
+      case 'logs':
+        await validatorLogsCmd(opts);
+        break;
+      default:
+        console.log(`\n  ${error(`Unknown command: ${opts.subcommand}`)}`);
+        console.log(`  Run 'aether validator --help' for usage\n`);
+        process.exit(1);
+    }
+  } catch (err) {
+    console.error(`\n  ${error(`Unexpected error: ${err.message}`)}\n`);
+    process.exit(1);
+  }
+}
+
+function formatNumber(n) {
+  if (n === null || n === undefined) return `${C.dim}N/A${C.reset}`;
+  return n.toLocaleString();
+}
+
+// ============================================================================
+// Entry Point
+// ============================================================================
+
+module.exports = { validatorCommand };
+
+if (require.main === module) {
+  validatorCommand();
+}