@jellylegsai/aether-cli 1.8.0

package/sdk/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@jellylegsai/aether-sdk",
+  "version": "1.1.0",
+  "description": "Official Aether Blockchain SDK - Real HTTP RPC calls to Aether chain",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "rpc.js",
+    "test.js",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node test.js",
+    "build": "node -e \"require('./index.js'); console.log('SDK build OK')\""
+  },
+  "keywords": [
+    "aether",
+    "blockchain",
+    "sdk",
+    "crypto",
+    "rpc",
+    "web3"
+  ],
+  "author": "Jelly-legs AI Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jelly-legs-ai/Jelly-legs-unsteady-workshop"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/sdk/rpc.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * @jellylegsai/aether-sdk - RPC Client
+ * 
+ * Low-level HTTP RPC client for Aether blockchain with retry logic.
+ * All functions make REAL HTTP calls to the blockchain RPC endpoint.
+ * No stubs, no mocks.
+ * 
+ * Features:
+ * - Retry logic with exponential backoff
+ * - Enhanced error handling for network timeouts
+ * - Rate limiting support
+ */
+
+const http = require('http');
+const https = require('https');
+
+const DEFAULT_RPC = process.env.AETHER_RPC || 'http://127.0.0.1:8899';
+
+// Retry configuration
+const DEFAULT_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+const DEFAULT_BACKOFF_MULTIPLIER = 2;
+const DEFAULT_MAX_RETRY_DELAY_MS = 30000;
+
+/**
+ * Check if error is retryable
+ */
+function isRetryableError(error) {
+  if (!error) return false;
+  
+  // Network errors
+  if (error.code === 'ECONNREFUSED') return true;
+  if (error.code === 'ENOTFOUND') return true;
+  if (error.code === 'ETIMEDOUT') return true;
+  if (error.code === 'ECONNRESET') return true;
+  if (error.code === 'EPIPE') return true;
+  
+  // Timeout errors
+  if (error.message && error.message.includes('timeout')) return true;
+  
+  // HTTP errors
+  if (error.statusCode >= 500) return true;
+  if (error.statusCode === 429) return true; // Rate limit
+  
+  return false;
+}
+
+/**
+ * Calculate delay for exponential backoff with jitter
+ */
+function calculateDelay(attempt, baseDelay = DEFAULT_RETRY_DELAY_MS, maxDelay = DEFAULT_MAX_RETRY_DELAY_MS) {
+  const delay = baseDelay * Math.pow(DEFAULT_BACKOFF_MULTIPLIER, attempt);
+  const jitter = Math.random() * 100; // Add up to 100ms jitter
+  return Math.min(delay + jitter, maxDelay);
+}
+
+/**
+ * Make a GET request to the RPC endpoint with retry logic
+ * @param {string} rpcUrl - RPC endpoint URL
+ * @param {string} path - API path (e.g., /v1/slot)
+ * @param {number} timeout - Request timeout in ms
+ * @param {number} retries - Number of retry attempts
+ * @returns {Promise<object>} Parsed JSON response
+ */
+async function rpcGet(rpcUrl, path, timeout = 8000, retries = DEFAULT_RETRIES) {
+  let lastError = null;
+  
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const result = await _rpcGetInternal(rpcUrl, path, timeout);
+      return result;
+    } catch (error) {
+      lastError = error;
+      
+      // Don't retry if not retryable or on last attempt
+      if (attempt === retries || !isRetryableError(error)) {
+        throw error;
+      }
+      
+      // Calculate and wait for backoff
+      const delay = calculateDelay(attempt);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+  
+  throw lastError;
+}
+
+/**
+ * Internal: Make HTTP GET request
+ */
+function _rpcGetInternal(rpcUrl, path, timeout) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, rpcUrl);
+    const isHttps = url.protocol === 'https:';
+    const lib = isHttps ? https : http;
+
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'GET',
+      timeout,
+      headers: { 
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'User-Agent': 'aether-sdk/1.0.0',
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.error) {
+            const err = new Error(parsed.error.message || JSON.stringify(parsed.error));
+            err.statusCode = res.statusCode;
+            err.responseData = parsed;
+            reject(err);
+          } else {
+            resolve(parsed);
+          }
+        } catch (e) {
+          resolve({ raw: data });
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      err.rpcUrl = rpcUrl;
+      err.path = path;
+      reject(err);
+    });
+    
+    req.on('timeout', () => {
+      req.destroy();
+      const err = new Error(`RPC request timeout after ${timeout}ms`);
+      err.code = 'ETIMEDOUT';
+      err.rpcUrl = rpcUrl;
+      err.path = path;
+      reject(err);
+    });
+    
+    req.end();
+  });
+}
+
+/**
+ * Make a POST request to the RPC endpoint with retry logic
+ * @param {string} rpcUrl - RPC endpoint URL
+ * @param {string} path - API path
+ * @param {object} body - Request body (will be JSON.stringify'd)
+ * @param {number} timeout - Request timeout in ms
+ * @param {number} retries - Number of retry attempts
+ * @returns {Promise<object>} Parsed JSON response
+ */
+async function rpcPost(rpcUrl, path, body, timeout = 8000, retries = DEFAULT_RETRIES) {
+  let lastError = null;
+  
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const result = await _rpcPostInternal(rpcUrl, path, body, timeout);
+      return result;
+    } catch (error) {
+      lastError = error;
+      
+      // Don't retry if not retryable or on last attempt
+      if (attempt === retries || !isRetryableError(error)) {
+        throw error;
+      }
+      
+      // Calculate and wait for backoff
+      const delay = calculateDelay(attempt);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+  
+  throw lastError;
+}
+
+/**
+ * Internal: Make HTTP POST request
+ */
+function _rpcPostInternal(rpcUrl, path, body, timeout) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, rpcUrl);
+    const isHttps = url.protocol === 'https:';
+    const lib = isHttps ? https : http;
+    const bodyStr = JSON.stringify(body);
+
+    const req = lib.request({
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'POST',
+      timeout,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'Content-Length': Buffer.byteLength(bodyStr),
+        'User-Agent': 'aether-sdk/1.0.0',
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.error) {
+            const err = new Error(parsed.error.message || JSON.stringify(parsed.error));
+            err.statusCode = res.statusCode;
+            err.responseData = parsed;
+            reject(err);
+          } else {
+            resolve(parsed);
+          }
+        } catch (e) {
+          resolve(data);
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      err.rpcUrl = rpcUrl;
+      err.path = path;
+      reject(err);
+    });
+    
+    req.on('timeout', () => {
+      req.destroy();
+      const err = new Error(`RPC request timeout after ${timeout}ms`);
+      err.code = 'ETIMEDOUT';
+      err.rpcUrl = rpcUrl;
+      err.path = path;
+      reject(err);
+    });
+
+    req.write(bodyStr);
+    req.end();
+  });
+}
+
+module.exports = {
+  rpcGet,
+  rpcPost,
+  DEFAULT_RPC,
+  DEFAULT_RETRIES,
+  DEFAULT_RETRY_DELAY_MS,
+  DEFAULT_BACKOFF_MULTIPLIER,
+  DEFAULT_MAX_RETRY_DELAY_MS,
+  isRetryableError,
+  calculateDelay,
+};

