evm-rpc-checker 1.0.0

package/README.md

@@ -0,0 +1,86 @@
+# evm-rpc-checker
+
+A CLI tool for analyzing EVM-compatible blockchain RPC endpoints. Performs 10 automated tests and outputs a comprehensive quality score.
+
+## Install
+
+```bash
+npm i -g evm-rpc-checker
+```
+
+## Usage
+
+```bash
+evm-rpc-checker <rpc-url>
+
+# or without installing
+npx evm-rpc-checker https://ethereum-rpc.publicnode.com
+```
+
+## Example Output
+
+```
+  EVM RPC Checker
+  ──────────────────────────────────────────────────
+  Target: https://ethereum-rpc.publicnode.com
+
+  Chain:  Ethereum Mainnet (ID: 1)
+  Block:  #24,696,724
+
+  ⚡  Connectivity  PASS
+     Chain ID: 1
+     Chain: Ethereum Mainnet
+     Latest Block: 24,696,724
+     Latency: 332 ms
+
+  ⏱  Latency  PASS
+     Avg: 332 ms
+     Min: 304 ms
+     Max: 409 ms
+     Jitter: 105 ms
+
+  🌐  CORS  PASS
+     Allow-Origin: *
+     Browser OK: Yes
+
+  📦  Batch Request  PASS
+     Supported: Yes
+     Responses: 3/3
+
+  🔌  WebSocket  PASS
+  📚  Archive Node  PASS
+  🔧  Methods  PASS (6/7)
+  🚀  Throughput  PASS (3.0 req/s)
+  🧩  Consistency  PASS
+  ⛽  Gas Tracker  PASS
+
+  ──────────────────────────────────────────────────
+  Overall Score:  88/100  ██████████████████░░
+```
+
+## Test Suites
+
+| Test | Description |
+|------|-------------|
+| **Connectivity** | `eth_chainId`, `eth_blockNumber`, `net_version` |
+| **Latency** | Avg/min/max latency and jitter over 5 requests |
+| **CORS** | CORS header validation via OPTIONS preflight |
+| **Batch Request** | JSON-RPC batch request support |
+| **WebSocket** | HTTP-to-WS/WSS upgrade support |
+| **Archive Node** | Historical state query at block #1 |
+| **Methods** | 7 RPC methods including trace/debug |
+| **Throughput** | Sequential request throughput (req/s) |
+| **Consistency** | Block height variance across 3 queries |
+| **Gas Tracker** | Gas price, EIP-1559 base fee and priority fees |
+
+## Requirements
+
+- Node.js >= 18
+
+## Related
+
+Desktop app with GUI available at [github.com/lolieatapple/rpc-checker](https://github.com/lolieatapple/rpc-checker)
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,519 @@
+#!/usr/bin/env node
+
+// src/index.ts
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  bgGreen: "\x1B[42m",
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m"
+};
+var KNOWN_CHAINS = {
+  1: "Ethereum Mainnet",
+  5: "Goerli",
+  11155111: "Sepolia",
+  56: "BNB Smart Chain",
+  137: "Polygon",
+  42161: "Arbitrum One",
+  10: "Optimism",
+  43114: "Avalanche C-Chain",
+  250: "Fantom Opera",
+  100: "Gnosis Chain",
+  8453: "Base",
+  324: "zkSync Era",
+  59144: "Linea",
+  534352: "Scroll",
+  1101: "Polygon zkEVM",
+  5000: "Mantle",
+  81457: "Blast",
+  34443: "Mode",
+  169: "Manta Pacific",
+  7777777: "Zora",
+  2222: "Kava EVM",
+  1284: "Moonbeam",
+  1285: "Moonriver",
+  42220: "Celo",
+  25: "Cronos",
+  1088: "Metis",
+  128: "HECO",
+  66: "OKXChain"
+};
+function fmtMs(ms) {
+  return ms < 1 ? "<1 ms" : ms < 1000 ? `${Math.round(ms)} ms` : `${(ms / 1000).toFixed(2)} s`;
+}
+async function rpcCall(rpcUrl, method, params = []) {
+  const body = JSON.stringify({ jsonrpc: "2.0", method, params, id: Date.now() });
+  const start = performance.now();
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const res = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    const latency = performance.now() - start;
+    const data = await res.json();
+    return { success: true, data, latency, status: res.status };
+  } catch (err) {
+    return { success: false, error: err.message, latency: performance.now() - start };
+  }
+}
+async function corsCheck(rpcUrl) {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const res = await fetch(rpcUrl, {
+      method: "OPTIONS",
+      headers: {
+        Origin: "http://localhost:3000",
+        "Access-Control-Request-Method": "POST",
+        "Access-Control-Request-Headers": "Content-Type"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    const headers = {};
+    for (const [k, v] of res.headers.entries()) {
+      if (k.startsWith("access-control"))
+        headers[k] = v;
+    }
+    return { success: true, status: res.status, headers };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+async function batchCall(rpcUrl, calls) {
+  const body = JSON.stringify(calls.map((c2, i) => ({ jsonrpc: "2.0", method: c2.method, params: c2.params, id: i + 1 })));
+  const start = performance.now();
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 15000);
+    const res = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    const latency = performance.now() - start;
+    const data = await res.json();
+    return { success: true, data, latency };
+  } catch (err) {
+    return { success: false, error: err.message, latency: performance.now() - start };
+  }
+}
+async function wsCheck(rpcUrl) {
+  let wsUrl = rpcUrl;
+  if (wsUrl.startsWith("https://"))
+    wsUrl = wsUrl.replace("https://", "wss://");
+  else if (wsUrl.startsWith("http://"))
+    wsUrl = wsUrl.replace("http://", "ws://");
+  return new Promise((resolve) => {
+    try {
+      const ws = new WebSocket(wsUrl);
+      const timer = setTimeout(() => {
+        ws.close();
+        resolve({ success: false, error: "Connection timeout (5s)" });
+      }, 5000);
+      ws.onopen = () => {
+        ws.send(JSON.stringify({ jsonrpc: "2.0", method: "eth_blockNumber", params: [], id: 1 }));
+      };
+      ws.onmessage = (event) => {
+        clearTimeout(timer);
+        ws.close();
+        try {
+          const data = JSON.parse(String(event.data));
+          resolve({ success: true, data, wsUrl });
+        } catch {
+          resolve({ success: false, error: "Invalid JSON response" });
+        }
+      };
+      ws.onerror = () => {
+        clearTimeout(timer);
+        resolve({ success: false, error: "WebSocket connection failed" });
+      };
+    } catch (err) {
+      resolve({ success: false, error: err.message });
+    }
+  });
+}
+function statusIcon(status) {
+  switch (status) {
+    case "pass":
+      return `${c.green}PASS${c.reset}`;
+    case "fail":
+      return `${c.red}FAIL${c.reset}`;
+    case "warn":
+      return `${c.yellow}WARN${c.reset}`;
+  }
+}
+function printHeader(rpcUrl) {
+  console.log();
+  console.log(`${c.bold}${c.cyan}  EVM RPC Checker${c.reset}`);
+  console.log(`${c.gray}  ${"─".repeat(50)}${c.reset}`);
+  console.log(`${c.gray}  Target: ${c.white}${rpcUrl}${c.reset}`);
+  console.log();
+}
+function printChainInfo(chainId, chainName, blockNumber) {
+  console.log(`${c.blue}  Chain:${c.reset}  ${chainName} ${c.dim}(ID: ${chainId})${c.reset}`);
+  console.log(`${c.blue}  Block:${c.reset}  #${blockNumber.toLocaleString()}`);
+  console.log();
+}
+function printTestResult(result) {
+  console.log(`  ${result.icon}  ${c.bold}${result.name}${c.reset}  ${statusIcon(result.status)}`);
+  if (result.message) {
+    console.log(`     ${c.dim}${result.message}${c.reset}`);
+  }
+  for (const d of result.details) {
+    console.log(`     ${c.gray}${d.label}:${c.reset} ${d.value}`);
+  }
+  console.log();
+}
+function printScore(score) {
+  const color = score >= 80 ? c.green : score >= 50 ? c.yellow : c.red;
+  const bar = "█".repeat(Math.round(score / 5)) + "░".repeat(20 - Math.round(score / 5));
+  console.log(`${c.gray}  ${"─".repeat(50)}${c.reset}`);
+  console.log(`  ${c.bold}Overall Score:${c.reset}  ${color}${c.bold}${score}${c.reset}/100  ${color}${bar}${c.reset}`);
+  console.log();
+}
+function printProgress(current, total, name) {
+  const pct = Math.round(current / total * 100);
+  const filled = Math.round(pct / 5);
+  const bar = "█".repeat(filled) + "░".repeat(20 - filled);
+  process.stdout.write(`\r  ${c.cyan}${bar}${c.reset} ${pct}% ${c.dim}${name}...${c.reset}   `);
+}
+function clearProgress() {
+  process.stdout.write("\r" + " ".repeat(70) + "\r");
+}
+var TESTS = [
+  { id: "connectivity", name: "Connectivity", icon: "⚡" },
+  { id: "latency", name: "Latency", icon: "⏱" },
+  { id: "cors", name: "CORS", icon: "\uD83C\uDF10" },
+  { id: "batch", name: "Batch Request", icon: "\uD83D\uDCE6" },
+  { id: "websocket", name: "WebSocket", icon: "\uD83D\uDD0C" },
+  { id: "archive", name: "Archive Node", icon: "\uD83D\uDCDA" },
+  { id: "methods", name: "Methods", icon: "\uD83D\uDD27" },
+  { id: "throughput", name: "Throughput", icon: "\uD83D\uDE80" },
+  { id: "consistency", name: "Consistency", icon: "\uD83E\uDDE9" },
+  { id: "gastracker", name: "Gas Tracker", icon: "⛽" }
+];
+async function runAnalysis(rpcUrl) {
+  printHeader(rpcUrl);
+  const results = [];
+  let completed = 0;
+  const total = TESTS.length;
+  printProgress(completed, total, "Connectivity");
+  let chainId = 0;
+  let blockNumber = 0;
+  try {
+    const [chainRes, blockRes, netRes] = await Promise.all([
+      rpcCall(rpcUrl, "eth_chainId"),
+      rpcCall(rpcUrl, "eth_blockNumber"),
+      rpcCall(rpcUrl, "net_version")
+    ]);
+    if (!chainRes.success || chainRes.data?.error)
+      throw new Error(chainRes.data?.error?.message || chainRes.error || "Cannot connect");
+    chainId = parseInt(chainRes.data.result, 16);
+    blockNumber = parseInt(blockRes.data?.result || "0", 16);
+    const netVersion = netRes.data?.result || "N/A";
+    const chainName = KNOWN_CHAINS[chainId] || `Unknown Chain (${chainId})`;
+    results.push({
+      name: "Connectivity",
+      icon: "⚡",
+      status: "pass",
+      score: 10,
+      details: [
+        { label: "Chain ID", value: String(chainId) },
+        { label: "Chain", value: chainName },
+        { label: "Latest Block", value: blockNumber.toLocaleString() },
+        { label: "Net Version", value: netVersion },
+        { label: "Latency", value: fmtMs(chainRes.latency) }
+      ]
+    });
+    completed++;
+    clearProgress();
+    printChainInfo(chainId, chainName, blockNumber);
+  } catch (e) {
+    clearProgress();
+    results.push({ name: "Connectivity", icon: "⚡", status: "fail", score: 0, details: [], message: `Connection failed: ${e.message}` });
+    printTestResult(results[0]);
+    console.log(`  ${c.red}${c.bold}Connectivity test failed. Cannot continue.${c.reset}`);
+    console.log();
+    return;
+  }
+  async function runTest(id, name, icon, fn) {
+    printProgress(completed, total, name);
+    try {
+      const result = await fn();
+      results.push({ name, icon, ...result });
+    } catch (e) {
+      results.push({ name, icon, status: "fail", score: 0, details: [], message: `Exception: ${e.message}` });
+    }
+    completed++;
+  }
+  await runTest("latency", "Latency", "⏱", async () => {
+    const times = [];
+    for (let i = 0;i < 5; i++) {
+      const res = await rpcCall(rpcUrl, "eth_blockNumber");
+      if (res.success)
+        times.push(res.latency);
+    }
+    if (times.length === 0)
+      return { status: "fail", score: 0, details: [], message: "All requests failed" };
+    const avg = times.reduce((a, b) => a + b, 0) / times.length;
+    const min = Math.min(...times);
+    const max = Math.max(...times);
+    const jitter = max - min;
+    const score = avg < 100 ? 10 : avg < 300 ? 8 : avg < 600 ? 6 : avg < 1000 ? 4 : 2;
+    return {
+      status: avg < 1000 ? "pass" : "warn",
+      score,
+      details: [
+        { label: "Avg", value: fmtMs(avg) },
+        { label: "Min", value: fmtMs(min) },
+        { label: "Max", value: fmtMs(max) },
+        { label: "Jitter", value: fmtMs(jitter) },
+        { label: "Samples", value: `${times.length}/5` }
+      ]
+    };
+  });
+  await runTest("cors", "CORS", "\uD83C\uDF10", async () => {
+    const res = await corsCheck(rpcUrl);
+    if (!res.success) {
+      return { status: "warn", score: 5, details: [
+        { label: "Status", value: "Cannot detect" },
+        { label: "Info", value: res.error || "Preflight may not be supported" }
+      ] };
+    }
+    const headers = res.headers || {};
+    const hasOrigin = !!headers["access-control-allow-origin"];
+    const origin = headers["access-control-allow-origin"] || "Not set";
+    const methods = headers["access-control-allow-methods"] || "Not set";
+    const isOpen = origin === "*";
+    return {
+      status: hasOrigin ? isOpen ? "pass" : "warn" : "fail",
+      score: isOpen ? 10 : hasOrigin ? 7 : 3,
+      details: [
+        { label: "Allow-Origin", value: origin },
+        { label: "Allow-Methods", value: methods },
+        { label: "Browser OK", value: hasOrigin ? "Yes" : "No" }
+      ]
+    };
+  });
+  await runTest("batch", "Batch Request", "\uD83D\uDCE6", async () => {
+    const res = await batchCall(rpcUrl, [
+      { method: "eth_blockNumber", params: [] },
+      { method: "eth_chainId", params: [] },
+      { method: "eth_gasPrice", params: [] }
+    ]);
+    if (!res.success)
+      return { status: "fail", score: 0, details: [], message: `Batch failed: ${res.error}` };
+    const isArray = Array.isArray(res.data);
+    const allOk = isArray && res.data.every((r) => r.result !== undefined);
+    return {
+      status: isArray ? "pass" : "fail",
+      score: isArray ? allOk ? 10 : 7 : 0,
+      details: [
+        { label: "Supported", value: isArray ? "Yes" : "No" },
+        { label: "Responses", value: isArray ? `${res.data.length}/3` : "N/A" },
+        { label: "All OK", value: allOk ? "Yes" : "No" },
+        { label: "Latency", value: fmtMs(res.latency) }
+      ]
+    };
+  });
+  await runTest("websocket", "WebSocket", "\uD83D\uDD0C", async () => {
+    const res = await wsCheck(rpcUrl);
+    if (!res.success) {
+      return { status: "warn", score: 4, details: [
+        { label: "WebSocket", value: "Not Supported" },
+        { label: "Reason", value: res.error || "Unknown" }
+      ] };
+    }
+    const bn = parseInt(res.data?.result || "0", 16);
+    return {
+      status: "pass",
+      score: 10,
+      details: [
+        { label: "WebSocket", value: "Supported" },
+        { label: "WS URL", value: res.wsUrl || "" },
+        { label: "Block Height", value: bn.toLocaleString() }
+      ]
+    };
+  });
+  await runTest("archive", "Archive Node", "\uD83D\uDCDA", async () => {
+    const res = await rpcCall(rpcUrl, "eth_getBalance", ["0x0000000000000000000000000000000000000000", "0x1"]);
+    if (!res.success)
+      return { status: "fail", score: 0, details: [], message: `Request failed: ${res.error}` };
+    const hasError = !!res.data?.error;
+    const isArchive = !hasError && res.data?.result !== undefined;
+    return {
+      status: isArchive ? "pass" : "warn",
+      score: isArchive ? 10 : 5,
+      details: [
+        { label: "Archive", value: isArchive ? "Yes" : "No" },
+        { label: "History Query", value: isArchive ? "Supported" : "Not Supported" },
+        ...hasError ? [{ label: "Error", value: res.data.error.message || "unknown" }] : [],
+        { label: "Latency", value: fmtMs(res.latency) }
+      ]
+    };
+  });
+  await runTest("methods", "Methods", "\uD83D\uDD27", async () => {
+    const methods = [
+      { method: "eth_gasPrice", params: [], label: "eth_gasPrice" },
+      { method: "eth_estimateGas", params: [{ to: "0x0000000000000000000000000000000000000000", value: "0x0" }], label: "eth_estimateGas" },
+      { method: "eth_getLogs", params: [{ fromBlock: "latest", toBlock: "latest" }], label: "eth_getLogs" },
+      { method: "eth_getCode", params: ["0x0000000000000000000000000000000000000001", "latest"], label: "eth_getCode" },
+      { method: "trace_block", params: ["latest"], label: "trace_block" },
+      { method: "debug_traceBlockByNumber", params: ["latest", {}], label: "debug_traceBlock" },
+      { method: "eth_feeHistory", params: ["0x5", "latest", [25, 75]], label: "eth_feeHistory" }
+    ];
+    const callResults = [];
+    for (const m of methods) {
+      callResults.push(await rpcCall(rpcUrl, m.method, m.params));
+    }
+    let supported = 0;
+    const details = methods.map((m, i) => {
+      const r = callResults[i];
+      const ok = r.success && !r.data?.error;
+      if (ok)
+        supported++;
+      return { label: m.label, value: ok ? "✓" : "✗" };
+    });
+    const score = Math.round(supported / methods.length * 10);
+    return {
+      status: supported >= 4 ? "pass" : supported >= 2 ? "warn" : "fail",
+      score,
+      details: [{ label: "Support Rate", value: `${supported}/${methods.length}` }, ...details]
+    };
+  });
+  await runTest("throughput", "Throughput", "\uD83D\uDE80", async () => {
+    const count = 10;
+    const start = performance.now();
+    const callResults = [];
+    for (let i = 0;i < count; i++) {
+      callResults.push(await rpcCall(rpcUrl, "eth_blockNumber"));
+    }
+    const elapsed = performance.now() - start;
+    const successCount = callResults.filter((r) => r.success && !r.data?.error).length;
+    const rps = (successCount / (elapsed / 1000)).toFixed(1);
+    const avgLatency = callResults.filter((r) => r.success).reduce((s, r) => s + r.latency, 0) / (successCount || 1);
+    const score = parseFloat(rps) >= 20 ? 10 : parseFloat(rps) >= 10 ? 8 : parseFloat(rps) >= 3 ? 5 : 2;
+    return {
+      status: successCount === count ? "pass" : "warn",
+      score,
+      details: [
+        { label: "Requests", value: String(count) },
+        { label: "Success", value: `${successCount}/${count}` },
+        { label: "Throughput", value: `${rps} req/s` },
+        { label: "Total Time", value: fmtMs(elapsed) },
+        { label: "Avg Latency", value: fmtMs(avgLatency) }
+      ]
+    };
+  });
+  await runTest("consistency", "Consistency", "\uD83E\uDDE9", async () => {
+    const r1 = await rpcCall(rpcUrl, "eth_blockNumber");
+    const r2 = await rpcCall(rpcUrl, "eth_blockNumber");
+    const r3 = await rpcCall(rpcUrl, "eth_blockNumber");
+    const blocks = [r1, r2, r3].filter((r) => r.success && r.data?.result).map((r) => parseInt(r.data.result, 16));
+    if (blocks.length < 3)
+      return { status: "fail", score: 0, details: [], message: "Some requests failed" };
+    const maxDiff = Math.max(...blocks) - Math.min(...blocks);
+    const consistent = maxDiff <= 1;
+    return {
+      status: consistent ? "pass" : "warn",
+      score: consistent ? 10 : maxDiff <= 3 ? 6 : 2,
+      details: [
+        { label: "Block #1", value: blocks[0].toLocaleString() },
+        { label: "Block #2", value: blocks[1].toLocaleString() },
+        { label: "Block #3", value: blocks[2].toLocaleString() },
+        { label: "Max Drift", value: `${maxDiff} blocks` },
+        { label: "Consistent", value: consistent ? "Yes" : "No" }
+      ]
+    };
+  });
+  await runTest("gastracker", "Gas Tracker", "⛽", async () => {
+    const gasPriceRes = await rpcCall(rpcUrl, "eth_gasPrice");
+    const feeHistoryRes = await rpcCall(rpcUrl, "eth_feeHistory", ["0xa", "latest", [10, 50, 90]]);
+    if (!gasPriceRes.success || gasPriceRes.data?.error) {
+      return { status: "fail", score: 0, details: [], message: "Cannot get gas price" };
+    }
+    const gasPrice = parseInt(gasPriceRes.data.result, 16);
+    const gasPriceGwei = (gasPrice / 1e9).toFixed(2);
+    const details = [
+      { label: "Gas Price", value: `${gasPriceGwei} Gwei` }
+    ];
+    if (feeHistoryRes.success && !feeHistoryRes.data?.error && feeHistoryRes.data?.result) {
+      const fh = feeHistoryRes.data.result;
+      const baseFees = (fh.baseFeePerGas || []).map((b) => parseInt(b, 16) / 1e9);
+      if (baseFees.length > 0) {
+        const avgBase = (baseFees.reduce((a, b) => a + b, 0) / baseFees.length).toFixed(2);
+        details.push({ label: "Avg Base Fee", value: `${avgBase} Gwei` });
+      }
+      const rewards = fh.reward;
+      if (rewards?.length > 0) {
+        const latest = rewards[rewards.length - 1];
+        if (latest) {
+          details.push({ label: "Priority P10", value: `${(parseInt(latest[0], 16) / 1e9).toFixed(2)} Gwei` });
+          details.push({ label: "Priority P50", value: `${(parseInt(latest[1], 16) / 1e9).toFixed(2)} Gwei` });
+          details.push({ label: "Priority P90", value: `${(parseInt(latest[2], 16) / 1e9).toFixed(2)} Gwei` });
+        }
+      }
+      details.push({ label: "EIP-1559", value: "Supported" });
+    } else {
+      details.push({ label: "EIP-1559", value: "Not Supported" });
+    }
+    return { status: "pass", score: 8, details };
+  });
+  clearProgress();
+  for (const r of results) {
+    printTestResult(r);
+  }
+  const totalScore = results.reduce((s, r) => s + r.score, 0);
+  const maxScore = results.length * 10;
+  const pct = Math.round(totalScore / maxScore * 100);
+  printScore(pct);
+}
+function printUsage() {
+  console.log();
+  console.log(`${c.bold}${c.cyan}  EVM RPC Checker${c.reset} - Analyze EVM-compatible RPC endpoints`);
+  console.log();
+  console.log(`  ${c.bold}Usage:${c.reset}`);
+  console.log(`    ${c.green}evm-rpc-checker${c.reset} <rpc-url>`);
+  console.log(`    ${c.green}bun cli/src/index.ts${c.reset} <rpc-url>`);
+  console.log();
+  console.log(`  ${c.bold}Example:${c.reset}`);
+  console.log(`    ${c.dim}evm-rpc-checker https://eth.llamarpc.com${c.reset}`);
+  console.log(`    ${c.dim}evm-rpc-checker https://rpc.ankr.com/eth${c.reset}`);
+  console.log();
+}
+var args = process.argv.slice(2);
+if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+  printUsage();
+  process.exit(0);
+}
+var rpcUrl = args[0];
+if (!rpcUrl.startsWith("http://") && !rpcUrl.startsWith("https://")) {
+  console.error(`
+  ${c.red}Error: Invalid URL. Must start with http:// or https://${c.reset}
+`);
+  process.exit(1);
+}
+runAnalysis(rpcUrl).catch((err) => {
+  console.error(`
+  ${c.red}Fatal error: ${err.message}${c.reset}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "evm-rpc-checker",
+  "version": "1.0.0",
+  "description": "CLI tool for analyzing EVM-compatible RPC endpoints",
+  "type": "module",
+  "bin": {
+    "evm-rpc-checker": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outfile dist/index.js --target node",
+    "prepublishOnly": "bun run build",
+    "dev": "bun src/index.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "evm",
+    "rpc",
+    "ethereum",
+    "blockchain",
+    "checker",
+    "analyzer",
+    "web3",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lolieatapple/rpc-checker.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/lolieatapple/rpc-checker",
+  "license": "MIT"
+}