Add cross-chain yield scan: defi yield scan --asset USDC

Scans all 11 chains in parallel for lending rates, ranks by supply APY,
and identifies arb opportunities (supply high / borrow low spread).

  defi yield scan --asset USDC
  → 15 rates across 11 chains in 1.4s
  → Top: HypurrFi 4.66% (HyperEVM)
  → 10 arb opportunities (best: +2.56% cross-chain)

Table output with color-coded APYs and arb spread table.

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

Author: Hiksang

.omc/project-memory.json

@@ -116,6 +116,18 @@
       "lastAccessed": 1773824621726,
       "type": "file"
     },
+    {
+      "path": "crates/defi-cli/src/table.rs",
+      "accessCount": 8,
+      "lastAccessed": 1773826378964,
+      "type": "file"
+    },
+    {
+      "path": "crates/defi-cli/src/commands/yield_cmd.rs",
+      "accessCount": 8,
+      "lastAccessed": 1773826425420,
+      "type": "file"
+    },
     {
       "path": "crates/defi-cli/src/commands/whales.rs",
       "accessCount": 6,
@@ -134,12 +146,6 @@
       "lastAccessed": 1773745726311,
       "type": "file"
     },
-    {
-      "path": "crates/defi-cli/src/table.rs",
-      "accessCount": 5,
-      "lastAccessed": 1773826170351,
-      "type": "file"
-    },
     {
       "path": "crates/defi-core/src/registry/mod.rs",
       "accessCount": 4,

.omc/state/hud-stdin-cache.json

@@ -1 +1 @@
-{"session_id":"2c019e77-806b-4a72-b477-db1f3b13fa91","transcript_path":"/Users/hik/.claude/projects/-Users-hik-Documents-GitHub-defi-cli/2c019e77-806b-4a72-b477-db1f3b13fa91.jsonl","cwd":"/Users/hik/Documents/GitHub/defi-cli","model":{"id":"claude-opus-4-6[1m]","display_name":"Opus 4.6 (1M context)"},"workspace":{"current_dir":"/Users/hik/Documents/GitHub/defi-cli","project_dir":"/Users/hik/Documents/GitHub/defi-cli","added_dirs":[]},"version":"2.1.77","output_style":{"name":"default"},"cost":{"total_cost_usd":388.52809715000075,"total_duration_ms":181764897,"total_api_duration_ms":29799466,"total_lines_added":11098,"total_lines_removed":1738},"context_window":{"total_input_tokens":9209365,"total_output_tokens":1237334,"context_window_size":1000000,"current_usage":{"input_tokens":3,"output_tokens":1,"cache_creation_input_tokens":4113,"cache_read_input_tokens":608615},"used_percentage":61,"remaining_percentage":39},"exceeds_200k_tokens":true}
+{"session_id":"2c019e77-806b-4a72-b477-db1f3b13fa91","transcript_path":"/Users/hik/.claude/projects/-Users-hik-Documents-GitHub-defi-cli/2c019e77-806b-4a72-b477-db1f3b13fa91.jsonl","cwd":"/Users/hik/Documents/GitHub/defi-cli","model":{"id":"claude-opus-4-6[1m]","display_name":"Opus 4.6 (1M context)"},"workspace":{"current_dir":"/Users/hik/Documents/GitHub/defi-cli","project_dir":"/Users/hik/Documents/GitHub/defi-cli","added_dirs":[]},"version":"2.1.77","output_style":{"name":"default"},"cost":{"total_cost_usd":394.6681909000007,"total_duration_ms":181995226,"total_api_duration_ms":30017887,"total_lines_added":11283,"total_lines_removed":1743},"context_window":{"total_input_tokens":9209422,"total_output_tokens":1243110,"context_window_size":1000000,"current_usage":{"input_tokens":3,"output_tokens":1,"cache_creation_input_tokens":197,"cache_read_input_tokens":627744},"used_percentage":63,"remaining_percentage":37},"exceeds_200k_tokens":true}

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

@@ -21,6 +21,12 @@ pub enum YieldCommand {
         #[arg(long)]
         asset: String,
     },
+    /// Scan ALL chains for best yield opportunities (parallel)
+    Scan {
+        /// Asset symbol (e.g. USDC, WETH)
+        #[arg(long)]
+        asset: String,
+    },
     /// Suggest optimal yield strategy for an asset
     Optimize {
         /// Asset symbol or address to optimize (e.g. USDC, WHYPE)
@@ -169,6 +175,9 @@ pub async fn run(
     let chain_key = chain.name.to_lowercase();
 
     match args.command {
+        YieldCommand::Scan { asset } => {
+            return run_yield_scan(registry, &asset, output).await;
+        }
         YieldCommand::Compare { asset } => {
             let asset_addr = resolve_asset(registry, &chain_key, &asset)?;
             let mut results = collect_lending_rates(registry, chain, asset_addr).await;
@@ -404,3 +413,147 @@ pub async fn run(
 
     Ok(())
 }
+
+/// Scan all chains in parallel for the best yield on a given asset
+async fn run_yield_scan(registry: &Registry, asset: &str, output: &OutputMode) -> Result<()> {
+    let start = std::time::Instant::now();
+    let chain_keys: Vec<String> = registry.chains.keys().cloned().collect();
+
+    // Collect params for each chain
+    struct ChainYieldParams {
+        chain_name: String,
+        rpc: String,
+        asset_addr: Option<Address>,
+        protocols: Vec<defi_core::registry::ProtocolEntry>,
+    }
+
+    let mut params = Vec::new();
+    for ck in &chain_keys {
+        let chain = match registry.get_chain(ck) {
+            Ok(c) => c,
+            Err(_) => continue,
+        };
+        let asset_addr = registry.resolve_token(ck, asset).ok().map(|t| t.address);
+        let protos: Vec<_> = registry
+            .get_protocols_for_chain(ck)
+            .iter()
+            .filter(|p| p.category == ProtocolCategory::Lending && p.interface == "aave_v3")
+            .cloned()
+            .cloned()
+            .collect();
+        if asset_addr.is_some() && !protos.is_empty() {
+            params.push(ChainYieldParams {
+                chain_name: chain.name.clone(),
+                rpc: chain.effective_rpc_url(),
+                asset_addr,
+                protocols: protos,
+            });
+        }
+    }
+
+    // Spawn parallel tasks
+    let mut join_set = tokio::task::JoinSet::new();
+    for p in params {
+        join_set.spawn(async move {
+            let addr = match p.asset_addr {
+                Some(a) => a,
+                None => return Vec::new(),
+            };
+            let mut rates = Vec::new();
+            for proto in &p.protocols {
+                if let Ok(lending) =
+                    defi_protocols::factory::create_lending_with_rpc(proto, Some(&p.rpc))
+                    && let Ok(r) = lending.get_rates(addr).await
+                    && r.supply_apy > 0.0
+                {
+                    rates.push(serde_json::json!({
+                        "chain": p.chain_name,
+                        "protocol": r.protocol,
+                        "supply_apy": r.supply_apy,
+                        "borrow_variable_apy": r.borrow_variable_apy,
+                    }));
+                }
+            }
+            rates
+        });
+    }
+
+    // Collect results
+    let mut all_rates: Vec<serde_json::Value> = Vec::new();
+    while let Some(result) = join_set.join_next().await {
+        if let Ok(rates) = result {
+            all_rates.extend(rates);
+        }
+    }
+
+    // Sort by supply APY descending
+    all_rates.sort_by(|a, b| {
+        b["supply_apy"]
+            .as_f64()
+            .unwrap_or(0.0)
+            .partial_cmp(&a["supply_apy"].as_f64().unwrap_or(0.0))
+            .unwrap()
+    });
+
+    let scan_ms = start.elapsed().as_millis();
+    let best = all_rates.first().and_then(|r| {
+        Some(format!(
+            "{} on {}",
+            r["protocol"].as_str()?,
+            r["chain"].as_str()?
+        ))
+    });
+
+    // Find arb opportunities (supply on A, borrow on B, same asset)
+    let mut arbs = Vec::new();
+    for s in &all_rates {
+        for b in &all_rates {
+            let sp = s["supply_apy"].as_f64().unwrap_or(0.0);
+            let bp = b["borrow_variable_apy"].as_f64().unwrap_or(0.0);
+            if sp > bp && bp > 0.0 {
+                let spread = sp - bp;
+                let s_chain = s["chain"].as_str().unwrap_or("?");
+                let b_chain = b["chain"].as_str().unwrap_or("?");
+                let s_proto = s["protocol"].as_str().unwrap_or("?");
+                let b_proto = b["protocol"].as_str().unwrap_or("?");
+                if s_chain != b_chain || s_proto != b_proto {
+                    let strategy = if s_chain == b_chain {
+                        "same-chain"
+                    } else {
+                        "cross-chain"
+                    };
+                    arbs.push(serde_json::json!({
+                        "spread_pct": (spread * 100.0).round() / 100.0,
+                        "supply_chain": s_chain,
+                        "supply_protocol": s_proto,
+                        "supply_apy": sp,
+                        "borrow_chain": b_chain,
+                        "borrow_protocol": b_proto,
+                        "borrow_apy": bp,
+                        "strategy": strategy,
+                    }));
+                }
+            }
+        }
+    }
+    arbs.sort_by(|a, b| {
+        b["spread_pct"]
+            .as_f64()
+            .unwrap_or(0.0)
+            .partial_cmp(&a["spread_pct"].as_f64().unwrap_or(0.0))
+            .unwrap()
+    });
+    arbs.truncate(10); // Top 10 arb opportunities
+
+    let result = serde_json::json!({
+        "asset": asset,
+        "scan_duration_ms": scan_ms,
+        "chains_scanned": chain_keys.len(),
+        "rates": all_rates,
+        "best_supply": best,
+        "arb_opportunities": arbs,
+    });
+
+    output.print(&result)?;
+    Ok(())
+}

crates/defi-cli/src/table.rs

@@ -11,6 +11,9 @@ pub fn render(value: &Value) -> Option<String> {
     if value.get("holders").is_some() {
         return Some(render_whales(value));
     }
+    if value.get("arb_opportunities").is_some() && value.get("rates").is_some() {
+        return Some(render_yield_scan(value));
+    }
     if value.get("rates").is_some() && value.get("asset").is_some() {
         return Some(render_yield(value));
     }
@@ -320,6 +323,73 @@ fn render_status(v: &Value) -> String {
     format!("{}\n\n{}", out, t)
 }
 
+fn render_yield_scan(v: &Value) -> String {
+    let asset = v["asset"].as_str().unwrap_or("?");
+    let ms = v["scan_duration_ms"].as_u64().unwrap_or(0);
+    let best = v["best_supply"].as_str().unwrap_or("?");
+
+    let mut t = Table::new();
+    t.load_preset(UTF8_FULL_CONDENSED);
+    t.set_header(vec!["Chain", "Protocol", "Supply APY", "Borrow APY"]);
+
+    for r in v["rates"].as_array().unwrap_or(&vec![]) {
+        let supply = r["supply_apy"].as_f64().unwrap_or(0.0);
+        let color = if supply > 3.0 {
+            Color::Green
+        } else if supply > 1.0 {
+            Color::Cyan
+        } else {
+            Color::White
+        };
+        t.add_row(vec![
+            Cell::new(r["chain"].as_str().unwrap_or("?")),
+            Cell::new(r["protocol"].as_str().unwrap_or("?")),
+            Cell::new(format!("{:.2}%", supply)).fg(color),
+            Cell::new(format!(
+                "{:.2}%",
+                r["borrow_variable_apy"].as_f64().unwrap_or(0.0)
+            )),
+        ]);
+    }
+
+    let mut out = format!(
+        "  {} Yield Scan ({}ms) — Best: {}\n\n{}",
+        asset, ms, best, t
+    );
+
+    let empty_arbs = vec![];
+    let arbs = v["arb_opportunities"].as_array().unwrap_or(&empty_arbs);
+    if !arbs.is_empty() {
+        let mut at = Table::new();
+        at.load_preset(UTF8_FULL_CONDENSED);
+        at.set_header(vec!["Spread", "Supply @", "Borrow @", "Type"]);
+        for a in arbs {
+            let spread = a["spread_pct"].as_f64().unwrap_or(0.0);
+            let color = if spread > 1.0 {
+                Color::Green
+            } else {
+                Color::Cyan
+            };
+            at.add_row(vec![
+                Cell::new(format!("+{:.2}%", spread)).fg(color),
+                Cell::new(format!(
+                    "{} ({})",
+                    a["supply_protocol"].as_str().unwrap_or("?"),
+                    a["supply_chain"].as_str().unwrap_or("?")
+                )),
+                Cell::new(format!(
+                    "{} ({})",
+                    a["borrow_protocol"].as_str().unwrap_or("?"),
+                    a["borrow_chain"].as_str().unwrap_or("?")
+                )),
+                Cell::new(a["strategy"].as_str().unwrap_or("?")),
+            ]);
+        }
+        out.push_str(&format!("\n  Arb Opportunities\n\n{}", at));
+    }
+    out
+}
+
 fn render_portfolio(v: &Value) -> String {
     render_positions(v) // Same format
 }