package/sdk/test.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * @jellylegsai/aether-sdk - Test Script
+ * 
+ * Tests all SDK functions with REAL RPC calls to http://127.0.0.1:8899
+ */
+
+const aether = require('./index');
+
+const C = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+};
+
+async function test(name, fn) {
+  try {
+    const result = await fn();
+    console.log(`  ${C.green}✓${C.reset} ${name}`);
+    return { ok: true, result };
+  } catch (err) {
+    console.log(`  ${C.red}✗${C.reset} ${name}: ${err.message}`);
+    return { ok: false, error: err.message };
+  }
+}
+
+async function main() {
+  console.log(`\n${C.cyan}══ @jellylegsai/aether-sdk Test Suite ══${C.reset}\n`);
+  console.log(`  ${C.dim}RPC Endpoint: ${aether.DEFAULT_RPC_URL}${C.reset}\n`);
+
+  const results = [];
+
+  // Test ping first
+  results.push(await test('ping()', async () => {
+    const ping = await aether.ping();
+    if (!ping.ok) throw new Error(ping.error);
+    return ping;
+  }));
+
+  // Test chain queries
+  results.push(await test('getSlot()', () => aether.getSlot()));
+  results.push(await test('getBlockHeight()', () => aether.getBlockHeight()));
+  results.push(await test('getEpoch()', () => aether.getEpoch()));
+  results.push(await test('getTPS()', () => aether.getTPS()));
+  results.push(await test('getSupply()', () => aether.getSupply()));
+  results.push(await test('getFees()', () => aether.getFees()));
+  results.push(await test('getValidators()', () => aether.getValidators()));
+  results.push(await test('getPeers()', () => aether.getPeers()));
+  results.push(await test('getHealth()', () => aether.getHealth()));
+  results.push(await test('getSlotProduction()', () => aether.getSlotProduction()));
+
+  // Test with a sample address (may not exist, but tests the call)
+  const testAddress = 'ATH111111111111111111111111111111111';
+  results.push(await test(`getAccount('${testAddress.substring(0, 12)}...')`, () => 
+    aether.getAccount(testAddress)
+  ));
+  results.push(await test(`getBalance('${testAddress.substring(0, 12)}...')`, () => 
+    aether.getBalance(testAddress)
+  ));
+  results.push(await test(`getStakePositions('${testAddress.substring(0, 12)}...')`, () => 
+    aether.getStakePositions(testAddress)
+  ));
+  results.push(await test(`getRewards('${testAddress.substring(0, 12)}...')`, () => 
+    aether.getRewards(testAddress)
+  ));
+
+  // Summary
+  const passed = results.filter(r => r.ok).length;
+  const failed = results.filter(r => !r.ok).length;
+
+  console.log();
+  if (failed === 0) {
+    console.log(`  ${C.green}══ All ${passed} tests passed! ══${C.reset}\n`);
+  } else {
+    console.log(`  ${C.yellow}══ ${passed} passed, ${failed} failed ══${C.reset}`);
+    console.log(`  ${C.dim}  (Failures may be due to RPC not running or test data not existing)${C.reset}\n`);
+  }
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main();

package/test/doctor.test.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * Test suite for aether-cli doctor command
+ */
+
+const { checkCPU, checkMemory, checkDisk, checkNetwork, checkFirewall } = require('../commands/doctor');
+
+console.log('Running aether-cli doctor tests...\n');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    const result = fn();
+    console.log(`✅ ${name}`);
+    passed++;
+    return result;
+  } catch (error) {
+    console.log(`❌ ${name}: ${error.message}`);
+    failed++;
+    return null;
+  }
+}
+
+// Test CPU check
+test('checkCPU returns valid structure', () => {
+  const cpu = checkCPU();
+  if (!cpu.section) throw new Error('Missing section');
+  if (!('passed' in cpu)) throw new Error('Missing passed');
+  if (!cpu.message) throw new Error('Missing message');
+  console.log(`   CPU: ${cpu.physicalCores} cores, ${cpu.model}`);
+  return cpu;
+});
+
+// Test Memory check
+test('checkMemory returns valid structure', () => {
+  const mem = checkMemory();
+  if (!mem.section) throw new Error('Missing section');
+  if (!('passed' in mem)) throw new Error('Missing passed');
+  if (!mem.message) throw new Error('Missing message');
+  console.log(`   Memory: ${mem.total} total, ${mem.available} available`);
+  return mem;
+});
+
+// Test Disk check
+test('checkDisk returns valid structure', () => {
+  const disk = checkDisk();
+  if (!disk.section) throw new Error('Missing section');
+  if (!('passed' in disk)) throw new Error('Missing passed');
+  if (!disk.message) throw new Error('Missing message');
+  console.log(`   Disk: ${disk.total} total, ${disk.free} free`);
+  return disk;
+});
+
+// Test Network check
+test('checkNetwork returns valid structure', () => {
+  const net = checkNetwork();
+  if (!net.section) throw new Error('Missing section');
+  if (!('passed' in net)) throw new Error('Missing passed');
+  console.log(`   Network: ${net.publicIP}`);
+  return net;
+});
+
+// Test Firewall check
+test('checkFirewall returns valid structure', () => {
+  const fw = checkFirewall();
+  if (!fw.section) throw new Error('Missing section');
+  if (!('passed' in fw)) throw new Error('Missing passed');
+  console.log(`   Firewall: P2P=${fw.p2p}, RPC=${fw.rpc}, SSH=${fw.ssh}`);
+  return fw;
+});
+
+// Summary
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/validator-identity.json

@@ -0,0 +1,4 @@
+{
+  "pubkey": "2LKAbw8SykbpqU4VeHuhKKW97HWMzp6TB2sGb1UqsZFQ",
+  "secret": "8ataEJXSePVGf922cCZxspPb3FCErgqVzwPyXPfTkPSg"
+}