aether-hub 1.2.5 → 1.2.7

package/commands/rewards.js

@@ -6,10 +6,11 @@
  * Shows accumulated rewards, estimated APY, and claimable amounts.
  *
  * Usage:
- *   aether rewards list --address <addr>         List all rewards per stake account
- *   aether rewards list --address <addr> --json  JSON output for scripting
- *   aether rewards claim --address <addr> --account <stakeAcct> [--json]
- *   aether rewards summary --address <addr>      One-line summary of total rewards
+ *   aether rewards list    --address <addr>         List all rewards per stake account
+ *   aether rewards list    --address <addr> --json  JSON output for scripting
+ *   aether rewards claim   --address <addr> --account <stakeAcct> [--json]
+ *   aether rewards summary --address <addr>         One-line summary of total rewards
+ *   aether rewards compound --address <addr> [--account <stakeAcct>] [--json]  Claim and auto-re-stake
  *
  * Requires AETHER_RPC env var or local node running (default: http://127.0.0.1:8899)
  */
@@ -607,6 +608,184 @@ async function rewardsClaim(args) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Rewards compound command — claim and auto-re-stake
+// ---------------------------------------------------------------------------
+
+async function rewardsCompound(args) {
+  const rpc = args.rpc || getDefaultRpc();
+  const isJson = args.json || false;
+  let address = args.address || null;
+  let stakeAccount = args.account || null;
+
+  const config = loadConfig();
+  const rl = createRl();
+
+  if (!address) {
+    const ans = await question(rl, `\n${C.cyan}Enter wallet address: ${C.reset}`);
+    address = ans.trim();
+  }
+
+  if (!address) {
+    console.log(`\n${C.red}✗ No address provided.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // Load wallet for signing
+  const wallet = loadWallet(address);
+  if (!wallet) {
+    console.log(`\n${C.red}✗ Wallet not found locally: ${address}${C.reset}`);
+    console.log(`  ${C.dim}Import it: aether wallet import${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // Fetch stake accounts
+  let stakeAccounts = await fetchWalletStakeAccounts(address);
+  if (stakeAccounts.length === 0) {
+    console.log(`\n${C.red}✗ No stake accounts found for this wallet.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // If --account specified, filter to that one
+  if (stakeAccount) {
+    stakeAccounts = stakeAccounts.filter(sa => sa === stakeAccount);
+    if (stakeAccounts.length === 0) {
+      console.log(`\n${C.red}✗ Stake account not found: ${stakeAccount}${C.reset}\n`);
+      rl.close();
+      return;
+    }
+  }
+
+  console.log(`\n${C.bright}${C.cyan}╔══════════════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bright}${C.cyan}║              Compound Staking Rewards                          ║${C.reset}`);
+  console.log(`${C.bright}${C.cyan}╚══════════════════════════════════════════════════════════════╝${C.reset}\n`);
+  console.log(`  ${C.dim}Wallet:${C.reset} ${C.bright}${address}${C.reset}`);
+  console.log(`  ${C.dim}RPC:${C.reset} ${rpc}`);
+  console.log(`  ${C.dim}Stake accounts to process:${C.reset} ${stakeAccounts.length}\n`);
+
+  // Ask for mnemonic upfront
+  console.log(`${C.yellow}  ⚠ Compound requires your wallet passphrase to sign transactions.${C.reset}`);
+  const mnemonic = await question(rl, `  ${C.cyan}Enter your 12/24-word mnemonic:${C.reset} `);
+  console.log();
+
+  let keypair;
+  try {
+    if (!bip39.validateMnemonic(mnemonic)) {
+      throw new Error('Invalid BIP39 mnemonic');
+    }
+    keypair = deriveKeypair(mnemonic);
+  } catch (err) {
+    console.log(`  ${C.red}✗ Failed to derive keypair: ${err.message}${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  // Verify address matches
+  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}`);
+    console.log(`  ${C.dim}Check your passphrase and try again.${C.reset}\n`);
+    rl.close();
+    return;
+  }
+
+  const compoundResults = [];
+  let totalCompounded = BigInt(0);
+  let successCount = 0;
+
+  for (const sa of stakeAccounts) {
+    console.log(`  ${C.dim}Processing stake account:${C.reset} ${sa.substring(0, 20)}...`);
+
+    try {
+      // Fetch rewards for this stake account
+      const rewardData = await fetchStakeRewards(rpc, sa);
+      if (rewardData.error) {
+        console.log(`    ${C.red}✗ Failed to fetch rewards: ${rewardData.error}${C.reset}`);
+        compoundResults.push({ stake_account: sa, status: 'error', error: rewardData.error });
+        continue;
+      }
+
+      const estimatedRewards = BigInt(rewardData.estimatedRewards);
+      if (estimatedRewards === BigInt(0)) {
+        console.log(`    ${C.yellow}⚠ No rewards to compound${C.reset}`);
+        compoundResults.push({ stake_account: sa, status: 'no_rewards', rewards: '0' });
+        continue;
+      }
+
+      console.log(`    ${C.dim}Rewards to compound:${C.reset} ${rewardData.estimatedRewardsFormatted}`);
+      console.log(`    ${C.dim}Validator:${C.reset} ${rewardData.validator || 'unknown'}`);
+
+      // Build compound transaction (ClaimRewards + Stake in one)
+      const tx = {
+        type: 'CompoundRewards',
+        from: address,
+        stake_account: sa,
+        lamports: estimatedRewards.toString(),
+        validator: rewardData.validator || null,
+        timestamp: Math.floor(Date.now() / 1000),
+      };
+
+      // Sign transaction
+      const txData = JSON.stringify(tx);
+      const txHash = crypto.createHash('sha256').update(txData).digest('hex');
+      const signature = nacl.hash(Buffer.from(txHash, 'hex'));
+      const signatureB58 = bs58.encode(signature.slice(0, 64));
+      tx.signature = signatureB58;
+
+      // Submit transaction
+      const result = await httpPost(rpc, '/v1/tx', tx);
+
+      if (result.success || result.txid || result.signature) {
+        console.log(`    ${C.green}✓ Compounded successfully${C.reset}`);
+        console.log(`      ${C.dim}TX: ${(result.txid || result.signature || signatureB58).substring(0, 20)}...${C.reset}`);
+        totalCompounded += estimatedRewards;
+        successCount++;
+        compoundResults.push({
+          stake_account: sa,
+          status: 'compounded',
+          rewards: estimatedRewards.toString(),
+          rewards_formatted: rewardData.estimatedRewardsFormatted,
+          tx: result.txid || result.signature || signatureB58,
+        });
+      } else {
+        console.log(`    ${C.red}✗ Compound failed: ${result.error || JSON.stringify(result)}${C.reset}`);
+        compoundResults.push({ stake_account: sa, status: 'failed', error: result.error });
+      }
+    } catch (err) {
+      console.log(`    ${C.red}✗ Error: ${err.message}${C.reset}`);
+      compoundResults.push({ stake_account: sa, status: 'error', error: err.message });
+    }
+
+    console.log();
+  }
+
+  rl.close();
+
+  // Summary
+  console.log(`${C.bright}${C.cyan}╔══════════════════════════════════════════════════════════════╗${C.reset}`);
+  console.log(`${C.bright}${C.cyan}║                    Compound Summary                          ║${C.reset}`);
+  console.log(`${C.bright}${C.cyan}╚══════════════════════════════════════════════════════════════╝${C.reset}\n`);
+  console.log(`  ${C.dim}Accounts processed:${C.reset} ${stakeAccounts.length}`);
+  console.log(`  ${C.green}✓ Successful:${C.reset} ${successCount}`);
+  console.log(`  ${C.dim}Total compounded:${C.reset} ${C.green}${formatAether(totalCompounded.toString())}${C.reset}\n`);
+
+  if (isJson) {
+    console.log(JSON.stringify({
+      address,
+      total_compounded_lamports: totalCompounded.toString(),
+      total_compounded_formatted: formatAether(totalCompounded.toString()),
+      accounts_processed: stakeAccounts.length,
+      successful: successCount,
+      results: compoundResults,
+    }, null, 2));
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Parse CLI args
 // ---------------------------------------------------------------------------
@@ -664,12 +843,16 @@ async function main() {
     case 'claim':
       await rewardsClaim(parsed);
       break;
+    case 'compound':
+      await rewardsCompound(parsed);
+      break;
     default:
       console.log(`\n${C.cyan}Usage:${C.reset}`);
       console.log(`  aether rewards list    --address <addr>  List all staking rewards`);
       console.log(`  aether rewards summary --address <addr>  One-line rewards summary`);
       console.log(`  aether rewards pending --address <addr>  Show pending (unclaimed) rewards`);
       console.log(`  aether rewards claim   --address <addr>  [--account <stakeAcct>]  Claim rewards`);
+      console.log(`  aether rewards compound --address <addr> [--account <stakeAcct>]  Claim and re-stake rewards`);
       console.log();
       console.log(`  ${C.dim}--json   Output as JSON`);
       console.log(`  --rpc <url>  Use specific RPC endpoint${C.reset}\n`);

package/commands/sdk-test.js

@@ -0,0 +1,477 @@
+#!/usr/bin/env node
+/**
+ * aether-cli sdk-test
+ *
+ * Comprehensive SDK test suite - exercises all major SDK functions
+ * with REAL HTTP RPC calls to verify the SDK works end-to-end.
+ *
+ * Uses @jellylegsai/aether-sdk for all blockchain interactions.
+ * No stubs, no mocks - every function makes actual RPC calls.
+ *
+ * Usage:
+ *   aether sdk-test                  Run full test suite
+ *   aether sdk-test --rpc <url>      Test against specific RPC endpoint
+ *   aether sdk-test --quick          Run only essential tests (slot, balance, health)
+ *   aether sdk-test --json           JSON output for CI/monitoring
+ *
+ * Default RPC: http://127.0.0.1:8899 (or AETHER_RPC env var)
+ */
+
+const path = require('path');
+const sdkPath = path.join(__dirname, '..', 'sdk', 'index.js');
+const aether = require(sdkPath);
+
+// ANSI colors
+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',
+};
+
+const CLI_VERSION = '1.0.0';
+
+// Test results storage
+const testResults = {
+  passed: 0,
+  failed: 0,
+  skipped: 0,
+  tests: [],
+};
+
+// ---------------------------------------------------------------------------
+// Test Helpers
+// ---------------------------------------------------------------------------
+
+function recordTest(name, passed, error = null, data = null) {
+  testResults.tests.push({ name, passed, error, data });
+  if (passed) {
+    testResults.passed++;
+  } else if (error === 'SKIPPED') {
+    testResults.skipped++;
+  } else {
+    testResults.failed++;
+  }
+}
+
+function printTestResult(name, passed, error, data, asJson) {
+  if (asJson) return;
+  
+  const icon = passed ? `${C.green}✓${C.reset}` : error === 'SKIPPED' ? `${C.yellow}○${C.reset}` : `${C.red}✗${C.reset}`;
+  const status = passed ? `${C.green}PASS${C.reset}` : error === 'SKIPPED' ? `${C.yellow}SKIP${C.reset}` : `${C.red}FAIL${C.reset}`;
+  
+  console.log(`  ${icon} ${name.padEnd(35)} ${status}`);
+  
+  if (data && !passed && error !== 'SKIPPED') {
+    console.log(`      ${C.red}Error: ${error}${C.reset}`);
+  } else if (data && passed) {
+    console.log(`      ${C.dim}${formatData(data)}${C.reset}`);
+  } else if (error && error !== 'SKIPPED') {
+    console.log(`      ${C.red}${error}${C.reset}`);
+  }
+}
+
+function formatData(data) {
+  if (typeof data === 'number') return data.toLocaleString();
+  if (typeof data === 'string') return data.length > 60 ? data.substring(0, 60) + '...' : data;
+  if (typeof data === 'object') {
+    try {
+      return JSON.stringify(data).substring(0, 80);
+    } catch {
+      return '[object]';
+    }
+  }
+  return String(data);
+}
+
+function getDefaultRpc() {
+  return process.env.AETHER_RPC || aether.DEFAULT_RPC_URL || 'http://127.0.0.1:8899';
+}
+
+// ---------------------------------------------------------------------------
+// Test Cases - All use REAL RPC calls via SDK
+// ---------------------------------------------------------------------------
+
+async function testGetSlot(client) {
+  const name = 'getSlot()';
+  try {
+    const slot = await client.getSlot();
+    const passed = typeof slot === 'number' && slot >= 0;
+    recordTest(name, passed, passed ? null : 'Invalid slot number', slot);
+    printTestResult(name, passed, passed ? null : 'Invalid slot number', slot, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetBlockHeight(client) {
+  const name = 'getBlockHeight()';
+  try {
+    const height = await client.getBlockHeight();
+    const passed = typeof height === 'number' && height >= 0;
+    recordTest(name, passed, passed ? null : 'Invalid block height', height);
+    printTestResult(name, passed, passed ? null : 'Invalid block height', height, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetHealth(client) {
+  const name = 'getHealth()';
+  try {
+    const health = await client.getHealth();
+    const passed = health === 'ok' || health === 'healthy' || typeof health === 'string';
+    recordTest(name, passed, passed ? null : 'Unhealthy node', health);
+    printTestResult(name, passed, passed ? null : 'Unhealthy node', health, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetVersion(client) {
+  const name = 'getVersion()';
+  try {
+    const version = await client.getVersion();
+    const passed = version && (version.aetherCore || version.featureSet || Object.keys(version).length > 0);
+    recordTest(name, passed, passed ? null : 'Empty version info', version);
+    printTestResult(name, passed, passed ? null : 'Empty version info', version, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetEpochInfo(client) {
+  const name = 'getEpochInfo()';
+  try {
+    const epoch = await client.getEpochInfo();
+    const passed = epoch && (epoch.epoch !== undefined || epoch.slot !== undefined);
+    recordTest(name, passed, passed ? null : 'Invalid epoch info', epoch);
+    printTestResult(name, passed, passed ? null : 'Invalid epoch info', epoch, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetSupply(client) {
+  const name = 'getSupply()';
+  try {
+    const supply = await client.getSupply();
+    const passed = supply && (supply.total !== undefined || supply.circulating !== undefined);
+    recordTest(name, passed, passed ? null : 'Invalid supply info', supply);
+    printTestResult(name, passed, passed ? null : 'Invalid supply info', supply, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetTPS(client) {
+  const name = 'getTPS()';
+  try {
+    const tps = await client.getTPS();
+    const passed = tps !== null && tps !== undefined;
+    recordTest(name, passed, passed ? null : 'Invalid TPS', tps);
+    printTestResult(name, passed, passed ? null : 'Invalid TPS', tps, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetFees(client) {
+  const name = 'getFees()';
+  try {
+    const fees = await client.getFees();
+    const passed = fees && Object.keys(fees).length > 0;
+    recordTest(name, passed, passed ? null : 'Empty fee info', fees);
+    printTestResult(name, passed, passed ? null : 'Empty fee info', fees, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetValidators(client) {
+  const name = 'getValidators()';
+  try {
+    const validators = await client.getValidators();
+    const passed = Array.isArray(validators);
+    recordTest(name, passed, passed ? null : 'Not an array', validators ? validators.length : null);
+    printTestResult(name, passed, passed ? null : 'Not an array', validators ? validators.length : null, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetClusterPeers(client) {
+  const name = 'getClusterPeers()';
+  try {
+    const peers = await client.getClusterPeers();
+    const passed = Array.isArray(peers);
+    recordTest(name, passed, passed ? null : 'Not an array', peers ? peers.length : null);
+    printTestResult(name, passed, passed ? null : 'Not an array', peers ? peers.length : null, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetRecentBlockhash(client) {
+  const name = 'getRecentBlockhash()';
+  try {
+    const blockhash = await client.getRecentBlockhash();
+    const passed = blockhash && (blockhash.blockhash || blockhash.value);
+    recordTest(name, passed, passed ? null : 'No blockhash returned', blockhash);
+    printTestResult(name, passed, passed ? null : 'No blockhash returned', blockhash, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetAccountInfo(client, testAddress) {
+  const name = 'getAccountInfo()';
+  try {
+    // Use system program address as test (always exists)
+    const address = testAddress || '11111111111111111111111111111111';
+    const account = await client.getAccountInfo(address);
+    const passed = account && (account.lamports !== undefined || account.owner !== undefined);
+    recordTest(name, passed, passed ? null : 'Invalid account info', account);
+    printTestResult(name, passed, passed ? null : 'Invalid account info', account, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetBalance(client, testAddress) {
+  const name = 'getBalance()';
+  try {
+    const address = testAddress || '11111111111111111111111111111111';
+    const balance = await client.getBalance(address);
+    const passed = typeof balance === 'number' && balance >= 0;
+    recordTest(name, passed, passed ? null : 'Invalid balance', balance);
+    printTestResult(name, passed, passed ? null : 'Invalid balance', balance, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testGetSlotProduction(client) {
+  const name = 'getSlotProduction()';
+  try {
+    const stats = await client.getSlotProduction();
+    const passed = stats && Object.keys(stats).length > 0;
+    recordTest(name, passed, passed ? null : 'Empty slot production stats', stats);
+    printTestResult(name, passed, passed ? null : 'Empty slot production stats', stats, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testConvenienceFunctions(rpcUrl) {
+  const name = 'Convenience Functions';
+  try {
+    // Test multiple convenience functions
+    const [slot, health, blockHeight] = await Promise.all([
+      aether.getSlot(),
+      aether.getHealth(),
+      aether.getBlockHeight(),
+    ]);
+    
+    const passed = typeof slot === 'number' && health && typeof blockHeight === 'number';
+    recordTest(name, passed, passed ? null : 'One or more functions failed', { slot, health, blockHeight });
+    printTestResult(name, passed, passed ? null : 'Function failed', { slot, health, blockHeight }, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+async function testPingUtility(rpcUrl) {
+  const name = 'ping()';
+  try {
+    const result = await aether.ping(rpcUrl);
+    const passed = result && result.ok === true && result.latency >= 0;
+    recordTest(name, passed, passed ? null : 'Ping failed', result);
+    printTestResult(name, passed, passed ? null : 'Ping failed', result, false);
+    return passed;
+  } catch (err) {
+    recordTest(name, false, err.message);
+    printTestResult(name, false, err.message, null, false);
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test Runner
+// ---------------------------------------------------------------------------
+
+async function runFullTestSuite(client, rpcUrl) {
+  console.log(`\n${C.bright}${C.cyan}═══ Aether SDK Test Suite ═══${C.reset}\n`);
+  console.log(`  ${C.dim}RPC Endpoint: ${rpcUrl}${C.reset}`);
+  console.log(`  ${C.dim}Testing @jellylegsai/aether-sdk v1.0.0${C.reset}\n`);
+  console.log(`  ${C.bright}Running tests...${C.reset}\n`);
+
+  // Core RPC methods
+  console.log(`  ${C.cyan}── Core RPC Methods ──${C.reset}`);
+  await testGetSlot(client);
+  await testGetBlockHeight(client);
+  await testGetHealth(client);
+  await testGetVersion(client);
+  await testGetEpochInfo(client);
+  
+  console.log(`\n  ${C.cyan}── Network & Supply ──${C.reset}`);
+  await testGetSupply(client);
+  await testGetTPS(client);
+  await testGetFees(client);
+  await testGetValidators(client);
+  await testGetClusterPeers(client);
+  
+  console.log(`\n  ${C.cyan}── Transaction Support ──${C.reset}`);
+  await testGetRecentBlockhash(client);
+  await testGetSlotProduction(client);
+  
+  console.log(`\n  ${C.cyan}── Account Operations ──${C.reset}`);
+  await testGetAccountInfo(client);
+  await testGetBalance(client);
+  
+  console.log(`\n  ${C.cyan}── Convenience Functions ──${C.reset}`);
+  await testConvenienceFunctions(rpcUrl);
+  await testPingUtility(rpcUrl);
+}
+
+async function runQuickTest(client, rpcUrl) {
+  console.log(`\n${C.bright}${C.cyan}═══ Aether SDK Quick Test ═══${C.reset}\n`);
+  console.log(`  ${C.dim}RPC Endpoint: ${rpcUrl}${C.reset}\n`);
+  
+  console.log(`  ${C.cyan}── Essential Tests ──${C.reset}`);
+  await testGetSlot(client);
+  await testGetHealth(client);
+  await testGetBalance(client);
+}
+
+function printSummary(asJson) {
+  if (asJson) {
+    console.log(JSON.stringify({
+      total: testResults.passed + testResults.failed + testResults.skipped,
+      passed: testResults.passed,
+      failed: testResults.failed,
+      skipped: testResults.skipped,
+      tests: testResults.tests,
+      cli_version: CLI_VERSION,
+      timestamp: new Date().toISOString(),
+    }, null, 2));
+    return;
+  }
+  
+  console.log(`\n${C.bright}${C.cyan}═══ Test Summary ═══${C.reset}\n`);
+  
+  const total = testResults.passed + testResults.failed + testResults.skipped;
+  const passRate = total > 0 ? ((testResults.passed / total) * 100).toFixed(1) : 0;
+  
+  console.log(`  ${C.bright}Total:${C.reset}  ${total}`);
+  console.log(`  ${C.green}Passed:${C.reset} ${testResults.passed}`);
+  console.log(`  ${C.red}Failed:${C.reset} ${testResults.failed}`);
+  console.log(`  ${C.yellow}Skipped:${C.reset} ${testResults.skipped}`);
+  console.log(`  ${C.bright}Pass Rate:${C.reset} ${passRate}%\n`);
+  
+  if (testResults.failed > 0) {
+    console.log(`  ${C.red}── Failed Tests ──${C.reset}`);
+    testResults.tests.filter(t => !t.passed && t.error !== 'SKIPPED').forEach(t => {
+      console.log(`    ${C.red}✗ ${t.name}: ${t.error}${C.reset}`);
+    });
+    console.log();
+  }
+  
+  if (testResults.failed === 0) {
+    console.log(`  ${C.green}✓ All tests passed!${C.reset}\n`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function sdkTestCommand() {
+  const args = process.argv.slice(2);
+  const asJson = args.includes('--json') || args.includes('-j');
+  const isQuick = args.includes('--quick') || args.includes('-q');
+  
+  const rpcIdx = args.findIndex(a => a === '--rpc' || a === '-r');
+  const rpcUrl = rpcIdx !== -1 && args[rpcIdx + 1] ? args[rpcIdx + 1] : getDefaultRpc();
+  
+  if (!asJson) {
+    console.log(`\n${C.bright}${C.cyan}╔═══════════════════════════════════════════════════════════╗${C.reset}`);
+    console.log(`${C.bright}${C.cyan}║         AETHER SDK COMPREHENSIVE TEST SUITE              ║${C.reset}`);
+    console.log(`${C.bright}${C.cyan}╚═══════════════════════════════════════════════════════════╝${C.reset}\n`);
+  }
+  
+  const client = new aether.AetherClient({ rpcUrl });
+  
+  if (isQuick) {
+    await runQuickTest(client, rpcUrl);
+  } else {
+    await runFullTestSuite(client, rpcUrl);
+  }
+  
+  printSummary(asJson);
+  
+  // Exit with error if tests failed
+  if (testResults.failed > 0) {
+    process.exit(1);
+  }
+}
+
+// Export for module use
+module.exports = { sdkTestCommand };
+
+// Run if called directly
+if (require.main === module) {
+  sdkTestCommand().catch(err => {
+    console.error(`${C.red}✗ Test suite failed: ${err.message}${C.reset}`);
+    process.exit(1);
+  });
+}