aether-hub 1.2.5 → 1.2.7

package/commands/stake-info.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+/**
+ * aether-cli - Stake Info Command
+ * Get staking information for an address using real chain RPC calls.
+ * All calls go through @jellylegsai/aether-sdk → AetherClient → real HTTP RPC.
+ *
+ * Usage:
+ *   aether stake-info <address>          Show stake info for address
+ *   aether stake-info <address> --json    JSON output
+ *   aether stake-info <address> --rpc <url>  Custom RPC endpoint
+ *
+ * SDK wired to: GET /v1/slot, GET /v1/account/<addr>, GET /v1/blockheight
+ */
+
+const path = require('path');
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const { AetherClient } = 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',
+};
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = { address: null, json: false, rpc: null };
+
+  for (let i = 0; i < args.length; i++) {
+    if (!args[i].startsWith('-') && !result.address) {
+      result.address = args[i];
+    } else if (args[i] === '--json' || args[i] === '-j') {
+      result.json = true;
+    } else if ((args[i] === '--rpc' || args[i] === '-r') && args[i + 1]) {
+      result.rpc = args[++i];
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      result.help = true;
+    }
+  }
+  return result;
+}
+
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function stakeInfoCommand() {
+  const opts = parseArgs();
+
+  if (opts.help || !opts.address) {
+    console.log(`
+${C.bright}${C.cyan}aether-cli stake-info${C.reset} — Get stake/account info for an address
+
+${C.bright}USAGE${C.reset}
+    aether stake-info <address> [--json] [--rpc <url>]
+
+${C.bright}OPTIONS${C.reset}
+    --json, -j       Output raw JSON
+    --rpc <url>       RPC endpoint (default: AETHER_RPC or localhost:8899)
+    --help, -h        Show this help
+
+${C.bright}SDK METHODS USED${C.reset}
+    client.getSlot()           → GET /v1/slot
+    client.getAccountInfo(addr) → GET /v1/account/<addr>
+    client.getBlockHeight()     → GET /v1/blockheight
+
+${C.bright}EXAMPLE${C.reset}
+    aether stake-info ATH3abc...def
+`);
+    return;
+  }
+
+  const rpcUrl = opts.rpc || getDefaultRpc();
+  const client = new AetherClient({ rpcUrl });
+
+  try {
+    // Real chain RPC calls — all parallel for speed
+    const [slot, accountInfo, blockHeight] = await Promise.all([
+      client.getSlot().catch(() => null),
+      client.getAccountInfo(opts.address).catch(() => null),
+      client.getBlockHeight().catch(() => null),
+    ]);
+
+    const balance = accountInfo?.lamports != null
+      ? (accountInfo.lamports / 1e9).toFixed(4) + ' AETH'
+      : 'unavailable';
+    const owner = accountInfo?.owner || 'unknown';
+    const executable = accountInfo?.executable ? 'yes' : 'no';
+
+    if (opts.json) {
+      console.log(JSON.stringify({
+        address: opts.address,
+        slot: slot ?? null,
+        block_height: blockHeight ?? null,
+        account: {
+          lamports: accountInfo?.lamports ?? null,
+          balance_aeth: accountInfo?.lamports != null ? (accountInfo.lamports / 1e9).toFixed(4) : null,
+          owner: accountInfo?.owner ?? null,
+          executable: accountInfo?.executable ?? false,
+          rent_epoch: accountInfo?.rent_epoch ?? null,
+        },
+        rpc: rpcUrl,
+        timestamp: new Date().toISOString(),
+      }, null, 2));
+      return;
+    }
+
+    console.log(`\n${C.bright}${C.cyan}── Aether Stake Info ─────────────────────────────────${C.reset}\n`);
+    console.log(`  ${C.dim}Address:${C.reset}   ${opts.address}`);
+    console.log(`  ${C.dim}Balance:${C.reset}   ${C.green}${balance}${C.reset}`);
+    console.log(`  ${C.dim}Owner:${C.reset}     ${owner}`);
+    console.log(`  ${C.dim}Executable:${C.reset} ${executable}`);
+    console.log(`  ${C.dim}Slot:${C.reset}      ${slot ?? 'unavailable'}`);
+    console.log(`  ${C.dim}Block Height:${C.reset} ${blockHeight ?? 'unavailable'}`);
+    console.log(`  ${C.dim}RPC:${C.reset}       ${rpcUrl}\n`);
+    console.log(`  ${C.green}? Real chain RPC calls completed${C.reset}\n`);
+  } catch (error) {
+    console.log(`  ${C.red}? Error: ${error.message}${C.reset}\n`);
+    process.exit(1);
+  }
+}
+
+stakeInfoCommand();
+
+module.exports = { stakeInfoCommand };

