aether-hub 1.2.6 → 1.2.7

package/commands/epoch.js

@@ -14,8 +14,7 @@
  * Requires AETHER_RPC env var (default: http://127.0.0.1:8899)
  */
 
-const http = require('http');
-const https = require('https');
+const path = require('path');
 
 // ANSI colours
 const C = {
@@ -32,68 +31,14 @@ const C = {
 const CLI_VERSION = '1.0.0';
 
 // ---------------------------------------------------------------------------
-// HTTP helpers
+// SDK Import - Real blockchain RPC calls via @jellylegsai/aether-sdk
 // ---------------------------------------------------------------------------
 
-function httpRequest(rpcUrl, pathStr, timeoutMs) {
-  timeoutMs = timeoutMs || 8000;
-  return new Promise(function(resolve, reject) {
-    const url = new URL(pathStr, 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: timeoutMs,
-      headers: { 'Content-Type': 'application/json' },
-    }, function(res) {
-      let data = '';
-      res.on('data', function(chunk) { data += chunk; });
-      res.on('end', function() {
-        try { resolve(JSON.parse(data)); }
-        catch { resolve({ raw: data }); }
-      });
-    });
-    req.on('error', reject);
-    req.on('timeout', function() { req.destroy(); reject(new Error('Request timeout')); });
-    req.end();
-  });
-}
-
-function httpPost(rpcUrl, pathStr, body, timeoutMs) {
-  timeoutMs = timeoutMs || 8000;
-  return new Promise(function(resolve, reject) {
-    const url = new URL(pathStr, 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: timeoutMs,
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(bodyStr),
-      },
-    }, function(res) {
-      let data = '';
-      res.on('data', function(chunk) { data += chunk; });
-      res.on('end', function() {
-        try { resolve(JSON.parse(data)); }
-        catch { resolve({ raw: data }); }
-      });
-    });
-    req.on('error', reject);
-    req.on('timeout', function() { req.destroy(); reject(new Error('Request timeout')); });
-    req.write(bodyStr);
-    req.end();
-  });
-}
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
 
 function getDefaultRpc() {
-  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+  return process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
 }
 
 // ---------------------------------------------------------------------------
@@ -111,46 +56,19 @@ function parseArgs() {
 }
 
 // ---------------------------------------------------------------------------
