aether-hub 1.1.3 → 1.1.5

package/commands/account.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+/**
+ * aether-cli account
+ *
+ * Query detailed on-chain account data for any address.
+ * Shows lamports, owner, executable, rent epoch, and program-owned account keys.
+ *
+ * Usage:
+ *   aether account --address <addr>         Full account dump
+ *   aether account --address <addr> --json  JSON output for scripting
+ *   aether account --address <addr> --data  Show raw account data as base64/hex
+ *
+ * Requires AETHER_RPC env var (default: http://127.0.0.1:8899)
+ */
+
+const http = require('http');
+const https = require('https');
+const bs58 = require('bs58').default;
+
+// ANSI colours
+const C = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+};
+
+// ---------------------------------------------------------------------------
+// HTTP helpers
+// ---------------------------------------------------------------------------
+
+function httpRequest(rpcUrl, path) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, rpcUrl);
+    const lib = url.protocol === 'https:' ? https : http;
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'GET',
+      timeout: 8000,
+      headers: { 'Content-Type': 'application/json' },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch { resolve({ raw: data }); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
+    req.end();
+  });
+}
+
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+}
+
+function formatAether(lamports) {
+  const aeth = lamports / 1e9;
+  if (aeth === 0) return '0 AETH';
+  return aeth.toFixed(4).replace(/\.?0+$/, '') + ' AETH';
+}
+
+// ---------------------------------------------------------------------------
+// Parse args
+// ---------------------------------------------------------------------------
+
+function parseArgs() {
+  return process.argv.slice(3); // [node, index.js, account, ...]
+}
+
+function findArg(args, ...flags) {
+  for (const flag of flags) {
+    const idx = args.indexOf(flag);
+    if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('-')) {
+      return { value: args[idx + 1], idx };
+    }
+  }
+  return null;
+}
+
+function parseBoolArg(args, ...flags) {
+  return flags.some(f => args.includes(f));
+}
+
+// ---------------------------------------------------------------------------
+// Format helpers
+// ---------------------------------------------------------------------------
+
+function formatPubkey(key) {
+  if (!key) return '—';
+  if (Array.isArray(key)) {
+    // base64-like or raw bytes → treat as public key bytes
+    if (key.length === 32) return 'ATH' + bs58.encode(Buffer.from(key.slice(0, 32)));
+    return 'ATH' + bs58.encode(Buffer.from(key));
+  }
+  if (typeof key === 'string') {
+    if (key.startsWith('ATH')) return key;
+    // Assume base58
+    try { return 'ATH' + bs58.encode(bs58.decode(key)); }
+    catch { return key.substring(0, 16) + '...'; }
+  }
+  return String(key).substring(0, 16);
+}
+
+function base64ToHex(b64) {
+  try {
+    const buf = Buffer.from(b64, 'base64');
+    return buf.toString('hex');
+  } catch {
+    return b64;
+  }
+}
+
+function formatData(data) {
+  if (!data) return null;
+  if (typeof data === 'string') return data;
+  if (Array.isArray(data)) {
+    // raw bytes → hex
+    return Buffer.from(data).toString('hex');
+  }
+  return JSON.stringify(data);
+}
+
+// ---------------------------------------------------------------------------
+// Main account query
+// ---------------------------------------------------------------------------
+
+async function accountCommand() {
+  const args = parseArgs();
+
+  // Parse flags
+  const addrArg = findArg(args, '--address', '-a');
+  const asJson = parseBoolArg(args, '--json', '-j');
+  const showData = parseBoolArg(args, '--data', '-d');
+  const rpcArg = findArg(args, '--rpc', '-r');
+  const rpcUrl = rpcArg ? rpcArg.value : getDefaultRpc();
+
+  if (!addrArg) {
+    console.log(`\n  ${C.red}✗ Missing --address flag.${C.reset}`);
+    console.log(`\n  ${C.cyan}Usage:${C.reset}`);
+    console.log(`    ${C.cyan}aether account --address <addr>${C.reset}         Show account details`);
+    console.log(`    ${C.cyan}aether account --address <addr> --json${C.reset}   JSON output`);
+    console.log(`    ${C.cyan}aether account --address <addr> --data${C.reset}    Show raw account data`);
+    console.log(`    ${C.cyan}aether account --address <addr> --rpc <url>${C.reset}  Use custom RPC\n`);
+    process.exit(1);
+  }
+
+  const rawAddress = addrArg.value;
+  const address = rawAddress.startsWith('ATH') ? rawAddress : rawAddress;
+  const apiAddress = rawAddress.startsWith('ATH') ? rawAddress.slice(3) : rawAddress;
+
+  if (!asJson) {
+    console.log(`\n${C.bright}${C.cyan}── Account Info ──────────────────────────────────────────${C.reset}\n`);
+    console.log(`  ${C.green}★${C.reset} Address: ${C.bright}${address}${C.reset}`);
+    console.log(`  ${C.dim}  RPC: ${rpcUrl}${C.reset}`);
+    console.log();
+  }
+
+  try {
+    const account = await httpRequest(rpcUrl, `/v1/account/${apiAddress}`);
+
+    if (!account || account.error) {
+      if (asJson) {
+        console.log(JSON.stringify({ address, error: account?.error || 'Account not found' }, null, 2));
+      } else {
+        console.log(`  ${C.yellow}⚠ Account not found on chain or RPC error.${C.reset}`);
+        console.log(`  ${C.dim}  This is normal for addresses with no on-chain account.${C.reset}`);
+        console.log(`  ${C.dim}  RPC response: ${JSON.stringify(account?.error || account)}${C.reset}\n`);
+      }
+      process.exit(1);
+    }
+
+    const lamports = account.lamports || account.lamports === 0 ? account.lamports : 0;
+    const owner = account.owner || null;
+    const executable = account.executable || false;
+    const rentEpoch = account.rent_epoch;
+    const data = account.data;
+    const dataLen = data ? (Array.isArray(data) ? data.length : typeof data === 'string' ? data.length : 0) : 0;
+
+    if (asJson) {
+      let ownerStr = null;
+      if (owner) {
+        if (Array.isArray(owner)) {
+          ownerStr = 'ATH' + bs58.encode(Buffer.from(owner.slice(0, 32)));
+        } else if (typeof owner === 'string') {
+          ownerStr = owner.startsWith('ATH') ? owner : 'ATH' + bs58.encode(bs58.decode(owner));
+        } else {
+          ownerStr = String(owner);
+        }
+      }
+
+      console.log(JSON.stringify({
+        address,
+        rpc: rpcUrl,
+        lamports,
+        lamports_formatted: formatAether(lamports),
+        owner: ownerStr,
+        executable,
+        rent_epoch: rentEpoch,
+        data_size: dataLen,
+        data: showData ? formatData(data) : null,
+        fetched_at: new Date().toISOString(),
+      }, null, 2));
+      return;
+    }
+
+    // Human-readable output
+    console.log(`  ${C.green}✓${C.reset} Found on chain`);
+    console.log(`  ${C.dim}────────────────────────────────────────${C.reset}`);
+    console.log(`  ${C.dim}  Balance:${C.reset}     ${C.bright}${formatAether(lamports)}${C.reset}  (${lamports.toLocaleString()} lamports)`);
+
+    if (owner) {
+      let ownerStr;
+      if (Array.isArray(owner)) {
+        ownerStr = 'ATH' + bs58.encode(Buffer.from(owner.slice(0, 32)));
+      } else if (typeof owner === 'string') {
+        ownerStr = owner.startsWith('ATH') ? owner : 'ATH' + bs58.encode(bs58.decode(owner));
+      } else {
+        ownerStr = String(owner);
+      }
+      console.log(`  ${C.dim}  Owner:${C.reset}       ${C.cyan}${ownerStr}${C.reset}`);
+    }
+
+    console.log(`  ${C.dim}  Executable:${C.reset} ${C.bright}${(executable ? 'Yes' : 'No')}${C.reset}`);
+    if (rentEpoch !== undefined) {
+      console.log(`  ${C.dim}  Rent epoch:${C.reset} ${rentEpoch}`);
+    }
+
+    if (dataLen > 0) {
+      console.log(`  ${C.dim}  Data size:${C.reset}  ${C.bright}${dataLen} bytes${C.reset}`);
+    } else {
+      console.log(`  ${C.dim}  Data size:${C.reset}  0 bytes`);
+    }
+
+    if (showData && data) {
+      console.log();
+      console.log(`  ${C.dim}  Raw data (hex):${C.reset}`);
+      const hex = formatData(data);
+      // Pretty-print in 32-byte chunks
+      const chunks = hex.match(/.{1,64}/g) || [];
+      for (let i = 0; i < chunks.length; i++) {
+        const offset = (i * 32).toString(16).padStart(8, '0');
+        console.log(`    ${C.dim}${offset}:${C.reset} ${chunks[i]}`);
+      }
+    }
+
+    console.log();
+    console.log(`  ${C.dim}────────────────────────────────────────${C.reset}`);
+
+    // Additional context: try to determine account type
+    let accountType = 'Unknown';
+    if (owner) {
+      const ownerStr = Array.isArray(owner)
+        ? bs58.encode(Buffer.from(owner.slice(0, 32)))
+        : (typeof owner === 'string' && !owner.startsWith('ATH') ? owner : '');
+      // Known program IDs (these are common Aether program identifiers)
+      const knownPrograms = {
+        'STAKE': 'Stake Program',
+        'SYSTEM': 'System Program',
+        'VOTE': 'Vote Program',
+        'TOKEN': 'Token Program',
+        'MEMO': 'Memo Program',
+      };
+      const prog = knownPrograms[ownerStr.toUpperCase()];
+      if (prog) accountType = prog;
+      else if (executable) accountType = 'Executable Program';
+      else if (dataLen === 0) accountType = 'Empty Account (no data)';
+      else accountType = 'Data Account';
+    }
+
+    console.log(`  ${C.dim}  Account type:${C.reset} ${C.bright}${accountType}${C.reset}`);
+    console.log();
+    console.log(`  ${C.dim}  Fetch via API:${C.reset} GET ${rpcUrl}/v1/account/${apiAddress}`);
+    console.log();
+
+  } catch (err) {
+    if (asJson) {
+      console.log(JSON.stringify({ address, error: err.message }, null, 2));
+    } else {
+      console.log(`  ${C.red}✗ Failed to fetch account:${C.reset} ${err.message}`);
+      console.log(`  ${C.dim}  Is your validator running? RPC: ${rpcUrl}${C.reset}`);
+      console.log(`  ${C.dim}  Set custom RPC: AETHER_RPC=https://your-rpc-url${C.reset}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Export & run
+// ---------------------------------------------------------------------------
+
+module.exports = { accountCommand };
+
+if (require.main === module) {
+  accountCommand();
+}

package/commands/wallet.js

@@ -1107,6 +1107,100 @@ async function txHistory(rl) {
 }
 
 // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// EXPORT WALLET
+// Export wallet data for backup — public data by default, mnemonic with --mnemonic flag
+// ---------------------------------------------------------------------------
+
+async function exportWallet(rl) {
+  console.log(`\n${C.bright}${C.cyan}── Wallet Export ─────────────────────────────────────────${C.reset}\n`);
+
+  const args = process.argv.slice(4);
+  let address = null;
+  let asJson = false;
+  let includeMnemonic = false;
+
+  const addrIdx = args.findIndex((a) => a === '--address' || a === '-a');
+  if (addrIdx !== -1 && args[addrIdx + 1]) {
+    address = args[addrIdx + 1];
+  }
+
+  asJson = args.includes('--json') || args.includes('-j');
+  includeMnemonic = args.includes('--mnemonic') || args.includes('-m');
+
+  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 wallet export --address <addr> [--mnemonic] [--json]${C.reset}\n`);
+    return;
+  }
+
+  const walletData = loadWallet(address);
+  if (!walletData) {
+    console.log(`  ${C.red}✗ Wallet not found:${C.reset} ${address}`);
+    console.log(`  ${C.dim}  Available wallets: ${C.cyan}aether wallet list${C.reset}\n`);
+    return;
+  }
+
+  const exportData = {
+    version: walletData.version || 1,
+    address: walletData.address,
+    public_key: walletData.public_key,
+    derivation_path: walletData.derivation_path,
+    created_at: walletData.created_at,
+    source: 'aether-cli',
+  };
+
+  // Mnemonic export requires interactive confirmation for security
+  if (includeMnemonic) {
+    console.log(`  ${C.yellow}⚠ WARNING: You are about to export your SECRET MNEMONIC.${C.reset}`);
+    console.log(`  ${C.dim}  Anyone with this phrase can access your funds.${C.reset}\n`);
+    const confirmed = await question(rl, `  Type ${C.bright}EXPORT${C.reset} to confirm: `);
+    if (confirmed.trim().toUpperCase() !== 'EXPORT') {
+      console.log(`\n  ${C.dim}Aborted. Mnemonic not exported.${C.reset}\n`);
+      return;
+    }
+    console.log(`  ${C.green}✓ Confirmed${C.reset}\n`);
+
+    // Re-derive mnemonic from keypair is NOT possible — we must ask for it
+    console.log(`  ${C.dim}The CLI cannot retrieve your mnemonic from the stored keypair.${C.reset}`);
+    console.log(`  ${C.dim}If you have a backup of your mnemonic, enter it below to include it.${C.reset}`);
+    console.log(`  ${C.dim}Otherwise, press Enter to export public data only.${C.reset}\n`);
+    const mnemonicInput = await question(rl, `  ${C.cyan}Mnemonic (or Enter to skip):${C.reset} `);
+    const mnemonic = mnemonicInput.trim();
+    if (mnemonic && bip39.validateMnemonic(mnemonic)) {
+      exportData.mnemonic = mnemonic;
+    } else if (mnemonic) {
+      console.log(`  ${C.red}✗ Invalid mnemonic phrase. Skipping.${C.reset}`);
+    }
+  }
+
+  if (asJson) {
+    console.log(JSON.stringify(exportData, null, 2));
+    return;
+  }
+
+  // Human-readable output
+  console.log(`  ${C.green}★${C.reset} Wallet exported successfully\n`);
+  console.log(`  ${C.dim}Address:${C.reset}        ${exportData.address}`);
+  console.log(`  ${C.dim}Public key:${C.reset}     ${exportData.public_key}`);
+  console.log(`  ${C.dim}Derivation path:${C.reset} ${exportData.derivation_path}`);
+  console.log(`  ${C.dim}Created:${C.reset}        ${exportData.created_at ? new Date(exportData.created_at).toLocaleString() : 'unknown'}`);
+  if (exportData.mnemonic) {
+    console.log();
+    console.log(`  ${C.yellow}★ MNEMONIC (keep this secret!):${C.reset}`);
+    console.log(`  ${C.bright}${exportData.mnemonic}${C.reset}`);
+  }
+  console.log();
+  console.log(`  ${C.dim}Export saved to stdout in JSON format with:${C.reset}`);
+  console.log(`    ${C.cyan}aether wallet export --address ${address} --json${C.reset}`);
+  console.log();
+}
+
 // STAKE POSITIONS
 // Query and display current stake positions/delegations for a wallet
 // ---------------------------------------------------------------------------
@@ -1437,6 +1531,8 @@ async function walletCommand() {
       await stakeWallet(rl);
     } else if (subcmd === 'stake-positions') {
       await stakePositions(rl);
+    } else if (subcmd === 'export') {
+      await exportWallet(rl);
     } else if (subcmd === 'unstake') {
       await unstakeWallet(rl);
     } else if (subcmd === 'transfer') {
@@ -1449,6 +1545,7 @@ async function walletCommand() {
       console.log(`    ${C.cyan}aether wallet create${C.reset}   Create new or import wallet`);
       console.log(`    ${C.cyan}aether wallet list${C.reset}     List all wallets`);
       console.log(`    ${C.cyan}aether wallet import${C.reset}   Import wallet from mnemonic`);
+      console.log(`    ${C.cyan}aether wallet export${C.reset}     Export wallet data (pubkey, address) — --mnemonic to include phrase`);
       console.log(`    ${C.cyan}aether wallet default${C.reset}  Show/set default wallet`);
       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`);

package/index.js

@@ -19,6 +19,7 @@ const { networkCommand } = require('./commands/network');
 const { validatorsListCommand } = require('./commands/validators');
 const { delegationsCommand } = require('./commands/delegations');
 const { rewardsCommand } = require('./commands/rewards');
+const { accountCommand } = require('./commands/account');
 const { emergencyCommand } = require('./commands/emergency');
 const readline = require('readline');
 
@@ -207,6 +208,16 @@ const COMMANDS = {
       process.argv = originalArgv;
     },
   },
+  export: {
+    description: 'Export wallet data — aether export --address <addr> [--mnemonic] [--json]',
+    handler: () => {
+      const { walletCommand } = require('./commands/wallet');
+      const originalArgv = process.argv;
+      process.argv = [...originalArgv.slice(0, 2), 'wallet', 'export', ...originalArgv.slice(3)];
+      walletCommand();
+      process.argv = originalArgv;
+    },
+  },
   transfer: {
     description: 'Transfer AETH to another address — aether transfer --to <addr> --amount <aeth>',
     handler: () => {
@@ -293,6 +304,13 @@ const COMMANDS = {
       snapshotCommand();
     },
   },
+  account: {
+    description: 'Query on-chain account data — aether account --address <addr> [--json] [--data] [--rpc <url>]',
+    handler: () => {
+      const { accountCommand } = require('./commands/account');
+      accountCommand();
+    },
+  },
   validators: {
     description: 'List active validators — aether validators list [--tier full|lite|observer] [--json]',
     handler: () => {

package/package.json

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