A high-performance reverse proxy with intelligent load balancing, health monitoring, and automatic node discovery for Comet RPC and JSON-RPC endpoints.

• Intelligent Load Balancing: EMA-based weighted selection favoring low-latency nodes
• Dual RPC Support: Separate handling for Comet RPC and JSON-RPC endpoints
• Automatic Node Discovery: Recursive discovery via Comet RPC's /net_info endpoint
• Health Monitoring: Periodic health checks with automatic node removal
• Real-time Dashboard: Web-based monitoring interface
• Graceful Shutdown: Proper cleanup on Ctrl+C or when all nodes are unhealthy
• Request Retry Logic: Configurable retry mechanism for failed requests
• Separate Latency Tracking: Independent EMA latency tracking per RPC type

• Rust 1.70+ (install from rust-lang.org)

cargo build --release

Create or edit config.json:

{
 "verbose": true,
 "http_port": 8080,
 "is_static": true,
 "enable_discovery": true,
 "discovery_interval_sec": 300,
 "health_check_interval_sec": 30,
 "health_failure_threshold": 3,
 "unhealthy_removal_threshold": 3,
 "request_retry_count": 2,
 "ema_alpha": 0.3,
 "request_timeout_ms": 5000,
 "expected_json_rpc_port": 8545,
 "static_nodes": [
 {
 "comet_rpc_url": "http://node1.example.com:26657",
 "json_rpc_url": "http://node1.example.com:8545"
 }
 ],
 "discoverable_nodes": [
 {
 "comet_rpc_url": "http://seed.example.com:26657"
 }
 ]
}

cargo run --release

Or with the binary:

./target/release/load-aware-proxy

• /rpc - Comet RPC proxy endpoint (GET/POST)
• /json-rpc - JSON-RPC proxy endpoint (POST)
• /health - Health check endpoint (returns node status)
• /api/status - Detailed status API (returns full statistics)
• / or /dashboard - Web dashboard

1. config.rs - Configuration loading and validation
2. node.rs - Node representation and pool management
3. balancer.rs - Load balancing with EMA-based selection
4. discovery.rs - Recursive node discovery
5. health.rs - Health monitoring system
6. rpc.rs - Request proxying and latency tracking
7. proxy.rs - Axum HTTP server
8. dashboard.rs - Monitoring endpoints
9. main.rs - Application orchestration

The proxy uses a sophisticated load balancing algorithm:

1. Initial Phase: Round-robin selection until all nodes have latency data
2. Weighted Phase: Bias calculation based on inverse latency
3. Staleness Detection: Recalculate weights when latency changes ≥5ms
4. Separate Tracking: Independent latency tracking for Comet RPC and JSON-RPC

Bias formula: bias = 1.0 / (latency + 1.0)

• Starts with seed nodes from discoverable_nodes config
• Queries /net_info endpoint to find peers
• Recursively discovers from newly found nodes
• Avoids infinite loops with visited set
• Resets balancer when new nodes are discovered

• Checks Comet RPC via /status endpoint
• Checks JSON-RPC via eth_blockNumber method
• Node marked unhealthy after N consecutive failures
• Node removed after M times marked unhealthy
• Automatic graceful shutdown if all nodes unhealthy

cargo test

Set verbose: true in config.json or use:

RUST_LOG=debug cargo run

cargo build --release --target x86_64-unknown-linux-gnu

curl http://localhost:8080/rpc/status

curl -X POST http://localhost:8080/json-rpc \
 -H "Content-Type: application/json" \
 -d '{
 "jsonrpc": "2.0",
 "method": "eth_blockNumber",
 "params": [],
 "id": 1
 }'

curl http://localhost:8080/health

Open in browser: http://localhost:8080/

The dashboard provides real-time monitoring of:

• Node health status
• Latency metrics (Comet RPC and JSON-RPC)
• Request counts per node
• Failure statistics
• Configuration summary
• System uptime

MIT License - see LICENSE file for details

Abdul Azeem

Contributions are welcome! Please ensure all tests pass before submitting a PR.

cargo test
cargo fmt
cargo clippy