package/commands/status.js

@@ -15,9 +15,8 @@
  * Requires AETHER_RPC env var (default: http://127.0.0.1:8899)
  */
 
-const http = require('http');
-const https = require('https');
 const os = require('os');
+const path = require('path');
 
 // ANSI colours
 const C = {
@@ -33,66 +32,20 @@ const C = {
 
 const CLI_VERSION = '1.0.0';
 
+// Import SDK for real blockchain RPC calls
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
 function getDefaultRpc() {
-  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
-}
-
-function httpRequest(rpcUrl, pathStr, timeoutMs = 10000) {
-  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: 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, pathStr, body, timeoutMs = 10000) {
-  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: 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(data); }
-      });
-    });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('Request timeout after ' + timeoutMs + 'ms')); });
-    req.end();
-  });
+function createClient(rpc) {
+  return new aether.AetherClient({ rpcUrl: rpc });
 }
 
 function formatAether(lamports) {
@@ -124,7 +77,7 @@ function loadIdentity() {
 // ---------------------------------------------------------------------------
 
 async function statusCommand() {
-  const args = process.argv.slice(3); // skip "aether status"
+  const args = process.argv.slice(2); // [node, status.js, ...]
   const isJson = args.includes('--json') || args.includes('-j');
   const isCompact = args.includes('--compact');
   const includeValidator = args.includes('--validator');
@@ -168,130 +121,133 @@ async function statusCommand() {
     return;
   }
 
-  printDashboard(data, errors, includeValidator);
+  printDashboard(data, errors, includeValidator, rpc);
 }
 
 async function fetchEpochInfo(rpc) {
-  const [epochResp, slotResp] = await Promise.all([
-    httpPost(rpc, '/v1/epoch/info', { jsonrpc: '2.0', id: 1, method: 'getEpochInfo' }),
-    httpPost(rpc, '/v1Slot', { jsonrpc: '2.0', id: 1, method: 'getSlot' }),
-  ]);
-
-  const epoch = epochResp?.result || {};
-  const currentSlot = slotResp?.result || epoch.currentSlot || 0;
-  const slotsInEpoch = epoch.slotsInEpoch || 432000;
-  const slotIndex = currentSlot % slotsInEpoch;
-  const epochProgress = slotsInEpoch > 0 ? (slotIndex / slotsInEpoch * 100).toFixed(1) : '0';
-
-  // Estimate time remaining (assuming 400ms slots)
-  const slotsRemaining = slotsInEpoch - slotIndex;
-  const secsRemaining = Math.round(slotsRemaining * 0.4);
-  const minsRemaining = Math.round(secsRemaining / 60);
-  const timeStr = minsRemaining >= 60
-    ? `${Math.floor(minsRemaining / 60)}h ${minsRemaining % 60}m`
-    : `${minsRemaining}m`;
-
-  return {
-    epoch: epoch.epoch || 0,
-    absoluteSlot: currentSlot,
-    slotIndex,
-    slotsInEpoch,
-    progress: epochProgress,
-    timeRemaining: timeStr,
-    totalSlots: epoch.totalSlots || 0,
-  };
+  const client = createClient(rpc);
+  try {
+    const epoch = await client.getEpochInfo();
+    const currentSlot = epoch.absoluteSlot || epoch.slot || 0;
+    const slotsInEpoch = epoch.slotsInEpoch || 432000;
+    const slotIndex = epoch.slotIndex || (currentSlot % slotsInEpoch);
+    const epochProgress = slotsInEpoch > 0 ? (slotIndex / slotsInEpoch * 100).toFixed(1) : '0';
+
+    // Estimate time remaining (assuming 400ms slots)
+    const slotsRemaining = slotsInEpoch - slotIndex;
+    const secsRemaining = Math.round(slotsRemaining * 0.4);
+    const minsRemaining = Math.round(secsRemaining / 60);
+    const timeStr = minsRemaining >= 60
+      ? `${Math.floor(minsRemaining / 60)}h ${minsRemaining % 60}m`
+      : `${minsRemaining}m`;
+
+    return {
+      epoch: epoch.epoch || 0,
+      absoluteSlot: currentSlot,
+      slotIndex,
+      slotsInEpoch,
+      progress: epochProgress,
+      timeRemaining: timeStr,
+      totalSlots: epoch.totalSlots || 0,
+    };
+  } catch (e) {
+    throw new Error('Epoch info fetch failed: ' + e.message);
+  }
 }
 
 async function fetchSupplyInfo(rpc) {
-  const resp = await httpPost(rpc, '/v1/supply', { jsonrpc: '2.0', id: 1, method: 'getSupply' });
-  const supply = resp?.result?.value || {};
-  const total = BigInt(supply.total || 0);
-  const circulating = BigInt(supply.circulating || 0);
-  const nonCirculating = BigInt(supply.nonCirculating || 0);
-
-  return {
-    total: total.toString(),
-    totalFormatted: formatAether(total.toString()),
-    circulating: circulating.toString(),
-    circulatingFormatted: formatAether(circulating.toString()),
-    nonCirculating: nonCirculating.toString(),
-    nonCirculatingFormatted: formatAether(nonCirculating.toString()),
-  };
+  const client = createClient(rpc);
+  try {
+    const supply = await client.getSupply();
+    const total = BigInt(supply.total || 0);
+    const circulating = BigInt(supply.circulating || 0);
+    const nonCirculating = BigInt(supply.nonCirculating || 0);
+
+    return {
+      total: total.toString(),
+      totalFormatted: formatAether(total.toString()),
+      circulating: circulating.toString(),
+      circulatingFormatted: formatAether(circulating.toString()),
+      nonCirculating: nonCirculating.toString(),
+      nonCirculatingFormatted: formatAether(nonCirculating.toString()),
+    };
+  } catch (e) {
+    throw new Error('Supply info fetch failed: ' + e.message);
+  }
 }
 
 async function fetchNetworkInfo(rpc) {
-  const [slotResp, blockResp, peersResp] = await Promise.all([
-    httpPost(rpc, '/v1Slot', { jsonrpc: '2.0', id: 1, method: 'getSlot' }),
-    httpPost(rpc, '/v1Block', { jsonrpc: '2.0', id: 1, method: 'getBlockTime', params: [0] }),
-    httpPost(rpc, '/v1Peers', { jsonrpc: '2.0', id: 1, method: 'getClusterPeers' }),
-  ]);
-
-  const blockHeight = slotResp?.result || 0;
-  const blockTime = blockResp?.result || null;
-  const peers = Array.isArray(peersResp?.result) ? peersResp.result : [];
-
-  return {
-    blockHeight,
-    blockTime,
-    peerCount: peers.length,
-    peers: peers.slice(0, 5), // first 5 for detail
-  };
+  const client = createClient(rpc);
+  try {
+    const [slot, blockHeight, peers] = await Promise.all([
+      client.getSlot(),
+      client.getBlockHeight(),
+      client.getClusterPeers(),
+    ]);
+
+    return {
+      blockHeight: blockHeight || slot || 0,
+      blockTime: null,
+      peerCount: Array.isArray(peers) ? peers.length : 0,
+      peers: (Array.isArray(peers) ? peers : []).slice(0, 5),
+    };
+  } catch (e) {
+    throw new Error('Network info fetch failed: ' + e.message);
+  }
 }
 
 async function fetchVersionInfo(rpc) {
+  const client = createClient(rpc);
   try {
-    const resp = await httpPost(rpc, '/v1Version', { jsonrpc: '2.0', id: 1, method: 'getVersion' });
-    return resp?.result || {};
+    return await client.getVersion();
   } catch {
     return {};
   }
 }
 
 async function fetchRewardsSummary(rpc, address) {
-  // Fetch stake accounts for wallet, then fetch rewards for each
-  const allAccountsResp = await httpPost(rpc, '/v1Stake/accounts', {
-    jsonrpc: '2.0', id: 1, method: 'getStakeAccounts', params: [address],
-  }).catch(() => null);
-
-  const stakeAccounts = (allAccountsResp?.result?.value || [])
-    .filter(a => a.owner && (!Array.isArray(a.owner) || a.owner.length > 0))
-    .map(a => a.pubkey || a);
-
-  if (stakeAccounts.length === 0) return null;
-
-  const rewardsResults = await Promise.all(
-    stakeAccounts.slice(0, 10).map(async (sa) => {
-      try {
-        const resp = await httpPost(rpc, '/v1Stake/rewards', {
-          jsonrpc: '2.0', id: 1, method: 'getStakeRewards', params: [sa],
-        });
-        const rewards = resp?.result?.rewards || [];
-        let total = BigInt(0);
-        for (const r of rewards) {
-          total += BigInt(r.estimatedReward || 0);
+  const client = createClient(rpc);
+  try {
+    // Get stake positions for the address (real RPC call via SDK)
+    const stakePositions = await client.getStakePositions(address);
+    
+    if (!stakePositions || stakePositions.length === 0) return null;
+
+    const rewardsResults = await Promise.all(
+      stakePositions.slice(0, 10).map(async (stake) => {
+        try {
+          const stakeAccount = stake.stakeAccount || stake.account || stake.pubkey || stake;
+          const rewards = await client.getRewards(stakeAccount);
+          const total = BigInt(rewards.total || rewards.amount || 0);
+          return { 
+            stakeAccount, 
+            estimatedRewards: total.toString(), 
+            estimatedRewardsFormatted: formatAether(total.toString()) 
+          };
+        } catch {
+          return { stakeAccount: stake.stakeAccount || stake, estimatedRewards: '0', estimatedRewardsFormatted: '0 AETH' };
         }
-        return { stakeAccount: sa, estimatedRewards: total.toString(), estimatedRewardsFormatted: formatAether(total.toString()) };
-      } catch {
-        return { stakeAccount: sa, estimatedRewards: '0', estimatedRewardsFormatted: '0 AETH' };
-      }
-    })
-  );
-
-  let totalRewards = BigInt(0);
-  for (const r of rewardsResults) {
-    totalRewards += BigInt(r.estimatedRewards);
-  }
+      })
+    );
+
+    let totalRewards = BigInt(0);
+    for (const r of rewardsResults) {
+      totalRewards += BigInt(r.estimatedRewards);
+    }
 
-  return {
-    address,
-    totalRewards: totalRewards.toString(),
-    totalRewardsFormatted: formatAether(totalRewards.toString()),
-    activeAccounts: rewardsResults.filter(r => BigInt(r.estimatedRewards) > 0n).length,
-    totalAccounts: rewardsResults.length,
-  };
+    return {
+      address,
+      totalRewards: totalRewards.toString(),
+      totalRewardsFormatted: formatAether(totalRewards.toString()),
+      activeAccounts: rewardsResults.filter(r => BigInt(r.estimatedRewards) > 0n).length,
+      totalAccounts: rewardsResults.length,
+    };
+  } catch (e) {
+    throw new Error('Rewards fetch failed: ' + e.message);
+  }
 }
 
-function printDashboard(data, errors, includeValidator) {
+function printDashboard(data, errors, includeValidator, rpc) {
   const { epoch, supply, network, version, validator, rewards, defaultWallet } = data;
 
   console.log(`\n${C.bright}${C.cyan}  ╔══════════════════════════════════════════════════════════╗${C.reset}`);

package/commands/supply.js

@@ -17,8 +17,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 = {
@@ -36,63 +35,19 @@ const C = {
 const CLI_VERSION = '1.0.0';
 
 // ---------------------------------------------------------------------------
-// Helpers
+// SDK Import - Real blockchain RPC calls via @jellylegsai/aether-sdk
 // ---------------------------------------------------------------------------
 
-function getDefaultRpc() {
-  return process.env.AETHER_RPC || 'http://127.0.0.1:8899';
-}
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
 
-function httpRequest(rpcUrl, pathStr, timeoutMs = 10000) {
-  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: 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();
-  });
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
 }
 
-function httpPost(rpcUrl, pathStr, body, timeoutMs = 10000) {
-  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: 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();
-  });
+/** Create SDK client */
+function createClient(rpcUrl) {
+  return new aether.AetherClient({ rpcUrl });
 }
 
 function formatAether(lamports) {
@@ -110,22 +65,23 @@ function formatLargeNum(n) {
 }
 
 // ---------------------------------------------------------------------------
-// Core supply fetchers
+// Core supply fetchers using SDK
 // ---------------------------------------------------------------------------
 
 /**
- * Fetch the total supply of AETH from the chain.
- * Uses the supply inflation schedule / mint account.
+ * Fetch the total supply of AETH from the chain using SDK.
+ * Makes real RPC call: GET /v1/supply
  */
 async function fetchTotalSupply(rpc) {
+  const client = createClient(rpc);
   try {
-    // Primary: dedicated supply endpoint
-    const res = await httpRequest(rpc, '/v1/supply');
-    if (res && !res.error && (res.total !== undefined || res.supply !== undefined)) {
+    // Primary: SDK getSupply() → GET /v1/supply
+    const res = await client.getSupply();
+    if (res && (res.total !== undefined || res.supply !== undefined)) {
       return {
         total: BigInt(res.total || res.supply?.total || 0),
         circulating: BigInt(res.circulating || res.supply?.circulating || 0),
-        nonCirculating: BigInt(res.non_circulating || res.supply?.non_circulating || 0),
+        nonCirculating: BigInt(res.non_circulating || res.nonCirculating || res.supply?.non_circulating || 0),
         source: 'rpc_v1_supply',
       };
     }
@@ -133,8 +89,8 @@ async function fetchTotalSupply(rpc) {
 
   // Fallback: fetch epoch info which contains total token count
   try {
-    const epochInfo = await httpRequest(rpc, '/v1/epoch-info');
-    if (epochInfo && !epochInfo.error) {
+    const epochInfo = await client.getEpochInfo();
+    if (epochInfo) {
       const totalStaked = BigInt(epochInfo.total_staked || 0);
       const rewardsPerEpoch = BigInt(epochInfo.rewards_per_epoch || '2000000000');
       const currentEpoch = BigInt(epochInfo.epoch || 0);
@@ -159,33 +115,27 @@ async function fetchTotalSupply(rpc) {
 }
 
 /**
- * Fetch staked supply by querying stake program accounts.
+ * Fetch staked supply by querying stake program accounts using SDK.
+ * Makes real RPC call: GET /v1/validators
  */
 async function fetchStakedSupply(rpc) {
+  const client = createClient(rpc);
   try {
-    // Try stake program accounts count / total
-    const res = await httpRequest(rpc, '/v1/stake/total');
-    if (res && !res.error && res.total_staked !== undefined) {
-      return BigInt(res.total_staked);
-    }
-  } catch { /* fall through */ }
-
-  try {
-    // Fallback: sum delegated stake across top validators
-    const validators = await httpRequest(rpc, '/v1/validators?limit=50');
+    // SDK getValidators() → GET /v1/validators
+    const validators = await client.getValidators();
     if (validators && Array.isArray(validators)) {
       let total = BigInt(0);
       for (const v of validators) {
-        total += BigInt(v.delegated_stake || v.stake || 0);
+        total += BigInt(v.delegated_stake || v.stake || v.delegatedStake || 0);
       }
       return total;
     }
   } catch { /* fall through */ }
 
   try {
-    // Last resort: epoch info staked amount
-    const epochInfo = await httpRequest(rpc, '/v1/epoch-info');
-    if (epochInfo && !epochInfo.error && epochInfo.total_staked) {
+    // Last resort: epoch info staked amount via SDK
+    const epochInfo = await client.getEpochInfo();
+    if (epochInfo && epochInfo.total_staked) {
       return BigInt(epochInfo.total_staked);
     }
   } catch { /* fall through */ }
@@ -194,10 +144,11 @@ async function fetchStakedSupply(rpc) {
 }
 
 /**
- * Estimate burned supply by querying accounts at known burn/mint addresses.
- * Uses a set of common Aether burn addresses.
+ * Estimate burned supply by querying accounts at known burn/mint addresses using SDK.
+ * Makes real RPC calls: GET /v1/account/<address>
  */
 async function fetchBurnedSupply(rpc) {
+  const client = createClient(rpc);
   const BURN_ADDRESSES = [
     'ATH1111111111111111111111111111111111111',  // mint authority burn
     'ATH2222222222222222222222222222222222222',  // zero authority
@@ -209,8 +160,9 @@ async function fetchBurnedSupply(rpc) {
   for (const addr of BURN_ADDRESSES) {
     try {
       const rawAddr = addr.startsWith('ATH') ? addr.slice(3) : addr;
-      const account = await httpRequest(rpc, `/v1/account/${encodeURIComponent(rawAddr)}`);
-      if (account && !account.error && account.lamports !== undefined && Number(account.lamports) > 0) {
+      // SDK getAccountInfo() → GET /v1/account/<address>
+      const account = await client.getAccountInfo(rawAddr);
+      if (account && account.lamports !== undefined && Number(account.lamports) > 0) {
         totalBurned += BigInt(account.lamports);
       }
     } catch { /* skip inaccessible addresses */ }