aether-hub 1.1.1 → 1.1.3

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

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 { emergencyCommand } = require('./commands/emergency');
 const readline = require('readline');
 
 // CLI version
@@ -186,6 +187,26 @@ 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: () => {
+      const { walletCommand } = require('./commands/wallet');
+      const originalArgv = process.argv;
+      process.argv = [...originalArgv.slice(0, 2), 'wallet', 'unstake', ...originalArgv.slice(3)];
+      walletCommand();
+      process.argv = originalArgv;
+    },
+  },
   transfer: {
     description: 'Transfer AETH to another address — aether transfer --to <addr> --amount <aeth>',
     handler: () => {
@@ -278,6 +299,13 @@ const COMMANDS = {
       validatorsListCommand();
     },
   },
+  emergency: {
+    description: 'Emergency response & network alerts — status, monitor, check, alert, failover, history',
+    handler: () => {
+      const { emergencyCommand } = require('./commands/emergency');
+      emergencyCommand();
+    },
+  },
   help: {
     description: 'Show this help message',
     handler: showHelp,

package/package.json

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