aether-hub 1.2.6 → 1.2.7

package/commands/validator-info.js

@@ -634,7 +634,13 @@ async function main() {
   console.log();
 }
 
-main().catch(err => {
-  console.error(`\n${C.red}✗ Validator info failed:${C.reset} ${err.message}\n`);
-  process.exit(1);
-});
+// Export for module use
+module.exports = { validatorInfo: main };
+
+// Only run if called directly (not when required as module)
+if (require.main === module) {
+  main().catch(err => {
+    console.error(`\n${C.red}✗ Validator info failed:${C.reset} ${err.message}\n`);
+    process.exit(1);
+  });
+}

package/commands/validator-start.js

@@ -254,7 +254,7 @@ function startValidatorProcess({ type, path: binaryPath, inPath }, options) {
   if (options.testnet) {
     validatorArgs.push('--testnet');
   }
-  validatorArgs.push('--tier', options.tier);
+  validatorArgs.push('--tier', options.tier.toLowerCase());
   validatorArgs.push('--rpc-addr', options.rpcAddr);
   validatorArgs.push('--p2p-addr', options.p2pAddr);
   if (options.identity) {

package/commands/validator-status.js

@@ -3,9 +3,15 @@
  * 
  * Queries the validator's RPC endpoint and displays status information.
  * Shows slot height, peer count, block production, and epoch info.
+ * 
+ * Uses @jellylegsai/aether-sdk for real blockchain RPC calls.
  */
 
-const http = require('http');
+const path = require('path');
+
+// Import SDK for real blockchain RPC calls
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
 
 // ANSI colors
 const colors = {
@@ -19,54 +25,10 @@ const colors = {
 };
 
 /**
- * Make an RPC call to the validator
+ * Create SDK client
  */
-function rpcCall(url, method, params = []) {
-  return new Promise((resolve, reject) => {
-    const urlObj = new URL(url);
-    
-    const postData = JSON.stringify({
-      jsonrpc: '2.0',
-      id: 1,
-      method,
-      params,
-    });
-
-    const options = {
-      hostname: urlObj.hostname,
-      port: urlObj.port || 8899,
-      path: '/',
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(postData),
-      },
-    };
-
-    const req = http.request(options, (res) => {
-      let data = '';
-      res.on('data', (chunk) => data += chunk);
-      res.on('end', () => {
-        try {
-          const json = JSON.parse(data);
-          if (json.error) {
-            reject(new Error(json.error.message || JSON.stringify(json.error)));
-          } else {
-            resolve(json.result);
-          }
-        } catch (e) {
-          reject(new Error(`Invalid JSON response: ${data}`));
-        }
-      });
-    });
-
-    req.on('error', (e) => {
-      reject(new Error(`Connection failed: ${e.message}`));
-    });
-
-    req.write(postData);
-    req.end();
-  });
+function createClient(rpcUrl) {
+  return new aether.AetherClient({ rpcUrl });
 }
 
 /**
@@ -181,24 +143,25 @@ async function validatorStatus() {
   let epochInfo = {};
   let blockProduction = {};
 
+  const client = createClient(options.rpcUrl);
+
   try {
-    // Make parallel RPC calls
-    const [slot, blockHeight, transactionCount, epochInfoResult, blockProdResult] = await Promise.all([
-      rpcCall(options.rpcUrl, 'getSlot').catch(e => ({ error: e.message })),
-      rpcCall(options.rpcUrl, 'getBlockHeight').catch(e => ({ error: e.message })),
-      rpcCall(options.rpcUrl, 'getTransactionCount').catch(e => ({ error: e.message })),
-      rpcCall(options.rpcUrl, 'getEpochInfo').catch(e => ({})),
-      options.details ? rpcCall(options.rpcUrl, 'getBlockProduction').catch(e => ({})) : Promise.resolve({}),
+    // Make parallel RPC calls using SDK
+    const [slotResult, blockHeightResult, epochInfoResult, peersResult] = await Promise.all([
+      client.getSlot().catch(e => ({ error: e.message })),
+      client.getBlockHeight().catch(e => ({ error: e.message })),
+      client.getEpochInfo().catch(e => ({})),
+      client.getClusterPeers().catch(e => ([])),
     ]);
 
-    if (typeof slot === 'object' && slot.error) {
+    if (typeof slotResult === 'object' && slotResult.error) {
       if (options.json) {
-        console.log(JSON.stringify({ error: slot.error }, null, 2));
+        console.log(JSON.stringify({ error: slotResult.error }, null, 2));
         process.exit(1);
       }
       console.log();
       console.log(`  ${colors.red}❌ Cannot connect to validator${colors.reset}`);
-      console.log(`     ${colors.yellow}${slot.error}${colors.reset}`);
+      console.log(`     ${colors.yellow}${slotResult.error}${colors.reset}`);
       console.log();
       console.log(`  ${colors.bright}Start the validator first:${colors.reset}`);
       console.log(`    ${colors.cyan}aether-cli validator start${colors.reset}`);
@@ -206,26 +169,22 @@ async function validatorStatus() {
       process.exit(1);
     }
 
-    status.slot = typeof slot === 'number' ? slot : 0;
-    status.blockHeight = typeof blockHeight === 'number' ? blockHeight : status.slot;
-    status.transactionCount = typeof transactionCount === 'number' ? transactionCount : 0;
+    status.slot = typeof slotResult === 'number' ? slotResult : (slotResult.slot || 0);
+    status.blockHeight = typeof blockHeightResult === 'number' ? blockHeightResult : status.slot;
+    status.transactionCount = 0; // Transaction count not available via SDK
+    status.peerCount = Array.isArray(peersResult) ? peersResult.length : 0;
     
     if (epochInfoResult && typeof epochInfoResult === 'object') {
       epochInfo = epochInfoResult;
       status.epoch = epochInfo.epoch || 0;
-      epochInfo.slotIndex = epochInfo.slotIndex || 0;
-      epochInfo.slotsInEpoch = epochInfo.slotsInEpoch || 432000;
+      epochInfo.slotIndex = epochInfo.slotIndex || epochInfo.slot_index || 0;
+      epochInfo.slotsInEpoch = epochInfo.slotsInEpoch || epochInfo.slots_in_epoch || 432000;
     }
     
-    if (blockProdResult && typeof blockProdResult === 'object') {
-      blockProduction = blockProdResult;
-    }
-
-    // Get peer count
-    try {
-      status.peerCount = await rpcCall(options.rpcUrl, 'getPeerCount') || 0;
-    } catch (e) {
-      status.peerCount = 0;
+    if (options.details) {
+      try {
+        blockProduction = await client.getSlotProduction();
+      } catch { /* Block production not available */ }
     }
 
     if (options.json) {
@@ -260,7 +219,7 @@ async function validatorStatus() {
 }
 
 // Export for use as module
-module.exports = { validatorStatus, rpcCall };
+module.exports = { validatorStatus };
 
 // Run if called directly
 if (require.main === module) {

package/commands/validators.js

@@ -13,10 +13,15 @@
  *   aether validators list --sort stake  Sort by stake (default: score)
  *
  * Requires AETHER_RPC env var (default: http://127.0.0.1:8899)
+ * 
+ * SDK wired to: GET /v1/validators, GET /v1/epoch, GET /v1/supply
  */
 
-const http = require('http');
-const https = require('https');
+const path = require('path');
+
+// Import SDK for real blockchain RPC calls
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
 
 // ANSI colours
 const C = {
@@ -31,56 +36,12 @@ const C = {
   magenta: '\x1b[35m',
 };
 
-const DEFAULT_RPC = process.env.AETHER_RPC || 'http://127.0.0.1:8899';
-
-// ---------------------------------------------------------------------------
-// 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 || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
 }
 
-function httpPost(rpcUrl, path, body) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(path, rpcUrl);
-    const lib = url.protocol === 'https:' ? https : http;
-    const bodyStr = JSON.stringify(body);
-    const req = lib.request({
-      hostname: url.hostname,
-      port: url.port || (url.protocol === 'https:' ? 443 : 80),
-      path: url.pathname + url.search,
-      method: 'POST',
-      timeout: 8000,
-      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();
-  });
+function createClient(rpcUrl) {
+  return new aether.AetherClient({ rpcUrl });
 }
 
 // ---------------------------------------------------------------------------
@@ -90,7 +51,7 @@ function httpPost(rpcUrl, path, body) {
 function parseArgs() {
   const args = process.argv.slice(3); // [node, index.js, validators, list, ...]
   const opts = {
-    rpc: DEFAULT_RPC,
+    rpc: getDefaultRpc(),
     subcmd: 'list',
     tier: null,
     asJson: false,
@@ -137,6 +98,7 @@ function parseArgs() {
 }
 
 function showHelp() {
+  const defaultRpc = getDefaultRpc();
   console.log(`
 ${C.bright}${C.cyan}aether-cli validators${C.reset} - List and inspect Aether validators
 
@@ -148,17 +110,22 @@ ${C.bright}Options (list):${C.reset}
   -t, --tier <type>   Filter by tier: full, lite, observer
   -s, --sort <field>  Sort by: stake, score, apy, uptime, name (default: score)
   -l, --limit <n>     Max validators to show (default: 100, max: 500)
-  -r, --rpc <url>     RPC endpoint (default: ${DEFAULT_RPC} or $AETHER_RPC)
+  -r, --rpc <url>     RPC endpoint (default: ${defaultRpc} or $AETHER_RPC)
   -j, --json          Output raw JSON (for scripting)
   -h, --help          Show this help message
 
 ${C.bright}Options (rank):${C.reset}
   -t, --tier <type>   Filter by tier: full, lite, observer
   -l, --limit <n>     Max validators to show (default: 50, max: 200)
-  -r, --rpc <url>     RPC endpoint (default: ${DEFAULT_RPC} or $AETHER_RPC)
+  -r, --rpc <url>     RPC endpoint (default: ${defaultRpc} or $AETHER_RPC)
   -j, --json          Output raw JSON (for scripting)
   -h, --help          Show this help message
 
+${C.bright}SDK Methods Used:${C.reset}
+  client.getValidators()  → GET /v1/validators
+  client.getEpochInfo()   → GET /v1/epoch
+  client.getSupply()      → GET /v1/supply
+
 ${C.bright}Examples:${C.reset}
   aether validators list                  # All validators, sorted by score
   aether validators list --tier full       # Full validators only
@@ -173,46 +140,40 @@ ${C.bright}Examples:${C.reset}
 }
 
 // ---------------------------------------------------------------------------
-// Data fetchers
+// Data fetchers using SDK - Real blockchain RPC calls
 // ---------------------------------------------------------------------------
 
-/** Fetch all validators from the network */
+/** Fetch all validators from the network using SDK */
 async function fetchValidators(rpc) {
   try {
-    // Try /v1/validators first (standard Aether RPC endpoint)
-    const res = await httpRequest(rpc, '/v1/validators');
-    if (res && !res.error) {
-      if (Array.isArray(res)) return res;
-      if (res.validators && Array.isArray(res.validators)) return res.validators;
-      if (res.accounts && Array.isArray(res.accounts)) return res.accounts;
-    }
-    // Fallback: POST to a validators query endpoint
-    const res2 = await httpPost(rpc, '/v1/validators', {});
-    if (res2 && !res2.error) {
-      if (Array.isArray(res2)) return res2;
-      if (res2.validators && Array.isArray(res2.validators)) return res2.validators;
-    }
-    return [];
+    const client = createClient(rpc);
+    // SDK getValidators() → GET /v1/validators
+    const result = await client.getValidators();
+    return Array.isArray(result) ? result : [];
   } catch {
     return [];
   }
 }
 
-/** Fetch epoch info for APY calculations */
+/** Fetch epoch info for APY calculations using SDK */
 async function fetchEpochInfo(rpc) {
   try {
-    const res = await httpRequest(rpc, '/v1/epoch-info');
-    return res;
+    const client = createClient(rpc);
+    // SDK getEpochInfo() → GET /v1/epoch
+    const result = await client.getEpochInfo();
+    return result || null;
   } catch {
     return null;
   }
 }
 
-/** Fetch network-wide stake totals for APY estimation */
+/** Fetch network-wide stake totals for APY estimation using SDK */
 async function fetchSupply(rpc) {
   try {
-    const res = await httpRequest(rpc, '/v1/supply');
-    return res;
+    const client = createClient(rpc);
+    // SDK getSupply() → GET /v1/supply
+    const result = await client.getSupply();
+    return result || null;
   } catch {
     return null;
   }

package/commands/wallet.js

@@ -541,37 +541,11 @@ async function connectWallet(rl) {
 
 // ---------------------------------------------------------------------------
 // BALANCE
-// Query chain RPC GET /v1/account/<addr> for real AETH balance
+// Query chain RPC GET /v1/account/<addr> for real AETH balance using SDK
 // ---------------------------------------------------------------------------
 
 function getDefaultRpc() {
-  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
-}
-
-/**
- * Make HTTP GET request to the RPC endpoint
- */
-function httpRequest(rpcUrl, path) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(path, rpcUrl);
-    const lib = url.protocol === 'https:' ? require('https') : require('http');
-    const req = lib.request({
-      hostname: url.hostname,
-      port: url.port || (url.protocol === 'https:' ? 443 : 80),
-      path: url.pathname + url.search,
-      method: 'GET',
-      headers: { 'Content-Type': 'application/json' },
-    }, (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.end();
-  });
+  return process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
 }
 
 /**
@@ -612,9 +586,11 @@ async function balanceWallet(rl) {
   console.log();
 
   try {
+    // Use SDK for real blockchain RPC call
+    const client = new aether.AetherClient({ rpcUrl });
     // Strip ATH prefix if present for API call
     const rawAddr = address.startsWith('ATH') ? address.slice(3) : address;
-    const account = await httpRequest(rpcUrl, `/v1/account/${rawAddr}`);
+    const account = await client.getAccountInfo(rawAddr);
     
     if (!account || account.error) {
       console.log(`  ${C.yellow}⚠ Account not found on chain or RPC error.${C.reset}`);

package/index.js

@@ -30,6 +30,12 @@ const { broadcastCommand } = require('./commands/broadcast');
 const { apyCommand } = require('./commands/apy');
 const { statsCommand } = require('./commands/stats');
 const { txHistoryCommand } = require('./commands/tx-history');
+const { feesCommand } = require('./commands/fees');
+const { tpsCommand } = require('./commands/tps');
+const { blockhashCommand } = require('./commands/blockhash');
+const { sdkTestCommand } = require('./commands/sdk-test');
+const { balanceCommand } = require('./commands/balance');
+const { transferCommand } = require('./commands/transfer');
 const readline = require('readline');
 
 // CLI version
@@ -204,6 +210,13 @@ const COMMANDS = {
       stakePositionsCommand();
     },
   },
+  'stake-info': {
+    description: 'Get staking info for an address via real chain RPC — aether stake-info <address>',
+    handler: () => {
+      const { stakeInfoCommand } = require('./commands/stake-info');
+      stakeInfoCommand();
+    },
+  },
   unstake: {
     description: 'Unstake AETH — deactivate a stake account — aether unstake --account <stakeAcct> [--amount <aeth>]',
     handler: () => {
@@ -227,11 +240,7 @@ const COMMANDS = {
   transfer: {
     description: 'Transfer AETH to another address — aether transfer --to <addr> --amount <aeth>',
     handler: () => {
-      const { walletCommand } = require('./commands/wallet');
-      const originalArgv = process.argv;
-      process.argv = [...originalArgv.slice(0, 2), 'wallet', 'transfer', ...originalArgv.slice(3)];
-      walletCommand();
-      process.argv = originalArgv;
+      transferCommand();
     },
   },
   tx: {
@@ -246,6 +255,20 @@ const COMMANDS = {
       txHistoryCommand();
     },
   },
+  blockhash: {
+    description: 'Get the latest blockhash from the chain (required for signing TXs) — aether blockhash [--json] [--watch]',
+    handler: () => {
+      const { blockhashCommand } = require('./commands/blockhash');
+      blockhashCommand();
+    },
+  },
+  balance: {
+    description: 'Query account balance — aether balance [address] [--json] [--lamports] [--rpc <url>]',
+    handler: () => {
+      const { balanceCommand } = require('./commands/balance');
+      balanceCommand();
+    },
+  },
   network: {
     description: 'Aether network status — slot, block height, peers, TPS, epoch info',
     handler: () => {
@@ -394,6 +417,31 @@ const COMMANDS = {
       emergencyCommand();
     },
   },
+  fees: {
+    description: 'Network fee estimates — aether fees [--json] [--verbose] [--rpc <url>]',
+    handler: () => {
+      feesCommand();
+    },
+  },
+  tps: {
+    description: 'Transactions per second monitor — aether tps [--monitor] [--interval 2] [--json]',
+    handler: () => {
+      tpsCommand();
+    },
+  },
+  claim: {
+    description: 'Claim accumulated staking rewards — aether claim --address <addr> [--json] [--dry-run]',
+    handler: () => {
+      const { claimCommand } = require('./commands/claim');
+      claimCommand();
+    },
+  },
+  'sdk-test': {
+    description: 'Test SDK with real RPC calls — aether sdk-test [--rpc <url>] [--quick] [--json]',
+    handler: () => {
+      sdkTestCommand();
+    },
+  },
   help: {
     description: 'Show this help message',
     handler: showHelp,
@@ -448,7 +496,7 @@ function parseArgs() {
   const args = process.argv.slice(2);
 
   // Handle version flag
-  if (args.includes('--version') || args.includes('-v')) {
+  if (args.includes('--version') || args.includes('-v') || args.includes('-V')) {
     return 'version';
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aether-hub",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "description": "AeTHer Validator CLI — tiered validators (Full/Lite/Observer), system checks, onboarding, and node management",
   "main": "index.js",
   "bin": {
@@ -18,8 +18,6 @@
     "test": "node test/doctor.test.js",
     "start": "node index.js",
     "doctor": "node index.js doctor",
-    "price": "node index.js price",
-    "build": "node -e \"require('./commands/price'); require('./commands/account'); require('./commands/emergency')\" && echo \"Build OK\"",
     "postinstall": "node -e \"console.log('\\n\\n  [Aether] aether-hub installed!\\n\\n  Run: aether start\\n  Docs: https://github.com/jelly-legs-ai/Jelly-legs-unsteady-workshop\\n')\""
   },
   "keywords": [