-// Fetch epoch info from RPC
+// Fetch epoch info from RPC using SDK
 // ---------------------------------------------------------------------------
 
 async function fetchEpochInfo(rpc) {
-  // Try Aether-native endpoint first
-  try {
-    const epochInfo = await httpRequest(rpc, '/v1/epoch-info');
-    if (epochInfo && !epochInfo.error && (epochInfo.epoch !== undefined || epochInfo.current_epoch)) {
-      return { data: epochInfo, source: 'aether' };
-    }
-  } catch(e) {
-    // fall through
-  }
-
-  // Fallback: try Solana-compat JSON-RPC
-  try {
-    const result = await httpPost(rpc, '/', {
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'getEpochInfo',
-    });
-    if (result && result.result) {
-      return { data: result.result, source: 'solana-compat' };
-    }
-  } catch(e) {
-    // fall through
-  }
-
-  // Try getEpochSchedule
+  // Use SDK for real blockchain RPC calls
+  const client = new aether.AetherClient({ rpcUrl: rpc });
   try {
-    const schedule = await httpPost(rpc, '/', {
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'getEpochSchedule',
-    });
-    if (schedule && schedule.result) {
-      return { data: schedule.result, source: 'schedule-only' };
+    const epochInfo = await client.getEpochInfo();
+    if (epochInfo && (epochInfo.epoch !== undefined || epochInfo.current_epoch)) {
+      return { data: epochInfo, source: 'aether-sdk' };
     }
   } catch(e) {
-    // fall through
+    throw new Error('Failed to fetch epoch info from RPC. Is your validator running?');
   }
 
   throw new Error('Failed to fetch epoch info from RPC. Is your validator running?');

package/commands/fees.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+/**
+ * aether-cli fees
+ *
+ * Query current network fee estimates for Aether transactions.
+ * Shows priority fee tiers (low, medium, high) and recent average fees.
+ * Uses @jellylegsai/aether-sdk for real RPC calls to /v1/fees.
+ *
+ * Usage:
+ *   aether fees                    Show current fee estimates
+ *   aether fees --json             JSON output for scripting
+ *   aether fees --verbose          Show detailed fee breakdown
+ *   aether fees --rpc <url>        Custom RPC endpoint
+ */
+
+const path = require('path');
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
+
+// 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',
+};
+
+// Fee priority levels
+const PRIORITY_LEVELS = {
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  TURBO: 'turbo',
+};
+
+/**
+ * Fetch fee data from Aether RPC endpoint using SDK
+ * Real RPC call: GET /v1/fees
+ */
+async function fetchFromRpc(rpcUrl) {
+  const client = new aether.AetherClient({ rpcUrl });
+  try {
+    const fees = await client.getFees();
+    if (fees && fees.fee !== undefined) {
+      return {
+        baseFee: fees.baseFee || fees.fee || 5000,
+        prioritizationFee: fees.prioritizationFee || 0,
+        totalFee: fees.totalFee || fees.fee || 5000,
+        raw: fees,
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generate simulated fee estimates as fallback
+ * Used when RPC endpoint is unavailable
+ */
+function generateSimulatedFees() {
+  const baseFee = 5000;
+  const congestionFactor = 1.0 + (Math.random() * 0.5);
+  
+  return {
+    baseFee,
+    levels: {
+      [PRIORITY_LEVELS.LOW]: {
+        lamports: Math.round(baseFee * 1.0 * congestionFactor),
+        aeth: (baseFee * 1.0 * congestionFactor / 1e9).toFixed(9),
+        description: 'Economy - may take longer during congestion',
+        color: C.green,
+      },
+      [PRIORITY_LEVELS.MEDIUM]: {
+        lamports: Math.round(baseFee * 1.5 * congestionFactor),
+        aeth: (baseFee * 1.5 * congestionFactor / 1e9).toFixed(9),
+        description: 'Standard - typical confirmation time',
+        color: C.cyan,
+      },
+      [PRIORITY_LEVELS.HIGH]: {
+        lamports: Math.round(baseFee * 2.5 * congestionFactor),
+        aeth: (baseFee * 2.5 * congestionFactor / 1e9).toFixed(9),
+        description: 'Fast - priority during high congestion',
+        color: C.yellow,
+      },
+      [PRIORITY_LEVELS.TURBO]: {
+        lamports: Math.round(baseFee * 5.0 * congestionFactor),
+        aeth: (baseFee * 5.0 * congestionFactor / 1e9).toFixed(9),
+        description: 'Maximum - fastest confirmation',
+        color: C.magenta,
+      },
+    },
+    averageFee24h: Math.round(baseFee * 1.8 * congestionFactor),
+    medianFee24h: Math.round(baseFee * 1.5 * congestionFactor),
+    source: 'Aether Network (simulated)',
+    timestamp: new Date(),
+  };
+}
+
+/**
+ * Build fee data from RPC response
+ */
+function buildFeeData(rpcFees) {
+  const baseFee = rpcFees.baseFee || 5000;
+  const totalFee = rpcFees.totalFee || baseFee;
+  
+  return {
+    baseFee,
+    levels: {
+      [PRIORITY_LEVELS.LOW]: {
+        lamports: totalFee,
+        aeth: (totalFee / 1e9).toFixed(9),
+        description: 'Economy',
+        color: C.green,
+      },
+      [PRIORITY_LEVELS.MEDIUM]: {
+        lamports: Math.round(totalFee * 1.5),
+        aeth: (totalFee * 1.5 / 1e9).toFixed(9),
+        description: 'Standard',
+        color: C.cyan,
+      },
+      [PRIORITY_LEVELS.HIGH]: {
+        lamports: Math.round(totalFee * 2.5),
+        aeth: (totalFee * 2.5 / 1e9).toFixed(9),
+        description: 'Fast',
+        color: C.yellow,
+      },
+      [PRIORITY_LEVELS.TURBO]: {
+        lamports: Math.round(totalFee * 5),
+        aeth: (totalFee * 5 / 1e9).toFixed(9),
+        description: 'Maximum',
+        color: C.magenta,
+      },
+    },
+    averageFee24h: totalFee,
+    medianFee24h: totalFee,
+    source: 'Aether RPC',
+    timestamp: new Date(),
+  };
+}
+
+/**
+ * Format lamports to human-readable string
+ */
+function formatLamports(lamports) {
+  if (lamports >= 1e9) {
+    return `${(lamports / 1e9).toFixed(6)} AETH`;
+  } else if (lamports >= 1e6) {
+    return `${(lamports / 1e6).toFixed(3)} mAETH`;
+  } else if (lamports >= 1e3) {
+    return `${(lamports / 1e3).toFixed(1)} µAETH`;
+  }
+  return `${lamports} lamports`;
+}
+
+/**
+ * Format timestamp
+ */
+function formatTime(date) {
+  return date.toISOString().replace('T', ' ').substring(0, 19) + ' UTC';
+}
+
+/**
+ * Main fees command
+ */
+async function feesCommand() {
+  const args = process.argv.slice(2);
+  const asJson = args.includes('--json') || args.includes('-j');
+  const verbose = args.includes('--verbose') || args.includes('-v');
+  const rpcUrl = args.includes('--rpc')
+    ? args[args.indexOf('--rpc') + 1]
+    : process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
+
+  if (!asJson) {
+    console.log(`\n${C.bright}${C.cyan}── Aether Network Fees ──────────────────────────────────${C.reset}\n`);
+  }
+
+  // Fetch real fee data from RPC using SDK
+  let feeData = null;
+  let source = 'Simulated';
+
+  try {
+    const rpcFees = await fetchFromRpc(rpcUrl);
+    if (rpcFees) {
+      feeData = buildFeeData(rpcFees);
+      source = 'Aether RPC';
+    }
+  } catch { /* RPC not available */ }
+
+  // Use simulated fees as fallback
+  if (!feeData) {
+    feeData = generateSimulatedFees();
+    source = 'Simulated';
+  }
+
+  // JSON output
+  if (asJson) {
+    const output = {
+      source: feeData.source,
+      timestamp: formatTime(feeData.timestamp),
+      base_fee_lamports: feeData.baseFee,
+      priority_levels: Object.fromEntries(
+        Object.entries(feeData.levels).map(([key, val]) => [
+          key,
+          { lamports: val.lamports, aeth: parseFloat(val.aeth) }
+        ])
+      ),
+      average_fee_24h_lamports: feeData.averageFee24h,
+      median_fee_24h_lamports: feeData.medianFee24h,
+    };
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+
+  // Human-readable output
+  console.log(`  ${C.dim}Source:${C.reset}      ${C.bright}${feeData.source}${C.reset}`);
+  console.log(`  ${C.dim}Updated:${C.reset}     ${formatTime(feeData.timestamp)}`);
+  console.log(`  ${C.dim}Base Fee:${C.reset}    ${formatLamports(feeData.baseFee)}`);
+  console.log();
+
+  console.log(`  ${C.bright}Priority Levels:${C.reset}\n`);
+  console.log(`  ┌─────────────┬──────────────────────┬─────────────────────────────────────┐`);
+  console.log(`  │ ${C.bright}Level${C.reset}      │ ${C.bright}Fee${C.reset}                │ ${C.bright}Description${C.reset}                     │`);
+  console.log(`  ├─────────────┼──────────────────────┼─────────────────────────────────────┤`);
+
+  Object.entries(feeData.levels).forEach(([level, info]) => {
+    const levelName = level.charAt(0) + level.slice(1).toLowerCase();
+    const feeStr = `${info.color}${formatLamports(info.lamports).padEnd(20)}${C.reset}`;
+    const descStr = info.description.padEnd(35);
+    console.log(`  │ ${levelName.padEnd(11)} │ ${feeStr} │ ${descStr} │`);
+  });
+
+  console.log(`  └─────────────┴──────────────────────┴─────────────────────────────────────┘`);
+  console.log();
+
+  // 24h statistics
+  console.log(`  ${C.dim}24h Statistics:${C.reset}`);
+  console.log(`    ${C.dim}Average:${C.reset}  ${formatLamports(feeData.averageFee24h)}`);
+  console.log(`    ${C.dim}Median:${C.reset}   ${formatLamports(feeData.medianFee24h)}`);
+  console.log();
+
+  // Verbose mode - show additional details
+  if (verbose) {
+    console.log(`  ${C.bright}Fee Breakdown:${C.reset}\n`);
+    console.log(`    ${C.dim}Base Fee:${C.reset}           ${formatLamports(feeData.baseFee)}`);
+    console.log(`    ${C.dim}Priority Multiplier:${C.reset} 1.0x - 5.0x (based on urgency)`);
+    console.log(`    ${C.dim}Network Congestion:${C.reset} ${Math.round((feeData.averageFee24h / feeData.baseFee - 1) * 100)}% above base`);
+    console.log();
+
+    console.log(`  ${C.bright}Recommendations:${C.reset}\n`);
+    console.log(`    • Use ${C.cyan}Standard${C.reset} for routine transactions`);
+    console.log(`    • Use ${C.yellow}Fast${C.reset} during network congestion or for time-sensitive ops`);
+    console.log(`    • Use ${C.magenta}Maximum${C.reset} for validator operations or large transfers`);
+    console.log();
+  }
+
+  // Usage tip
+  console.log(`  ${C.dim}Tip: Set ${C.cyan}--priority${C.reset}${C.dim} flag when submitting transactions to choose fee level.${C.reset}`);
+  console.log(`  ${C.dim}Example: ${C.cyan}aether transfer --to <addr> --amount 10 --priority high${C.reset}\n`);
+}
+
+// Export for use in index.js
+module.exports = { feesCommand };
+
+// Run if called directly
+if (require.main === module) {
+  feesCommand().catch(err => {
+    console.error(`\n${C.red}Fees error:${C.reset} ${err.message}\n`);
+    process.exit(1);
+  });
+}

package/commands/info.js

@@ -19,8 +19,10 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const http = require('http');
-const https = require('https');
+
+// Import SDK for real blockchain RPC calls
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
 
 // ANSI colours
 const C = {
@@ -59,57 +61,15 @@ function loadConfig() {
 }
 
 // ---------------------------------------------------------------------------
-// HTTP helpers
+// SDK helpers - Real blockchain RPC calls via Aether SDK
 // ---------------------------------------------------------------------------
 
-function httpRequest(rpcUrl, pathStr) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(pathStr, 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 httpPost(rpcUrl, pathStr, body) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(pathStr, 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: 15000,
-      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({ raw: data }); } });
-    });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout')); });
-    req.write(bodyStr);
-    req.end();
-  });
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
 }
 
-function getDefaultRpc() {
-  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+function createClient(rpcUrl) {
+  return new aether.AetherClient({ rpcUrl });
 }
 
 function formatAether(lamports) {
@@ -157,7 +117,8 @@ async function getIdentity(rpcUrl) {
 
   if (identity && identity.vote_account) {
     try {
-      const res = await httpRequest(rpcUrl, `/v1/account/${identity.vote_account}`);
+      const client = createClient(rpcUrl);
+      const res = await client.getAccountInfo(identity.vote_account);
       if (res && !res.error) {
         delegatedStake = res.lamports || 0;
         stakeStatus = 'active';
@@ -191,44 +152,41 @@ async function getNetworkStatus(rpcUrl) {
   let totalPeers = 0;
 
   try {
+    const client = createClient(rpcUrl);
     const results = await Promise.allSettled([
-      httpRequest(rpcUrl, '/v1/slot'),
-      httpRequest(rpcUrl, '/v1/epoch-info'),
-      httpRequest(rpcUrl, '/v1/block-height'),
-      httpRequest(rpcUrl, '/v1/peers'),
-      httpRequest(rpcUrl, '/v1/perf?limit=10'),
+      client.getSlot(),
+      client.getEpochInfo(),
+      client.getBlockHeight(),
+      client.getClusterPeers(),
+      { status: 'rejected', reason: new Error('Perf endpoint not in SDK') },
     ]);
 
-    const [slotRes, epochRes, blockHeightRes, peersRes, perfRes] = results;
+    const [slotRes, epochRes, blockHeightRes, peersRes] = results;
 
-    if (slotRes.status === 'fulfilled' && slotRes.value && !slotRes.value.error) {
-      slot = slotRes.value.slot ?? slotRes.value;
-      if (typeof slot === 'object') slot = slot.slot;
+    if (slotRes.status === 'fulfilled' && slotRes.value !== null) {
+      slot = typeof slotRes.value === 'object' ? slotRes.value.slot : slotRes.value;
     }
-    if (epochRes.status === 'fulfilled' && epochRes.value && !epochRes.value.error) {
+    if (epochRes.status === 'fulfilled' && epochRes.value) {
       const ei = epochRes.value;
       epoch = ei.epoch;
-      slotIndex = ei.slot_index;
-      slotsInEpoch = ei.slots_in_epoch;
-      blockTime = ei.block_time ?? null;
+      slotIndex = ei.slotIndex ?? ei.slot_index;
+      slotsInEpoch = ei.slotsInEpoch ?? ei.slots_in_epoch;
+      blockTime = ei.blockTime ?? ei.block_time ?? null;
     }
-    if (blockHeightRes.status === 'fulfilled' && blockHeightRes.value && !blockHeightRes.value.error) {
+    if (blockHeightRes.status === 'fulfilled' && blockHeightRes.value !== null) {
       blockHeight = typeof blockHeightRes.value === 'object'
-        ? blockHeightRes.value.block_height
+        ? blockHeightRes.value.blockHeight
         : blockHeightRes.value;
     }
-    if (peersRes.status === 'fulfilled' && peersRes.value && !peersRes.value.error) {
-      const pr = peersRes.value;
-      peers = Array.isArray(pr) ? pr : (pr.peers || []);
+    if (peersRes.status === 'fulfilled' && peersRes.value) {
+      peers = Array.isArray(peersRes.value) ? peersRes.value : (peersRes.value.peers || []);
       totalPeers = peers.length;
     }
-    if (perfRes.status === 'fulfilled' && perfRes.value && !perfRes.value.error && Array.isArray(perfRes.value)) {
-      const samples = perfRes.value.slice(-5);
-      if (samples.length > 0) {
-        const totalTPS = samples.reduce((sum, s) => sum + (s.tps || 0), 0);
-        TPS = Math.round(totalTPS / samples.length);
-      }
-    }
+    
+    // Get TPS from SDK
+    try {
+      TPS = await client.getTPS();
+    } catch { /* TPS not available */ }
   } catch { /* Network info unavailable */ }
 
   let syncState = 'unknown';
@@ -278,12 +236,13 @@ async function getStakeSummary(rpcUrl) {
     const walletAddr = cfg.defaultWallet;
 
     if (walletAddr) {
+      const client = createClient(rpcUrl);
       const rawAddr = walletAddr.startsWith('ATH') ? walletAddr.slice(3) : walletAddr;
-      const res = await httpRequest(rpcUrl, `/v1/stake?address=${encodeURIComponent(rawAddr)}`);
+      const res = await client.getStakePositions(rawAddr);
       if (res && !res.error) {
-        const accounts = Array.isArray(res) ? res : (res.accounts || []);
+        const accounts = Array.isArray(res) ? res : (res.accounts || res.stakes || res.delegations || []);
         for (const acc of accounts) {
-          const lamports = BigInt(acc.stake_lamports || acc.lamports || 0);
+          const lamports = BigInt(acc.stake_lamports || acc.lamports || acc.amount || 0);
           const status = (acc.status || acc.state || 'active').toLowerCase();
           const validator = acc.validator || acc.voter || acc.vote_account || 'unknown';
 
@@ -292,7 +251,7 @@ async function getStakeSummary(rpcUrl) {
 
           totalDelegated += lamports;
           positions.push({
-            stake_account: acc.pubkey || acc.publicKey || acc.account || 'unknown',
+            stake_account: acc.pubkey || acc.publicKey || acc.account || acc.stakeAccount || 'unknown',
             validator,
             lamports: lamports.toString(),
             lamports_formatted: formatAether(lamports.toString()),