aether-hub 1.0.5 → 1.1.0

package/commands/network.js

@@ -0,0 +1,503 @@
+#!/usr/bin/env node
+/**
+ * aether-cli network - Aether Network Status
+ *
+ * Queries the Aether network for broad health metrics:
+ *   - Network-wide slot, block height, slot production
+ *   - Connected peers and their info
+ *   - Consensus status and epoch info
+ *   - TPS estimates from the network
+ *
+ * Usage:
+ *   aether-cli network             # Interactive summary view
+ *   aether-cli network --json      # JSON output for scripting
+ *   aether-cli network --rpc <url> # Query a specific RPC endpoint
+ *   aether-cli network --peers     # Detailed peer list
+ *   aether-cli network --epoch     # Current epoch and consensus info
+ */
+
+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',
+  white: '\x1b[37m',
+};
+
+const DEFAULT_RPC = process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+
+// ---------------------------------------------------------------------------
+// HTTP helpers
+// ---------------------------------------------------------------------------
+
+function httpRequest(rpcUrl, path, options = {}) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, rpcUrl);
+    const isHttps = url.protocol === 'https:';
+    const lib = isHttps ? https : http;
+
+    const reqOptions = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'GET',
+      timeout: 5000,
+      headers: { 'Content-Type': 'application/json' },
+    };
+
+    const req = lib.request(reqOptions, (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();
+  });
+}
+
+function httpPost(rpcUrl, path, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, rpcUrl);
+    const isHttps = url.protocol === 'https:';
+    const lib = isHttps ? https : http;
+    const bodyStr = JSON.stringify(body);
+
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'POST',
+      timeout: 5000,
+      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.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    req.write(bodyStr);
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    rpc: DEFAULT_RPC,
+    showPeers: false,
+    showEpoch: false,
+    asJson: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--rpc' || args[i] === '-r') {
+      options.rpc = args[++i];
+    } else if (args[i] === '--peers' || args[i] === '-p') {
+      options.showPeers = true;
+    } else if (args[i] === '--epoch' || args[i] === '-e') {
+      options.showEpoch = true;
+    } else if (args[i] === '--json' || args[i] === '-j') {
+      options.asJson = true;
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      showHelp();
+      process.exit(0);
+    }
+  }
+
+  return options;
+}
+
+function showHelp() {
+  console.log(`
+${C.bright}${C.cyan}aether-cli network${C.reset} - Aether Network Status
+
+${C.bright}Usage:${C.reset}
+  aether-cli network [options]
+
+${C.bright}Options:${C.reset}
+  -r, --rpc <url>     RPC endpoint (default: ${DEFAULT_RPC} or $AETHER_RPC)
+  -p, --peers         Show detailed peer list
+  -e, --epoch         Show epoch and consensus information
+  -j, --json          Output raw JSON (good for scripting)
+  -h, --help          Show this help message
+
+${C.bright}Examples:${C.reset}
+  aether-cli network                    # Summary view
+  aether-cli network --json             # JSON output
+  aether-cli network --rpc http://api.testnet.aether.network
+  aether-cli network --peers            # Detailed peer list
+  aether-cli network --epoch            # Epoch/consensus info
+`.trim());
+}
+
+// ---------------------------------------------------------------------------
+// Network data fetchers
+// ---------------------------------------------------------------------------
+
+/** GET /v1/slot — current network slot */
+async function getSlot(rpc) {
+  try {
+    const res = await httpRequest(rpc, '/v1/slot');
+    return res.slot ?? res.root_slot ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** GET /v1/block_height — current network block height */
+async function getBlockHeight(rpc) {
+  try {
+    const res = await httpRequest(rpc, '/v1/block_height');
+    return res.block_height ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** GET /v1/validators — list of validators / peers */
+async function getValidators(rpc) {
+  try {
+    const res = await httpRequest(rpc, '/v1/validators');
+    if (res.validators && Array.isArray(res.validators)) {
+      return res.validators;
+    }
+    if (Array.isArray(res)) return res;
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+/** GET /v1/epoch — current epoch and consensus info */
+async function getEpoch(rpc) {
+  try {
+    const res = await httpRequest(rpc, '/v1/epoch');
+    return res;
+  } catch {
+    return null;
+  }
+}
+
+/** POST /v1/slot_production — slot production stats */
+async function getSlotProduction(rpc) {
+  try {
+    // Try slot production endpoint
+    const res = await httpPost(rpc, '/v1/slot_production', {});
+    return res;
+  } catch {
+    return null;
+  }
+}
+
+/** GET /v1/tps — TPS estimate from network */
+async function getTPS(rpc) {
+  try {
+    const res = await httpRequest(rpc, '/v1/tps');
+    return res.tps ?? res.tps_avg ?? res.transactions_per_second ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** GET /v1/supply — token supply info */
+async function getSupply(rpc) {
+  try {
+    const res = await httpRequest(rpc, '/v1/supply');
+    return res;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Output formatters
+// ---------------------------------------------------------------------------
+
+function formatNumber(n) {
+  if (n === null || n === undefined) return 'N/A';
+  return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+function peerHealthIcon(score) {
+  if (score === undefined || score === null) return `${C.dim}●${C.reset}`;
+  if (score >= 80) return `${C.green}●${C.reset}`;
+  if (score >= 50) return `${C.yellow}●${C.reset}`;
+  return `${C.red}●${C.reset}`;
+}
+
+function uptimeString(seconds) {
+  if (!seconds) return `${C.dim}unknown${C.reset}`;
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor((seconds % 86400) / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const parts = [];
+  if (d > 0) parts.push(`${d}d`);
+  if (h > 0) parts.push(`${h}h`);
+  if (m > 0) parts.push(`${m}m`);
+  return parts.length > 0 ? parts.join(' ') : `${seconds}s`;
+}
+
+// ---------------------------------------------------------------------------
+// Main renderers
+// ---------------------------------------------------------------------------
+
+function renderSummary(data, rpc) {
+  const { slot, blockHeight, peerCount, tps, supply, epochData } = data;
+  const now = new Date().toLocaleTimeString();
+
+  console.log(`
+${C.bright}${C.cyan}╔═══════════════════════════════════════════════════════════════════╗${C.reset}
+${C.bright}${C.cyan}║${C.reset}              ${C.bright}AETHER NETWORK STATUS${C.reset}${C.cyan}                            ║${C.reset}
+${C.bright}${C.cyan}╚═══════════════════════════════════════════════════════════════════╝${C.reset}
+`);
+  console.log(`  ${C.dim}RPC:${C.reset} ${rpc}`);
+  console.log(`  ${C.dim}Updated:${C.reset} ${now}`);
+  console.log();
+
+  // Network health
+  const isHealthy = slot !== null && blockHeight !== null;
+  const healthIcon = isHealthy ? `${C.green}● HEALTHY${C.reset}` : `${C.red}● UNHEALTHY${C.reset}`;
+  console.log(`  Network ${healthIcon}`);
+  console.log();
+
+  // Key metrics
+  console.log(`  ${C.bright}┌─────────────────────────────────────────────────────────────────┐${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset}  ${C.cyan}Current Slot${C.reset}          ${C.bright}│${C.reset}  ${C.green}${formatNumber(slot).padEnd(20)}${C.reset}${C.bright}│${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset}  ${C.cyan}Block Height${C.reset}         ${C.bright}│${C.reset}  ${C.blue}${formatNumber(blockHeight).padEnd(20)}${C.reset}${C.bright}│${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset}  ${C.cyan}Active Peers${C.reset}         ${C.bright}│${C.reset}  ${C.magenta}${formatNumber(peerCount).padEnd(20)}${C.reset}${C.bright}│${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset}  ${C.cyan}Network TPS${C.reset}          ${C.bright}│${C.reset}  ${tps !== null ? (tps > 0 ? `${C.green}` : `${C.yellow}`) + tps.toFixed(2).padEnd(20) : `${C.dim}N/A`.padEnd(20)}${C.reset}${C.bright}│${C.reset}`);
+  console.log(`  ${C.bright}└─────────────────────────────────────────────────────────────────┘${C.reset}`);
+  console.log();
+
+  // Epoch info if available
+  if (epochData && (epochData.epoch !== undefined || epochData.absolute_slot !== undefined)) {
+    console.log(`  ${C.bright}── Epoch / Consensus ──────────────────────────────────────────${C.reset}`);
+    const ep = epochData.epoch !== undefined ? epochData.epoch : '?';
+    const slotIndex = epochData.slot_index !== undefined ? epochData.slot_index : '?';
+    const slotsInEpoch = epochData.slots_in_epoch !== undefined ? epochData.slots_in_epoch : '?';
+    const progress = slotsInEpoch !== '?' && slotsInEpoch > 0
+      ? ((slotIndex / slotsInEpoch) * 100).toFixed(1) + '%'
+      : '?';
+
+    console.log(`  ${C.dim}Epoch:${C.reset} ${C.bright}${ep}${C.reset}  ${C.dim}Slot in epoch:${C.reset} ${slotIndex}/${slotsInEpoch} ${C.dim}(${progress})${C.reset}`);
+    if (epochData.absolute_slot !== undefined) {
+      console.log(`  ${C.dim}Absolute slot:${C.reset} ${formatNumber(epochData.absolute_slot)}`);
+    }
+    if (epochData.block_height !== undefined) {
+      console.log(`  ${C.dim}Block height:${C.reset} ${formatNumber(epochData.block_height)}`);
+    }
+    console.log();
+  }
+
+  // Supply if available
+  if (supply && !supply.error) {
+    console.log(`  ${C.bright}── Token Supply ───────────────────────────────────────────────${C.reset}`);
+    if (supply.total !== undefined) {
+      const totalAETH = (supply.total / 1e9).toFixed(2);
+      console.log(`  ${C.dim}Total supply:${C.reset}  ${C.green}${formatNumber(supply.total)} lamports${C.reset} ${C.dim}(${totalAETH} AETH)${C.reset}`);
+    }
+    if (supply.circulating !== undefined) {
+      const circAETH = (supply.circulating / 1e9).toFixed(2);
+      console.log(`  ${C.dim}Circulating:${C.reset} ${formatNumber(supply.circulating)} lamports ${C.dim}(${circAETH} AETH)${C.reset}`);
+    }
+    console.log();
+  }
+
+  console.log(`  ${C.dim}Tip: --peers for peer list  |  --epoch for consensus  |  --json for raw data${C.reset}`);
+  console.log();
+}
+
+function renderPeers(peers, rpc) {
+  console.log();
+  console.log(`${C.bright}${C.cyan}── Peer List ─────────────────────────────────────────────────${C.reset}`);
+  console.log(`  ${C.dim}RPC: ${rpc}${C.reset}`);
+  console.log();
+
+  if (!peers || peers.length === 0) {
+    console.log(`  ${C.yellow}⚠ No peer information available from this RPC.${C.reset}`);
+    console.log(`  ${C.dim}  Peers may not be exposed by your validator's RPC configuration.${C.reset}`);
+    console.log();
+    return;
+  }
+
+  console.log(`  ${C.bright}┌────────────────────────────────────────────────────────────────────────┐${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset} ${C.cyan}#${C.reset}  ${C.cyan}Validator Address${C.reset}                        ${C.cyan}Tier${C.reset}   ${C.cyan}Score${C.reset}  ${C.cyan}Uptime${C.reset} ${C.bright}│${C.reset}`);
+  console.log(`  ${C.bright}├${C.reset}${'-'.repeat(78)}${C.bright}│${C.reset}`);
+
+  peers.slice(0, 50).forEach((peer, i) => {
+    const num = (i + 1).toString().padStart(2);
+    const addr = (peer.address || peer.pubkey || peer.id || 'unknown').slice(0, 32).padEnd(34);
+    const tier = (peer.tier || peer.node_type || '?').toUpperCase().padEnd(6).slice(0, 6);
+    const score = peer.score !== undefined ? peer.score : (peer.uptime !== undefined ? Math.round(peer.uptime * 100) : null);
+    const scoreStr = score !== null ? `${score}%` : '?';
+    const uptime = uptimeString(peer.uptime_seconds || peer.uptime);
+    const scoreColor = score === null ? C.dim : score >= 80 ? C.green : score >= 50 ? C.yellow : C.red;
+
+    console.log(
+      `  ${C.bright}│${C.reset} ${C.dim}${num}${C.reset}  ${addr} ${tier.padEnd(6)} ${scoreColor}${(scoreStr + '%').padEnd(7)}${C.reset} ${C.dim}${uptime}${C.reset} ${C.bright}│${C.reset}`
+    );
+  });
+
+  if (peers.length > 50) {
+    console.log(`  ${C.bright}│${C.reset}  ${C.dim}... and ${peers.length - 50} more peers (use --json for full list)${C.reset}`.padEnd(80) + `${C.bright}│${C.reset}`);
+  }
+
+  console.log(`  ${C.bright}└────────────────────────────────────────────────────────────────────────┘${C.reset}`);
+  console.log();
+  console.log(`  ${C.dim}Total peers: ${peers.length}${C.reset}`);
+  console.log();
+}
+
+function renderEpoch(epochData, rpc) {
+  console.log();
+  console.log(`${C.bright}${C.cyan}── Epoch / Consensus ────────────────────────────────────────${C.reset}`);
+  console.log(`  ${C.dim}RPC: ${rpc}${C.reset}`);
+  console.log();
+
+  if (!epochData) {
+    console.log(`  ${C.yellow}⚠ Epoch information not available.${C.reset}`);
+    console.log(`  ${C.dim}  Is your validator fully synced?${C.reset}`);
+    console.log();
+    return;
+  }
+
+  const t = (label, val) => console.log(`  ${C.dim}${label}:${C.reset}  ${val !== undefined && val !== null ? C.bright + val : C.dim + 'N/A'}${C.reset}`);
+
+  console.log(`  ${C.bright}┌─────────────────────────────────────────────────────┐${C.reset}`);
+  console.log(`  ${C.bright}│${C.reset}  ${C.cyan}Epoch${C.reset}${' '.repeat(45)}${C.bright}│${C.reset}`);
+  const ep = epochData.epoch !== undefined ? epochData.epoch : '?';
+  console.log(`  ${C.bright}│${C.reset}  ${C.green}${(ep + '').padEnd(53)}${C.reset}${C.bright}│${C.reset}`);
+  console.log(`  ${C.bright}├${C.reset}${'─'.repeat(58)}${C.bright}│${C.reset}`);
+
+  if (epochData.slots_in_epoch !== undefined) {
+    console.log(`  ${C.bright}│${C.reset}  ${C.dim}Slots in epoch${C.reset}`.padEnd(53) + `${C.bright}│${C.reset}`);
+    console.log(`  ${C.bright}│${C.reset}  ${C.bright}${formatNumber(epochData.slots_in_epoch).padEnd(53)}${C.reset}${C.bright}│${C.reset}`);
+  }
+
+  if (epochData.slot_index !== undefined) {
+    console.log(`  ${C.bright}│${C.reset}  ${C.dim}Current slot in epoch${C.reset}`.padEnd(53) + `${C.bright}│${C.reset}`);
+    const progress = epochData.slots_in_epoch > 0
+      ? `${epochData.slot_index} / ${epochData.slots_in_epoch} (${((epochData.slot_index / epochData.slots_in_epoch) * 100).toFixed(1)}%)`
+      : `${epochData.slot_index}`;
+    console.log(`  ${C.bright}│${C.reset}  ${C.bright}${progress.padEnd(53)}${C.reset}${C.bright}│${C.reset}`);
+  }
+
+  if (epochData.absolute_slot !== undefined) {
+    console.log(`  ${C.bright}│${C.reset}  ${C.dim}Absolute slot${C.reset}`.padEnd(53) + `${C.bright}│${C.reset}`);
+    console.log(`  ${C.bright}│${C.reset}  ${C.bright}${formatNumber(epochData.absolute_slot).padEnd(53)}${C.reset}${C.bright}│${C.reset}`);
+  }
+
+  if (epochData.block_height !== undefined) {
+    console.log(`  ${C.bright}│${C.reset}  ${C.dim}Block height${C.reset}`.padEnd(53) + `${C.bright}│${C.reset}`);
+    console.log(`  ${C.bright}│${C.reset}  ${C.bright}${formatNumber(epochData.block_height).padEnd(53)}${C.reset}${C.bright}│${C.reset}`);
+  }
+
+  if (epochData.epoch_schedule) {
+    const es = epochData.epoch_schedule;
+    if (es.first_normal_epoch !== undefined) {
+      console.log(`  ${C.bright}│${C.reset}  ${C.dim}First normal epoch${C.reset}`.padEnd(53) + `${C.bright}│${C.reset}`);
+      console.log(`  ${C.bright}│${C.reset}  ${C.bright}${es.first_normal_epoch.padEnd(53)}${C.reset}${C.bright}│${C.reset}`);
+    }
+  }
+
+  console.log(`  ${C.bright}└─────────────────────────────────────────────────────┘${C.reset}`);
+  console.log();
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const opts = parseArgs();
+  const rpc = opts.rpc;
+
+  if (!opts.asJson) {
+    console.log(`\n${C.cyan}Querying Aether network...${C.reset} ${C.dim}(${rpc})${C.reset}\n`);
+  }
+
+  // Fetch all data in parallel
+  const [slot, blockHeight, validators, epochData, tps, supply] = await Promise.all([
+    getSlot(rpc),
+    getBlockHeight(rpc),
+    getValidators(rpc),
+    getEpoch(rpc),
+    getTPS(rpc),
+    getSupply(rpc),
+  ]);
+
+  const peerCount = Array.isArray(validators) ? validators.length : 0;
+
+  const data = {
+    slot,
+    blockHeight,
+    peerCount,
+    tps,
+    supply,
+    epochData,
+    validators,
+    rpc,
+    fetchedAt: new Date().toISOString(),
+  };
+
+  if (opts.asJson) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  if (opts.showPeers) {
+    renderPeers(validators, rpc);
+  } else if (opts.showEpoch) {
+    renderEpoch(epochData, rpc);
+  } else {
+    renderSummary(data, rpc);
+  }
+}
+
+module.exports = { main, networkCommand: main };
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`\n${C.red}✗ Network command failed:${C.reset} ${err.message}`);
+    console.error(`  ${C.dim}Check that your validator is running and RPC is accessible.${C.reset}`);
+    console.error(`  ${C.dim}Set custom RPC: AETHER_RPC=http://your-rpc-url${C.reset}\n`);
+    process.exit(1);
+  });
+}

package/commands/wallet.js

@@ -737,29 +737,6 @@ async function stakeWallet(rl) {
     return;
   }
 
-  // Derive the full wallet object (secret key needed for signing)
-  let keyPair;
-  try {
-    // Re-derive from public key stored in wallet file
-    // The secret key isn't stored — we'd need the mnemonic to re-derive.
-    // For signing, the CLI requires the wallet to have been created/imported in this session.
-    // We use bs58 decoded publicKey + nacl key derivation from stored entropy.
-    // Since we store only publicKey, we need the secret key for signing.
-    // Workaround: accept a --sign-with <secretkeybase58> flag for now, or
-    // require the wallet to be "active" via a session.
-    // For simplicity, derive a keypair using a stored seed phrase approach.
-    // The wallet.json only has public_key. We need nacl sign keypair.
-    // Let's require the secret key be provided for stake/transfer.
-    console.log(`  ${C.red}✗ Signing requires the wallet secret key.${C.reset}`);
-    console.log(`  ${C.dim}The wallet must be created/imported in this session to access the secret key.${C.reset}`);
-    console.log(`  ${C.dim}For staking, use the JS SDK's offline signing flow instead.${C.reset}`);
-    console.log(`  ${C.dim}See: aether-cli sdk js${C.reset}\n`);
-    return;
-  } catch (e) {
-    console.log(`  ${C.red}✗ Failed to load wallet keys: ${e.message}${C.reset}\n`);
-    return;
-  }
-
   // Prompt for missing values interactively
   if (!validator) {
     console.log(`  ${C.cyan}Enter validator address:${C.reset}`);
@@ -784,6 +761,30 @@ async function stakeWallet(rl) {
   console.log(`  ${C.green}★${C.reset} Amount:    ${C.bright}${amount} AETH${C.reset} (${lamports} lamports)`);
   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}`);
+    console.log(`  ${C.dim}Check your passphrase and try again.${C.reset}\n`);
+    return;
+  }
+
   const confirm = await question(rl, `  ${C.yellow}Confirm stake? [y/N]${C.reset} > ${C.reset}`);
   if (!confirm.trim().toLowerCase().startsWith('y')) {
     console.log(`  ${C.dim}Cancelled.${C.reset}\n`);
@@ -894,6 +895,30 @@ async function transferWallet(rl) {
   console.log(`  ${C.green}★${C.reset} Amount:    ${C.bright}${amount} AETH${C.reset} (${lamports} lamports)`);
   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}`);
+    console.log(`  ${C.dim}Check your passphrase and try again.${C.reset}\n`);
+    return;
+  }
+
   const confirm = await question(rl, `  ${C.yellow}Confirm transfer? [y/N]${C.reset} > ${C.reset}`);
   if (!confirm.trim().toLowerCase().startsWith('y')) {
     console.log(`  ${C.dim}Cancelled.${C.reset}\n`);
@@ -938,6 +963,149 @@ async function transferWallet(rl) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// TX HISTORY
+// Fetch and display recent transactions for an address
+// ---------------------------------------------------------------------------
+
+async function txHistory(rl) {
+  console.log(`\n${C.bright}${C.cyan}── Transaction History ────────────────────────────────────${C.reset}\n`);
+
+  const args = process.argv.slice(4);
+  let address = null;
+  let limit = 20;
+  let asJson = false;
+
+  const addrIdx = args.findIndex((a) => a === '--address' || a === '-a');
+  if (addrIdx !== -1 && args[addrIdx + 1]) {
+    address = args[addrIdx + 1];
+  }
+
+  const limitIdx = args.findIndex((a) => a === '--limit' || a === '-l');
+  if (limitIdx !== -1 && args[limitIdx + 1]) {
+    limit = parseInt(args[limitIdx + 1], 10);
+    if (isNaN(limit) || limit < 1 || limit > 100) {
+      console.log(`  ${C.red}✗ --limit must be between 1 and 100.${C.reset}\n`);
+      return;
+    }
+  }
+
+  asJson = args.includes('--json') || args.includes('-j');
+
+  if (!address) {
+    const cfg = loadConfig();
+    address = cfg.defaultWallet;
+  }
+
+  if (!address) {
+    console.log(`  ${C.red}✗ No wallet address specified and no default wallet set.${C.reset}`);
+    console.log(`  ${C.dim}Usage: aether tx history --address <addr> [--limit 20] [--json]${C.reset}\n`);
+    return;
+  }
+
+  const rpcUrl = getDefaultRpc();
+  const rawAddr = address.startsWith('ATH') ? address.slice(3) : address;
+
+  if (!asJson) {
+    console.log(`  ${C.green}★${C.reset} Address: ${C.bright}${address}${C.reset}`);
+    console.log(`  ${C.dim}  RPC: ${rpcUrl}  Limit: ${limit}${C.reset}`);
+    console.log();
+  }
+
+  try {
+    // Fetch account info first (for context)
+    const account = await httpRequest(rpcUrl, `/v1/account/${rawAddr}`);
+
+    // Fetch transactions for this address
+    const txs = await httpRequest(rpcUrl, `/v1/tx?address=${encodeURIComponent(rawAddr)}&limit=${limit}`);
+
+    if (asJson) {
+      const out = {
+        address,
+        rpc: rpcUrl,
+        account: account && !account.error ? {
+          lamports: account.lamports,
+          owner: account.owner,
+        } : null,
+        transactions: txs && !txs.error ? (Array.isArray(txs) ? txs : txs.transactions || []) : [],
+        fetched_at: new Date().toISOString(),
+      };
+      console.log(JSON.stringify(out, null, 2));
+      return;
+    }
+
+    if (!account || account.error) {
+      console.log(`  ${C.yellow}⚠ Account not found on chain.${C.reset}`);
+    } else {
+      console.log(`  ${C.green}✓ Balance:${C.reset} ${C.bright}${formatAether(account.lamports || 0)}${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}`);
+      }
+      console.log();
+    }
+
+    if (!txs || txs.error) {
+      console.log(`  ${C.yellow}⚠ No transaction history available.${C.reset}`);
+      console.log(`  ${C.dim}  RPC response: ${JSON.stringify(txs?.error || txs)}${C.reset}`);
+      console.log(`  ${C.dim}  (New wallets with 0 txs will return empty results)${C.reset}\n`);
+      return;
+    }
+
+    const txList = Array.isArray(txs) ? txs : txs.transactions || [];
+    console.log(`  ${C.bright}Recent Transactions (${txList.length})${C.reset}\n`);
+
+    if (txList.length === 0) {
+      console.log(`  ${C.dim}  No transactions found for this address.${C.reset}`);
+      console.log(`  ${C.dim}  This is normal for new wallets.${C.reset}\n`);
+      return;
+    }
+
+    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,
+    };
+
+    for (const tx of txList) {
+      const txType = tx.tx_type || tx.type || 'Unknown';
+      const color = typeColors[txType] || C.reset;
+      const ts = tx.timestamp
+        ? new Date(tx.timestamp * 1000).toISOString()
+        : 'unknown';
+      const sig = tx.signature || tx.id || tx.tx_signature || '—';
+      const sigShort = sig.length > 20 ? sig.slice(0, 8) + '…' + sig.slice(-8) : sig;
+
+      console.log(`  ${C.dim}┌─ ${ts}${C.reset}`);
+      console.log(`  │  ${C.bright}${color}${txType}${C.reset}  ${C.dim}sig:${C.reset} ${sigShort}`);
+      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 (d.stake_account) console.log(`  │  ${C.dim}  stake_acct: ${d.stake_account}${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();
+    }
+    console.log();
+  } catch (err) {
+    console.log(`  ${C.red}✗ Failed to fetch transaction history:${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`);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Main dispatcher
 // ---------------------------------------------------------------------------
@@ -967,6 +1135,8 @@ async function walletCommand() {
       await stakeWallet(rl);
     } else if (subcmd === 'transfer') {
       await transferWallet(rl);
+    } else if (subcmd === 'history' || subcmd === 'tx') {
+      await txHistory(rl);
     } else {
       console.log(`\n  ${C.red}Unknown wallet subcommand:${C.reset} ${subcmd}`);
       console.log(`\n  Usage:`);
@@ -978,6 +1148,7 @@ async function walletCommand() {
       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 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();
       process.exit(1);
     }

package/index.js

@@ -14,6 +14,7 @@ const { monitorLoop } = require('./commands/monitor');
 const { logsCommand } = require('./commands/logs');
 const { sdkCommand } = require('./commands/sdk');
 const { walletCommand } = require('./commands/wallet');
+const { networkCommand } = require('./commands/network');
 const readline = require('readline');
 
 // CLI version
@@ -55,10 +56,11 @@ async function showMenu() {
   console.log('  ' + TIER_COLORS.FULL + '3)' + TIER_COLORS.reset + '  📊  Monitor — Watch live validator stats');
   console.log('  ' + TIER_COLORS.FULL + '4)' + TIER_COLORS.reset + '  📋  Logs   — Tail and colourise validator logs');
   console.log('  ' + TIER_COLORS.FULL + '5)' + TIER_COLORS.reset + '  📦  SDK    — Get SDK links and install tools');
-  console.log('  ' + TIER_COLORS.FULL + '6)' + TIER_COLORS.reset + '  ❓  Help   — Show all commands\n');
+  console.log('  ' + TIER_COLORS.FULL + '6)' + TIER_COLORS.reset + '  🌐  Network — Aether network status (slot, peers, TPS)');
+  console.log('  ' + TIER_COLORS.FULL + '7)' + TIER_COLORS.reset + '  ❓  Help   — Show all commands\n');
   console.log('  ' + TIER_COLORS.reset + '  Type a number or command name. Press Ctrl+C to exit.\n');
 
-  const VALID_CHOICES = ['1', '2', '3', '4', '5', '6', 'doctor', 'init', 'monitor', 'logs', 'sdk', 'help'];
+  const VALID_CHOICES = ['1', '2', '3', '4', '5', '6', '7', 'doctor', 'init', 'monitor', 'logs', 'sdk', 'network', 'help'];
 
   while (true) {
     const answer = (await prompt(`  > `)).trim().toLowerCase();
@@ -98,7 +100,14 @@ async function showMenu() {
       return;
     }
 
-    if (answer === '6' || answer === 'help') {
+    if (answer === '6' || answer === 'network') {
+      rl.close();
+      const { networkCommand } = require('./commands/network');
+      networkCommand();
+      return;
+    }
+
+    if (answer === '7' || answer === 'help') {
       showHelp();
       console.log("  Press Ctrl+C to exit or select an option above.\n");
       continue;
@@ -182,6 +191,33 @@ const COMMANDS = {
       process.argv = originalArgv;
     },
   },
+  tx: {
+    description: 'Transaction history — aether tx history --address <addr> [--limit 20] [--json]',
+    handler: () => {
+      const { walletCommand } = require('./commands/wallet');
+      const originalArgv = process.argv;
+      process.argv = [...originalArgv.slice(0, 2), 'wallet', 'history', ...originalArgv.slice(3)];
+      walletCommand();
+      process.argv = originalArgv;
+    },
+  },
+  network: {
+    description: 'Aether network status — slot, block height, peers, TPS, epoch info',
+    handler: () => {
+      const { networkCommand } = require('./commands/network');
+      networkCommand();
+    },
+  },
+  history: {
+    description: 'Transaction history for an address — alias for tx history',
+    handler: () => {
+      const { walletCommand } = require('./commands/wallet');
+      const originalArgv = process.argv;
+      process.argv = [...originalArgv.slice(0, 2), 'wallet', 'history', ...originalArgv.slice(3)];
+      walletCommand();
+      process.argv = originalArgv;
+    },
+  },
   validator: {
     description: 'Validator node management',
     handler: () => {
@@ -249,6 +285,10 @@ Validator CLI v${VERSION}
   console.log('  aether-cli monitor             # Real-time validator dashboard');
   console.log('  aether-cli validator start     # Start validator node');
   console.log('  aether-cli validator status    # Check validator status');
+  console.log('  aether-cli wallet balance      # Query AETH balance');
+  console.log('  aether-cli network             # Network status, peers, slot info');
+  console.log('  aether-cli network --peers     # Detailed peer list');
+  console.log('  aether-cli tx history          # Show transaction history');
   console.log('  aether-cli --version           # Show version');
   console.log('\nDocumentation: https://github.com/jelly-legs-ai/Jelly-legs-unsteady-workshop');
   console.log('Spec: docs/MINING_VALIDATOR_TOOLS.md\n');
@@ -260,13 +300,10 @@ Validator CLI v${VERSION}
 function parseArgs() {
   const args = process.argv.slice(2);
 
-  // Handle flags
+  // Handle version flag
   if (args.includes('--version') || args.includes('-v')) {
     return 'version';
   }
-  if (args.includes('--help') || args.includes('-h')) {
-    return 'help';
-  }
 
   // No args → interactive menu
   if (args.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-hub",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "AeTHer Validator CLI — tiered validators (Full/Lite/Observer), system checks, onboarding, and node management",
   "main": "index.js",
   "bin": {