aether-hub 1.2.6 → 1.2.8

package/commands/tx-history.js

@@ -15,8 +15,11 @@
  *   aether history --address ATHxxx --rpc https://rpc.aether.io
  */
 
-const https = require('https');
-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 colours
 const C = {
@@ -33,67 +36,15 @@ const C = {
 const CLI_VERSION = '1.0.0';
 
 // ---------------------------------------------------------------------------
-// Config
+// SDK helpers - Real blockchain RPC calls via Aether SDK
 // ---------------------------------------------------------------------------
 
 function getDefaultRpc() {
-  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
-}
-
-// ---------------------------------------------------------------------------
-// HTTP helpers
-// ---------------------------------------------------------------------------
-
-function httpRequest(rpcUrl, path, timeoutMs = 10000) {
-  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: timeoutMs,
-      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 after ${timeoutMs}ms`)); });
-    req.end();
-  });
+  return process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
 }
 
-function httpPost(rpcUrl, path, body, timeoutMs = 15000) {
-  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: timeoutMs,
-      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 after ${timeoutMs}ms`)); });
-    req.write(bodyStr);
-    req.end();
-  });
+function createClient(rpcUrl) {
+  return new aether.AetherClient({ rpcUrl });
 }
 
 // ---------------------------------------------------------------------------
@@ -180,141 +131,42 @@ function formatStatus(status) {
 }
 
 // ---------------------------------------------------------------------------
-// Core RPC calls
+// Parse a transaction result into a normalized display object
 // ---------------------------------------------------------------------------
 
