Add HYPEREVM_RPC_URL env override and rate limit auto-retry

- ChainConfig::effective_rpc_url() checks HYPEREVM_RPC_URL env var first
- All CLI commands use effective_rpc_url() instead of hardcoded chain.rpc_url
- provider::with_retry() — exponential backoff on rate limit errors (3 retries, 2s initial)
- Lending rates and yield compare use retry wrapper
- build_provider_from_url() helper for raw URL strings

Usage: HYPEREVM_RPC_URL=http://localhost:8545 defi lending rates --protocol hyperlend --asset USDC

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Hiksang

crates/defi-cli/src/commands/dex.rs

@@ -162,7 +162,10 @@ pub async fn run(
             amount,
         } => {
             let entry = registry.get_protocol(&protocol)?;
-            let dex = defi_protocols::factory::create_dex_with_rpc(entry, Some(&chain.rpc_url))?;
+            let dex = defi_protocols::factory::create_dex_with_rpc(
+                entry,
+                Some(&chain.effective_rpc_url()),
+            )?;
 
             let token_in_addr =
                 resolve_token_address(registry, &chain.name.to_lowercase(), &token_in)?;
@@ -205,7 +208,10 @@ pub async fn run(
             let mut quotes: Vec<QuoteResult> = Vec::new();
 
             for entry in &dex_protocols {
-                match defi_protocols::factory::create_dex_with_rpc(entry, Some(&chain.rpc_url)) {
+                match defi_protocols::factory::create_dex_with_rpc(
+                    entry,
+                    Some(&chain.effective_rpc_url()),
+                ) {
                     Ok(dex) => {
                         let params = QuoteParams {
                             protocol: entry.slug.clone(),

crates/defi-cli/src/commands/lending.rs

@@ -264,16 +264,26 @@ pub async fn run(
         }
         LendingCommand::Rates { protocol, asset } => {
             let entry = registry.get_protocol(&protocol)?;
-            let lending =
-                defi_protocols::factory::create_lending_with_rpc(entry, Some(&chain.rpc_url))?;
+            let rpc_url = chain.effective_rpc_url();
             let asset_addr = resolve_asset(registry, &chain_key, &asset)?;
-            let rates = lending.get_rates(asset_addr).await?;
+            let entry_clone = entry.clone();
+            let rates = defi_core::provider::with_retry(3, 2000, || {
+                let lending =
+                    defi_protocols::factory::create_lending_with_rpc(&entry_clone, Some(&rpc_url));
+                async move {
+                    let lending = lending?;
+                    lending.get_rates(asset_addr).await
+                }
+            })
+            .await?;
             output.print(&rates)?;
         }
         LendingCommand::Position { protocol, address } => {
             let entry = registry.get_protocol(&protocol)?;
-            let lending =
-                defi_protocols::factory::create_lending_with_rpc(entry, Some(&chain.rpc_url))?;
+            let lending = defi_protocols::factory::create_lending_with_rpc(
+                entry,
+                Some(&chain.effective_rpc_url()),
+            )?;
             let user = address
                 .parse::<Address>()
                 .map_err(|e| DefiError::InvalidParam(format!("Invalid address: {e}")))?;

crates/defi-cli/src/commands/mod.rs

@@ -79,7 +79,7 @@ pub async fn run(cli: Cli) -> Result<(), DefiError> {
     let registry = defi_core::registry::Registry::load_embedded()?;
     let chain = registry.get_chain(&cli.chain)?;
     let output_mode = crate::output::OutputMode::from_cli(&cli);
-    let executor = crate::executor::Executor::new(cli.broadcast, Some(chain.rpc_url.clone()));
+    let executor = crate::executor::Executor::new(cli.broadcast, Some(chain.effective_rpc_url()));
 
     match cli.command {
         Commands::Status(args) => status::run(args, &registry, &output_mode).await,

crates/defi-cli/src/commands/staking.rs

@@ -137,7 +137,7 @@ pub async fn run(
                     let entry = registry.get_protocol(&p)?;
                     let staking = defi_protocols::factory::create_liquid_staking_with_rpc(
                         entry,
-                        Some(&_chain.rpc_url),
+                        Some(&_chain.effective_rpc_url()),
                     )?;
                     let info = staking.get_info().await?;
                     output.print(&info)?;

crates/defi-cli/src/commands/status.rs

@@ -124,7 +124,7 @@ pub async fn run(args: StatusArgs, registry: &Registry, output: &OutputMode) ->
             .map_err(|e| DefiError::RpcError(format!("Failed to get block number: {e}")))?;
         eprintln!(
             "Connected to {} (block #{}). Verifying {} contracts...",
-            chain.rpc_url,
+            chain.effective_rpc_url(),
             bn,
             all_addresses.len()
         );
@@ -213,7 +213,7 @@ pub async fn run(args: StatusArgs, registry: &Registry, output: &OutputMode) ->
     let status = StatusOutput {
         chain: chain.name.clone(),
         chain_id: chain.chain_id,
-        rpc_url: chain.rpc_url.clone(),
+        rpc_url: chain.effective_rpc_url(),
         block_number,
         protocols,
         summary,

crates/defi-cli/src/commands/vault.rs

@@ -123,8 +123,10 @@ pub async fn run(
         VaultCommand::Info { protocol } => match protocol {
             Some(p) => {
                 let entry = registry.get_protocol(&p)?;
-                let vault =
-                    defi_protocols::factory::create_vault_with_rpc(entry, Some(&_chain.rpc_url))?;
+                let vault = defi_protocols::factory::create_vault_with_rpc(
+                    entry,
+                    Some(&_chain.effective_rpc_url()),
+                )?;
                 let info = vault.get_vault_info().await?;
                 output.print(&info)?;
             }

crates/defi-cli/src/commands/yield_cmd.rs

@@ -59,18 +59,17 @@ async fn collect_lending_rates(
             }
             first = false;
 
-            match defi_protocols::factory::create_lending_with_rpc(entry, Some(&chain.rpc_url)) {
-                Ok(lending) => match lending.get_rates(asset_addr).await {
-                    Ok(rates) => results.push(rates),
-                    Err(e) => {
-                        eprintln!("Warning: {} rates unavailable: {}", entry.name, e);
-                    }
-                },
+            let rpc = chain.effective_rpc_url();
+            let entry_c = (*entry).clone();
+            match defi_core::provider::with_retry(2, 2000, || {
+                let l = defi_protocols::factory::create_lending_with_rpc(&entry_c, Some(&rpc));
+                async move { l?.get_rates(asset_addr).await }
+            })
+            .await
+            {
+                Ok(rates) => results.push(rates),
                 Err(e) => {
-                    eprintln!(
-                        "Warning: could not create {} lending adapter: {}",
-                        entry.name, e
-                    );
+                    eprintln!("Warning: {} rates unavailable: {}", entry.name, e);
                 }
             }
         }

crates/defi-core/src/provider.rs

@@ -4,10 +4,58 @@ use url::Url;
 use crate::error::{DefiError, Result};
 use crate::registry::ChainConfig;
 
+/// Build a provider using the effective RPC URL (env var override supported).
 pub fn build_provider(chain: &ChainConfig) -> Result<impl alloy::providers::Provider> {
-    let url: Url = chain
-        .rpc_url
+    let rpc = chain.effective_rpc_url();
+    let url: Url = rpc
         .parse()
         .map_err(|e| DefiError::RpcError(format!("Invalid RPC URL: {e}")))?;
     Ok(ProviderBuilder::new().connect_http(url))
 }
+
+/// Build a provider from a raw URL string.
+pub fn build_provider_from_url(rpc_url: &str) -> Result<impl alloy::providers::Provider> {
+    let url: Url = rpc_url
+        .parse()
+        .map_err(|e| DefiError::RpcError(format!("Invalid RPC URL: {e}")))?;
+    Ok(ProviderBuilder::new().connect_http(url))
+}
+
+/// Retry an async RPC operation with exponential backoff on rate limit errors.
+/// Retries up to `max_retries` times with initial delay `initial_delay_ms`.
+pub async fn with_retry<F, Fut, T>(
+    max_retries: u32,
+    initial_delay_ms: u64,
+    mut operation: F,
+) -> Result<T>
+where
+    F: FnMut() -> Fut,
+    Fut: std::future::Future<Output = Result<T>>,
+{
+    let mut delay = initial_delay_ms;
+    for attempt in 0..=max_retries {
+        match operation().await {
+            Ok(val) => return Ok(val),
+            Err(e) => {
+                let err_str = e.to_string();
+                let is_rate_limit = err_str.contains("rate limit")
+                    || err_str.contains("-32005")
+                    || err_str.contains("429");
+
+                if !is_rate_limit || attempt == max_retries {
+                    return Err(e);
+                }
+
+                eprintln!(
+                    "Rate limited (attempt {}/{}), retrying in {}ms...",
+                    attempt + 1,
+                    max_retries,
+                    delay
+                );
+                tokio::time::sleep(std::time::Duration::from_millis(delay)).await;
+                delay = (delay * 2).min(30_000); // exponential backoff, max 30s
+            }
+        }
+    }
+    unreachable!()
+}

crates/defi-core/src/registry/chain.rs

@@ -10,3 +10,11 @@ pub struct ChainConfig {
     pub wrapped_native: Option<String>,
     pub multicall3: Option<String>,
 }
+
+impl ChainConfig {
+    /// Get the effective RPC URL, checking environment variable override first.
+    /// Priority: HYPEREVM_RPC_URL env var > chains.toml rpc_url
+    pub fn effective_rpc_url(&self) -> String {
+        std::env::var("HYPEREVM_RPC_URL").unwrap_or_else(|_| self.rpc_url.clone())
+    }
+}