aether-hub 1.1.2 → 1.1.4

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/init.js

@@ -501,7 +501,7 @@ async function connectTestnet(rl, tier = 'full') {
       rl.close();
       
       const validatorStart = require('./validator-start');
-      validatorStart.validatorStart(tier);
+      validatorStart.validatorStart({ testnet: true, tier });
       return true;
     }
   } catch (err) {

package/commands/validator-start.js

@@ -64,8 +64,9 @@ function findValidatorBinary() {
 
 /**
  * Parse command line args for validator-start
+ * @param {Object} overrideOptions - Options passed directly (e.g. from init.js)
  */
-function parseArgs() {
+function parseArgs(overrideOptions = {}) {
   const args = process.argv.slice(3); // Skip 'aether-cli validator start'
   
   const options = {
@@ -75,6 +76,7 @@ function parseArgs() {
     identity: null,
     verbose: false,
     tier: 'full',
+    ...overrideOptions, // Allow init.js to pass testnet/tier directly
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -121,7 +123,10 @@ ${colors.cyan}╚═════════════════════
   `);
   
   console.log(`  ${colors.bright}Network:${colors.reset}`);
-  console.log(`    Mode:      ${options.testnet ? colors.yellow + 'TESTNET' : colors.green + 'MAINNET (not implemented)'}`);
+  const modeStr = options.testnet
+    ? colors.yellow + 'TESTNET'
+    : colors.red + 'MAINNET';
+  console.log(`    Mode:      ${modeStr}`);
   console.log(`    Tier:      ${tierLabel}`);
   console.log(`    RPC:       http://${options.rpcAddr}`);
   console.log(`    P2P:       ${options.p2pAddr}`);
@@ -136,16 +141,38 @@ ${colors.cyan}╚═════════════════════
  */
 function buildValidator() {
   const { execSync } = require('child_process');
+  const platform = os.platform();
+  const isWindows = platform === 'win32';
   const workspaceRoot = path.join(__dirname, '..', '..');
   const repoPath = path.join(workspaceRoot, 'Jelly-legs-unsteady-workshop');
   
   console.log(`  ${colors.cyan}Building aether-validator...${colors.reset}`);
   
   try {
-    execSync('cargo build --bin aether-validator', {
+    // Use full cargo path on Windows to avoid spawnSync ENOENT
+    const cargoPaths = isWindows
+      ? [
+          path.join(process.env.USERPROFILE || '', '.cargo', 'bin', 'cargo.exe'),
+          path.join(process.env.LOCALAPPDATA || '', 'Rust', 'bin', 'cargo.exe'),
+          'C:\\Users\\RM_Ga\\.cargo\\bin\\cargo.exe',
+          'cargo',
+        ]
+      : ['cargo'];
+    
+    let cargoCmd = 'cargo';
+    for (const cp of cargoPaths) {
+      if (cp === 'cargo' || fs.existsSync(cp)) {
+        cargoCmd = cp;
+        break;
+      }
+    }
+    
+    console.log(`  ${colors.cyan}Running: ${cargoCmd} build --release --package aether-validator${colors.reset}`);
+    
+    // Use execSync WITHOUT shell:true — avoids Windows spawnSync cmd.exe ENOENT
+    execSync(`${cargoCmd} build --release --package aether-validator`, {
       cwd: repoPath,
       stdio: 'inherit',
-      shell: true,
     });
     
     // Re-check for binary
@@ -165,18 +192,24 @@ function buildValidator() {
 
 /**
  * Main validator start command
+ * @param {Object|null} options - { testnet?: boolean, tier?: string }
  */
-function validatorStart(overrideTier = null) {
-  const options = parseArgs();
+function validatorStart(options = {}) {
+  // Support both old string-style (tier only) and new object-style { testnet, tier }
+  const parsedArgs = parseArgs(typeof options === 'object' ? options : { tier: options });
+  const optionsObj = typeof options === 'object' ? options : {};
   
-  // Allow tier override from init.js
-  if (overrideTier) {
-    options.tier = overrideTier;
-  }
+  // Merge: explicit options override parseArgs defaults
+  const finalOptions = {
+    ...parsedArgs,
+    ...optionsObj,
+    tier: optionsObj.tier || parsedArgs.tier,
+    testnet: optionsObj.testnet !== undefined ? optionsObj.testnet : parsedArgs.testnet,
+  };
   
   let result = findValidatorBinary();
 
-  printBanner(options);
+  printBanner(finalOptions);
 
   // Handle missing binary
   if (result.type === 'missing') {
@@ -203,12 +236,12 @@ function validatorStart(overrideTier = null) {
         process.exit(1);
       }
       result = built;
-      startValidatorProcess(result, options);
+      startValidatorProcess(result, finalOptions);
     });
     return;
   }
 
-  startValidatorProcess(result, options);
+  startValidatorProcess(result, finalOptions);
 }
 
 /**

package/commands/wallet.js

@@ -1106,6 +1106,143 @@ async function txHistory(rl) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// STAKE POSITIONS
+// Query and display current stake positions/delegations for a wallet
+// ---------------------------------------------------------------------------
+
+async function stakePositions(rl) {
+  console.log(`\n${C.bright}${C.cyan}── Stake Positions ──────────────────────────────────────${C.reset}\n`);
+
+  const args = process.argv.slice(4);
+  let address = null;
+  let asJson = 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');
+
+  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 stake-positions --address <addr> [--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}${C.reset}`);
+    console.log();
+  }
+
+  try {
+    // Fetch stake accounts for this address
+    const res = await httpRequest(rpcUrl, `/v1/stake?address=${encodeURIComponent(rawAddr)}`);
+
+    let stakeAccounts = [];
+    if (res && !res.error) {
+      stakeAccounts = Array.isArray(res) ? res : (res.accounts || res.stake_accounts || []);
+    }
+
+    if (asJson) {
+      const out = {
+        address,
+        rpc: rpcUrl,
+        stake_accounts: stakeAccounts.map(acc => ({
+          stake_account: acc.pubkey || acc.publicKey || acc.account,
+          validator: acc.validator || acc.voter || acc.vote_account,
+          stake_lamports: acc.stake_lamports || acc.lamports || 0,
+          stake_aeth: (acc.stake_lamports || acc.lamports || 0) / 1e9,
+          status: acc.status || acc.state || 'unknown',
+          activation_epoch: acc.activation_epoch,
+          deactivation_epoch: acc.deactivation_epoch,
+          rewards_earned: acc.rewards_earned || 0,
+        })),
+        total_staked_lamports: stakeAccounts.reduce((sum, acc) => sum + (acc.stake_lamports || acc.lamports || 0), 0),
+        fetched_at: new Date().toISOString(),
+      };
+      console.log(JSON.stringify(out, null, 2));
+      return;
+    }
+
+    if (!stakeAccounts || stakeAccounts.length === 0) {
+      console.log(`  ${C.yellow}⚠ No active stake positions found.${C.reset}`);
+      console.log(`  ${C.dim}  This wallet has not delegated to any validators.${C.reset}`);
+      console.log(`  ${C.dim}  Stake AETH with: ${C.cyan}aether stake --validator <addr> --amount <aeth>${C.reset}\n`);
+      return;
+    }
+
+    let totalStaked = 0;
+    let activeCount = 0;
+    let deactivatingCount = 0;
+    let inactiveCount = 0;
+
+    console.log(`  ${C.bright}Stake Positions (${stakeAccounts.length})${C.reset}\n`);
+
+    const statusColors = {
+      active: C.green,
+      activating: C.cyan,
+      deactivating: C.yellow,
+      inactive: C.dim,
+    };
+
+    for (const acc of stakeAccounts) {
+      const stakeAcct = acc.pubkey || acc.publicKey || acc.account || 'unknown';
+      const validator = acc.validator || acc.voter || acc.vote_account || 'unknown';
+      const lamports = acc.stake_lamports || acc.lamports || 0;
+      const aeth = lamports / 1e9;
+      const status = (acc.status || acc.state || 'unknown').toLowerCase();
+      const rewards = acc.rewards_earned || 0;
+
+      totalStaked += lamports;
+
+      if (status === 'active') activeCount++;
+      else if (status === 'deactivating' || status === 'deactivated') deactivatingCount++;
+      else inactiveCount++;
+
+      const statusColor = statusColors[status] || C.reset;
+      const shortAcct = stakeAcct.length > 20 ? stakeAcct.slice(0, 8) + '…' + stakeAcct.slice(-8) : stakeAcct;
+      const shortVal = validator.length > 20 ? validator.slice(0, 8) + '…' + validator.slice(-8) : validator;
+
+      console.log(`  ${C.dim}┌─ ${C.bright}${statusColor}${status.toUpperCase()}${C.reset}`);
+      console.log(`  │  ${C.dim}Stake acct:${C.reset} ${shortAcct}`);
+      console.log(`  │  ${C.dim}Validator:${C.reset}  ${shortVal}`);
+      console.log(`  │  ${C.dim}Staked:${C.reset}    ${C.bright}${aeth.toFixed(4)} AETH${C.reset} (${lamports.toLocaleString()} lamports)`);
+      if (rewards > 0) {
+        console.log(`  │  ${C.dim}Rewards:${C.reset}   ${C.green}+${(rewards / 1e9).toFixed(4)} AETH${C.reset}`);
+      }
+      if (acc.activation_epoch !== undefined) {
+        console.log(`  │  ${C.dim}Activated:${C.reset} epoch ${acc.activation_epoch}`);
+      }
+      if (acc.deactivation_epoch !== undefined) {
+        console.log(`  │  ${C.dim}Deactivates:${C.reset} epoch ${acc.deactivation_epoch}`);
+      }
+      console.log(`  ${C.dim}└${C.reset}`);
+      console.log();
+    }
+
+    console.log(`  ${C.bright}Summary:${C.reset}`);
+    console.log(`  ${C.dim}  Total staked:${C.reset} ${C.bright}${(totalStaked / 1e9).toFixed(4)} AETH${C.reset} (${totalStaked.toLocaleString()} lamports)`);
+    console.log(`  ${C.green}  ● Active:${C.reset} ${activeCount}  ${C.yellow}● Deactivating:${C.reset} ${deactivatingCount}  ${C.dim}● Inactive:${C.reset} ${inactiveCount}`);
+    console.log();
+
+  } catch (err) {
+    console.log(`  ${C.red}✗ Failed to fetch stake positions:${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`);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // UNSTAKE
 // Submit an Unstake transaction via POST /v1/tx to deactivate stake
@@ -1298,6 +1435,8 @@ async function walletCommand() {
       await balanceWallet(rl);
     } else if (subcmd === 'stake') {
       await stakeWallet(rl);
+    } else if (subcmd === 'stake-positions') {
+      await stakePositions(rl);
     } else if (subcmd === 'unstake') {
       await unstakeWallet(rl);
     } else if (subcmd === 'transfer') {
@@ -1314,6 +1453,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 stake-positions${C.reset} Show current stake delegations and rewards`);
       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`);

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');
 
@@ -187,6 +188,16 @@ const COMMANDS = {
       process.argv = originalArgv;
     },
   },
+  'stake-positions': {
+    description: 'Show current stake positions/delegations — aether stake-positions --address <addr> [--json]',
+    handler: () => {
+      const { walletCommand } = require('./commands/wallet');
+      const originalArgv = process.argv;
+      process.argv = [...originalArgv.slice(0, 2), 'wallet', 'stake-positions', ...originalArgv.slice(3)];
+      walletCommand();
+      process.argv = originalArgv;
+    },
+  },
   unstake: {
     description: 'Unstake AETH — deactivate a stake account — aether unstake --account <stakeAcct> [--amount <aeth>]',
     handler: () => {
@@ -283,6 +294,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.2",
+  "version": "1.1.4",
   "description": "AeTHer Validator CLI — tiered validators (Full/Lite/Observer), system checks, onboarding, and node management",
   "main": "index.js",
   "bin": {