-/**
- * Fetch confirmed transaction signatures for an address using getSignaturesForAddress.
- */
-async function fetchTxSignatures(rpcUrl, address, limit) {
-  const body = {
-    jsonrpc: '2.0',
-    id: 1,
-    method: 'getSignaturesForAddress',
-    params: [
-      address,
-      { limit },
-    ],
-  };
-  return httpPost(rpcUrl, '/', body);
-}
+function parseTransaction(txResult) {
+  const blockTime = txResult.blockTime;
+  const slot = txResult.slot;
+  const status = txResult.status || 'confirmed';
 
-/**
- * Fetch a specific confirmed transaction by signature.
- */
-async function fetchTx(rpcUrl, signature) {
-  const body = {
-    jsonrpc: '2.0',
-    id: 1,
-    method: 'getTransaction',
-    params: [
-      signature,
-      { encoding: 'jsonParsed', maxSupportedTransactionVersion: 0 },
-    ],
-  };
-  return httpPost(rpcUrl, '/', body);
-}
-
-/**
- * Parse a transaction result into a normalized display object.
- */
-function parseTransaction(txResult, sigInfo) {
-  const blockTime = sigInfo.blockTime || txResult.blockTime;
-  const slot = sigInfo.slot;
-  const status = sigInfo.err ? 'failed' : (sigInfo.confirmationStatus || 'confirmed');
-
-  let txType = 'unknown';
+  let txType = txResult.tx_type || txResult.type || 'unknown';
   let amount = 0;
-  let fee = txResult.meta?.fee || 0;
-  let fromAddr = null;
+  let fee = txResult.fee || 0;
+  let fromAddr = txResult.signer || null;
   let toAddr = null;
-  let memo = null;
+  let memo = txResult.memo || null;
 
-  try {
-    const msg = txResult.transaction?.message;
-    if (msg) {
-      // Parse instructions for transfer/stake types
-      const instructions = msg.instructions || [];
-      for (const ix of instructions) {
-        const programId = ix.programId || (ix.parsed && ix.parsed.info && ix.parsed.type);
-        // Native transfer
-        if (ix.parsed && ix.parsed.type === 'transfer') {
-          txType = 'transfer';
-          const info = ix.parsed.info;
-          fromAddr = info.source || info.from;
-          toAddr = info.destination || info.to;
-          amount = info.lamports || info.amount || 0;
-        } else if (ix.parsed && ix.parsed.type === 'stake') {
-          txType = 'stake';
-          const info = ix.parsed.info;
-          fromAddr = info.from || info.funder;
-          toAddr = info.validator;
-          amount = info.lamports || info.amount || 0;
-        } else if (ix.parsed && ix.parsed.type === 'withdrawStake') {
-          txType = 'unstake';
-          const info = ix.parsed.info;
-          toAddr = info.destination || info.withdrawer;
-          amount = info.lamports || info.amount || 0;
-        } else if (ix.parsed && ix.parsed.type === 'vote') {
-          txType = 'vote';
-        } else if (ix.parsed && ix.parsed.type === 'initialize') {
-          txType = 'initialize';
-        } else if (ix.parsed && ix.parsed.type === 'createAccount') {
-          txType = 'create';
-        } else if (ix.parsed && ix.parsed.type === 'approve') {
-          txType = 'stake';
-          const info = ix.parsed.info || {};
-          fromAddr = info.from || info.owner;
-          toAddr = info.stake;
-          amount = info.amount || info.lamports || 0;
-        } else if (ix.parsed && ix.parsed.type === 'delegate') {
-          txType = 'stake';
-          const info = ix.parsed.info || {};
-          fromAddr = info.stake || info.from;
-          toAddr = info.validator;
-          amount = info.lamports || 0;
-        } else if (ix.parsed && ix.parsed.type === 'withdraw') {
-          txType = 'unstake';
-          const info = ix.parsed.info || {};
-          toAddr = info.destination;
-          amount = info.lamports || 0;
-        }
-        // Check memo
-        if (ix.memo) memo = ix.memo;
-      }
-
-      // Fallback: try legacy instructions if no parsed instructions
-      if (!instructions.length || instructions.every(ix => !ix.parsed)) {
-        for (const ix of instructions) {
-          if (ix.data === 'AAAA' || ix.data === '2ugJ4ELK3wW9qNXH' || !ix.data) {
-            txType = 'transfer';
-          }
-        }
-      }
-
-      // Compute fee
-      if (txResult.meta) {
-        fee = txResult.meta.fee || 0;
-        if (txResult.meta.postBalances && txResult.meta.preBalances) {
-          // Try to detect native transfer from balance changes
-          for (let i = 0; i < txResult.meta.postBalances.length; i++) {
-            const diff = txResult.meta.postBalances[i] - txResult.meta.preBalances[i];
-            if (diff < 0) {
-              amount = Math.abs(diff);
-              if (!fromAddr) fromAddr = msg.accountKeys?.[i];
-            } else if (diff > 0 && amount === 0) {
-              if (!toAddr) toAddr = msg.accountKeys?.[i];
-            }
-          }
-        }
-      }
+  // Parse payload for details
+  if (txResult.payload) {
+    const payload = txResult.payload;
+    if (payload.amount !== undefined) {
+      amount = Number(payload.amount);
+    }
+    if (payload.recipient) {
+      toAddr = payload.recipient;
+    }
+    if (payload.validator) {
+      toAddr = payload.validator;
+      txType = 'stake';
+    }
+    if (payload.stake_account) {
+      fromAddr = payload.stake_account;
+      txType = 'unstake';
     }
-  } catch (e) {
-    // Parsing failed — use defaults
   }
 
   return {
-    signature: sigInfo.signature || sigInfo.signatures?.[0],
+    signature: txResult.signature,
     slot,
     blockTime,
     status,
@@ -411,6 +263,14 @@ function displayJson(txs, meta) {
 
 async function main() {
   const opts = parseArgs();
+  // Shift args if this module was called via index.js (extra argument in argv)
+  // Detect by checking if first non-option arg after 'tx' is the command name
+  const args = process.argv.slice(2);
+  const txIdx = args.indexOf('tx');
+  const historyIdx = args.indexOf('history');
+  if (txIdx !== -1 && historyIdx !== -1) {
+    // Already parsed correctly above - no action needed
+  }
 
   if (opts.help) {
     console.log(`
@@ -449,46 +309,11 @@ ${C.bright}EXAMPLES${C.reset}
   }
 
   try {
-    // Step 1: Get transaction signatures
-    const sigsResult = await fetchTxSignatures(rpcUrl, opts.address, limit);
-
-    if (sigsResult.error) {
-      throw new Error(sigsResult.error.message || JSON.stringify(sigsResult.error));
-    }
-
-    const signatures = Array.isArray(sigsResult.result) ? sigsResult.result : [];
-
-    if (signatures.length === 0) {
-      if (!opts.json) {
-        displayTxTable([]);
-      } else {
-        displayJson([], { address: opts.address, rpc: rpcUrl, limit });
-      }
-      return;
-    }
-
-    // Step 2: Fetch each transaction in parallel (up to 10 at a time)
-    const txResults = [];
-    const BATCH = 10;
-
-    for (let i = 0; i < signatures.length; i += BATCH) {
-      const batch = signatures.slice(i, i + BATCH);
-      const batchPromises = batch.map(sig => fetchTx(rpcUrl, sig.signature).catch(err => ({ error: err.message })));
-      const batchResults = await Promise.all(batchPromises);
-      txResults.push(...batchResults);
-    }
-
-    // Step 3: Parse and normalize
-    const txs = txResults
-      .map((res, idx) => {
-        if (res.error) return null;
-        try {
-          return parseTransaction(res.result || {}, signatures[idx] || {});
-        } catch {
-          return null;
-        }
-      })
-      .filter(Boolean);
+    // Use SDK for real blockchain RPC calls
+    const client = createClient(rpcUrl);
+    const history = await client.getTransactionHistory(opts.address, limit);
+    
+    const txs = (history.transactions || []).map(tx => parseTransaction(tx));
 
     if (opts.json) {
       displayJson(txs, { address: opts.address, rpc: rpcUrl, limit });
@@ -497,12 +322,25 @@ ${C.bright}EXAMPLES${C.reset}
     }
 
   } catch (err) {
-    console.log(`\n  ${C.red}✗ Failed to fetch transaction history:${C.reset} ${err.message}\n`);
-    if (err.stack && !opts.json) {
-      console.log(`  ${C.dim}${err.stack.split('\n').slice(0, 3).join('\n  ')}${C.reset}\n`);
+    if (opts.json) {
+      console.log(JSON.stringify({
+        error: err.message,
+        address: opts.address,
+        rpc: rpcUrl,
+      }, null, 2));
+    } else {
+      console.log(`\n  ${C.red}✗ Failed to fetch transaction history:${C.reset} ${err.message}\n`);
+      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);
   }
 }
 
-main();
+// Export for CLI integration
+module.exports = { txHistoryCommand: main };
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

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) {