Struct RpcPool 

pub struct RpcPool { /* private fields */ }

Pool of RPC endpoints with load balancing and health tracking.

Memory Considerations

The endpoint list is fixed at construction time. Endpoints are never removed, only marked as unhealthy via the HealthTracker. This is intentional:

• CLI tools are short-lived, so memory growth isn’t a concern
• Endpoints may recover after temporary issues (circuit breaker resets)
• The list size is bounded by user configuration

For long-running daemons, consider implementing periodic cleanup of persistently unhealthy endpoints.

Block Reorganization Handling

This pool does not account for chain reorganizations. Queries for recent blocks may return data that becomes stale if a reorg occurs. This is acceptable for a CLI tool because:

• Most queries are for historical data (well past finalization)
• Real-time queries are point-in-time snapshots by nature
• Reorg detection would add significant complexity

For applications requiring reorg-aware data, consider waiting for finalization (12-15 confirmations on Ethereum mainnet) or using a service that handles reorgs.

Implementations

impl RpcPool

pub fn new(chain: Chain, config: &RpcConfig) -> Result<Self>

Create a new RPC pool for a chain

(PERF-008 fix: Uses iterator-based filtering to avoid intermediate Vec clone)

pub fn from_url(url: &str, timeout_secs: u64) -> Result<Self>

Create from a single endpoint URL

pub fn endpoint_count(&self) -> usize

Get number of available endpoints

pub fn concurrency(&self) -> usize

Get concurrency level

pub fn health_tracker(&self) -> Arc<HealthTracker>

Get health tracker

pub async fn get_block_number(&self) -> Result<u64>

Get current block number (tries multiple endpoints)

pub async fn get_transaction(&self, hash: B256) -> Result<Option<Transaction>>

Get a transaction by hash (tries multiple endpoints)

pub async fn get_transaction_receipt( &self, hash: B256, ) -> Result<Option<TransactionReceipt>>

Get a transaction receipt by hash (tries multiple endpoints)

pub async fn get_block_with_txs( &self, block_number: u64, ) -> Result<Option<Block>>

Get a block by number with full transaction objects (tries multiple endpoints)

pub async fn get_logs(&self, filter: &Filter) -> Result<Vec<Log>>

Fetch logs with automatic retry and load balancing

pub async fn get_logs_parallel( &self, filters: Vec<Filter>, ) -> Vec<Result<Vec<Log>>>

Fetch logs from multiple filters in parallel

pub fn effective_max_block_range(&self, url: &str) -> u64

Get effective max block range for an endpoint

pub fn min_block_range(&self) -> u64

Get the smallest max block range across all endpoints

pub fn max_block_range(&self) -> u64

Get the largest max block range across healthy endpoints Returns the user-specified chunk_size if set, otherwise uses endpoint limits

pub fn get_endpoint_health(&self) -> Vec<(String, u8, Option<EndpointHealth>)>

Get health info for all endpoints

pub fn list_endpoints(&self) -> Vec<&str>

List all endpoint URLs

pub fn archive_endpoint_count(&self) -> usize

Get count of archive endpoints

pub fn debug_endpoint_count(&self) -> usize

Get count of debug-capable endpoints

pub fn select_archive_endpoints(&self, count: usize) -> Vec<Arc<Endpoint>>

Select endpoints that are known archives (for historical data queries) Falls back to all available endpoints if no archives are known