Add oracle price feed infrastructure for arbitrage detection

New components:
- Oracle trait (get_price, get_prices) in defi-core
- AaveOracle adapter (HyperLend, HypurrFi oracle contracts)
- FelixOracle adapter (WHYPE PriceFeed only)
- DexSpotPrice utility (quote-based spot pricing)
- CLI `defi price --asset WHYPE` command

Verified on real HyperEVM RPC:
  WHYPE: HyperLend=$38.31, HypurrFi=$38.30, Felix=$38.31 (spread 0.03%)
  WBTC:  HyperLend=$73,952, HypurrFi=$73,847 (spread 0.14%)
  WETH:  HyperLend=$2,264, HypurrFi=$2,262 (spread 0.10%)
  kHYPE: HyperLend=$38.87, HypurrFi=$38.82 (spread 0.13%)

This provides the foundation for DEX↔Oracle arbitrage detection.

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

Author: Hiksang

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

@@ -3,6 +3,7 @@ pub mod cdp;
 pub mod dex;
 pub mod gauge;
 pub mod lending;
+pub mod price;
 pub mod schema;
 pub mod staking;
 pub mod status;
@@ -67,6 +68,8 @@ pub enum Commands {
     Vault(vault::VaultArgs),
     /// Yield operations: compare, optimize
     Yield(yield_cmd::YieldArgs),
+    /// Query asset prices from oracles and DEXes
+    Price(price::PriceArgs),
     /// Wallet management
     Wallet(wallet::WalletArgs),
     /// Token operations: approve, allowance, transfer
@@ -96,6 +99,7 @@ pub async fn run(cli: Cli) -> Result<(), DefiError> {
         }
         Commands::Vault(args) => vault::run(args, &registry, chain, &executor, &output_mode).await,
         Commands::Yield(args) => yield_cmd::run(args, &registry, chain, &output_mode).await,
+        Commands::Price(args) => price::run(args, &registry, chain, &output_mode).await,
         Commands::Wallet(args) => wallet::run(args, &registry, &output_mode).await,
         Commands::Token(args) => token::run(args, &registry, chain, &executor, &output_mode).await,
         Commands::Agent => crate::agent::run_agent(&registry, &executor).await,

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

@@ -0,0 +1,195 @@
+use alloy::primitives::Address;
+use clap::Args;
+
+use defi_core::error::{DefiError, Result};
+use defi_core::registry::{ChainConfig, ProtocolCategory, Registry};
+use defi_core::types::PriceData;
+
+use crate::output::OutputMode;
+
+#[derive(Args)]
+pub struct PriceArgs {
+    /// Asset symbol (e.g. WHYPE) or address
+    #[arg(long)]
+    pub asset: String,
+
+    /// Price source filter: all, oracle, dex
+    #[arg(long, default_value = "all")]
+    pub source: String,
+}
+
+#[derive(serde::Serialize)]
+struct PriceReport {
+    asset: String,
+    asset_address: String,
+    prices: Vec<PriceEntry>,
+    max_spread_pct: f64,
+    oracle_vs_dex_spread_pct: f64,
+}
+
+#[derive(serde::Serialize)]
+struct PriceEntry {
+    source: String,
+    source_type: String,
+    price: f64,
+}
+
+fn resolve_asset(registry: &Registry, chain: &str, asset: &str) -> Result<(Address, String, u8)> {
+    if let Ok(addr) = asset.parse::<Address>() {
+        return Ok((addr, asset.to_string(), 18));
+    }
+    let token = registry.resolve_token(chain, asset)?;
+    Ok((token.address, token.symbol.clone(), token.decimals))
+}
+
+pub async fn run(
+    args: PriceArgs,
+    registry: &Registry,
+    chain: &ChainConfig,
+    output: &OutputMode,
+) -> Result<()> {
+    let chain_key = chain.name.to_lowercase();
+    let rpc_url = chain.effective_rpc_url();
+    let (asset_addr, asset_symbol, _asset_decimals) =
+        resolve_asset(registry, &chain_key, &args.asset)?;
+
+    let fetch_oracle = args.source == "all" || args.source == "oracle";
+    let fetch_dex = args.source == "all" || args.source == "dex";
+
+    let mut all_prices: Vec<PriceData> = Vec::new();
+
+    // === Oracle prices from lending protocols (Aave V3 forks) ===
+    if fetch_oracle {
+        let lending_protocols = registry.get_protocols_by_category(ProtocolCategory::Lending);
+        for entry in &lending_protocols {
+            match defi_protocols::factory::create_oracle_from_lending(entry, &rpc_url) {
+                Ok(oracle) => match oracle.get_price(asset_addr).await {
+                    Ok(price) => all_prices.push(price),
+                    Err(e) => {
+                        eprintln!("[{}] oracle price failed: {e}", entry.name);
+                    }
+                },
+                Err(_) => continue, // Interface doesn't support oracle
+            }
+        }
+
+        // === Oracle prices from CDP protocols (Felix) ===
+        // Felix PriceFeed only returns WHYPE collateral price.
+        // Only query it when the asset is WHYPE or a WHYPE-related token.
+        let whype_addr: Address = "0x5555555555555555555555555555555555555555"
+            .parse()
+            .unwrap();
+        let is_whype = asset_addr == whype_addr
+            || asset_symbol.eq_ignore_ascii_case("WHYPE")
+            || asset_symbol.eq_ignore_ascii_case("HYPE");
+
+        if is_whype {
+            let cdp_protocols = registry.get_protocols_by_category(ProtocolCategory::Cdp);
+            for entry in &cdp_protocols {
+                match defi_protocols::factory::create_oracle_from_cdp(entry, asset_addr, &rpc_url) {
+                    Ok(oracle) => match oracle.get_price(asset_addr).await {
+                        Ok(price) => all_prices.push(price),
+                        Err(e) => {
+                            eprintln!("[{}] oracle price failed: {e}", entry.name);
+                        }
+                    },
+                    Err(_) => continue,
+                }
+            }
+        }
+    }
+
+    // === DEX spot prices ===
+    if fetch_dex {
+        // Resolve USDC as the quote token
+        let usdc = registry.resolve_token(&chain_key, "USDC");
+        if let Ok(usdc_token) = usdc {
+            let usdc_addr = usdc_token.address;
+            let usdc_decimals = usdc_token.decimals;
+
+            let dex_protocols = registry.get_protocols_by_category(ProtocolCategory::Dex);
+            for entry in &dex_protocols {
+                match defi_protocols::factory::create_dex_with_rpc(entry, Some(&rpc_url)) {
+                    Ok(dex) => {
+                        match defi_protocols::dex::DexSpotPrice::get_price(
+                            dex.as_ref(),
+                            asset_addr,
+                            _asset_decimals,
+                            usdc_addr,
+                            usdc_decimals,
+                        )
+                        .await
+                        {
+                            Ok(price) => all_prices.push(price),
+                            Err(e) => {
+                                eprintln!("[{}] dex price failed: {e}", entry.name);
+                            }
+                        }
+                    }
+                    Err(_) => continue,
+                }
+            }
+        } else {
+            eprintln!("USDC token not found in registry — skipping DEX prices");
+        }
+    }
+
+    if all_prices.is_empty() {
+        return Err(DefiError::Internal(
+            "No prices could be fetched from any source".to_string(),
+        ));
+    }
+
+    // Compute spreads
+    let prices_f64: Vec<f64> = all_prices.iter().map(|p| p.price_f64).collect();
+    let max_price = prices_f64.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
+    let min_price = prices_f64.iter().cloned().fold(f64::INFINITY, f64::min);
+    let max_spread_pct = if min_price > 0.0 {
+        (max_price - min_price) / min_price * 100.0
+    } else {
+        0.0
+    };
+
+    // Oracle vs DEX spread
+    let oracle_prices: Vec<f64> = all_prices
+        .iter()
+        .filter(|p| p.source_type == "oracle")
+        .map(|p| p.price_f64)
+        .collect();
+    let dex_prices: Vec<f64> = all_prices
+        .iter()
+        .filter(|p| p.source_type == "dex_spot")
+        .map(|p| p.price_f64)
+        .collect();
+
+    let oracle_vs_dex_spread_pct = if !oracle_prices.is_empty() && !dex_prices.is_empty() {
+        let avg_oracle = oracle_prices.iter().sum::<f64>() / oracle_prices.len() as f64;
+        let avg_dex = dex_prices.iter().sum::<f64>() / dex_prices.len() as f64;
+        let min_avg = avg_oracle.min(avg_dex);
+        if min_avg > 0.0 {
+            (avg_oracle - avg_dex).abs() / min_avg * 100.0
+        } else {
+            0.0
+        }
+    } else {
+        0.0
+    };
+
+    let report = PriceReport {
+        asset: asset_symbol,
+        asset_address: asset_addr.to_string(),
+        prices: all_prices
+            .iter()
+            .map(|p| PriceEntry {
+                source: p.source.clone(),
+                source_type: p.source_type.clone(),
+                price: (p.price_f64 * 100.0).round() / 100.0,
+            })
+            .collect(),
+        max_spread_pct: (max_spread_pct * 100.0).round() / 100.0,
+        oracle_vs_dex_spread_pct: (oracle_vs_dex_spread_pct * 100.0).round() / 100.0,
+    };
+
+    output.print(&report)?;
+    Ok(())
+}

crates/defi-core/src/traits/mod.rs

@@ -6,6 +6,7 @@ pub mod gauge;
 pub mod lending;
 pub mod liquid_staking;
 pub mod options;
+pub mod oracle;
 pub mod vault;
 pub mod yield_aggregator;
 pub mod yield_source;
@@ -18,6 +19,7 @@ pub use gauge::{Gauge, GaugeSystem, VoteEscrow, Voter};
 pub use lending::Lending;
 pub use liquid_staking::LiquidStaking;
 pub use options::Options;
+pub use oracle::Oracle;
 pub use vault::Vault;
 pub use yield_aggregator::YieldAggregator;
 pub use yield_source::YieldSource;

crates/defi-core/src/traits/oracle.rs

@@ -0,0 +1,15 @@
+use alloy::primitives::Address;
+use async_trait::async_trait;
+
+use crate::error::Result;
+use crate::types::PriceData;
+
+/// Oracle price feed — reads prices from lending protocol oracles or price feeds
+#[async_trait]
+pub trait Oracle: Send + Sync {
+    fn name(&self) -> &str;
+    /// Get price for an asset from this oracle
+    async fn get_price(&self, asset: Address) -> Result<PriceData>;
+    /// Get prices for multiple assets
+    async fn get_prices(&self, assets: &[Address]) -> Result<Vec<PriceData>>;
+}

crates/defi-core/src/types.rs

@@ -357,6 +357,27 @@ pub struct VeNftInfo {
     pub voting_power: U256,
 }
 
+// === Oracle / Price Types ===
+
+/// Price data from an oracle or DEX
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PriceData {
+    /// Source of the price (protocol name or "dex:protocol")
+    pub source: String,
+    /// Source type: "oracle", "dex_spot", "dex_twap"
+    pub source_type: String,
+    /// The asset being priced
+    pub asset: Address,
+    /// Price in USD (18 decimals)
+    pub price_usd: U256,
+    /// Price as f64 for display
+    pub price_f64: f64,
+    /// Block number when price was fetched
+    pub block_number: Option<u64>,
+    /// Timestamp
+    pub timestamp: Option<u64>,
+}
+
 // === Yield Types ===
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

crates/defi-protocols/src/cdp/felix_oracle.rs

@@ -0,0 +1,115 @@
+use alloy::primitives::Address;
+use alloy::providers::ProviderBuilder;
+use alloy::sol;
+use async_trait::async_trait;
+
+use defi_core::error::{DefiError, Result};
+use defi_core::traits::Oracle;
+use defi_core::types::PriceData;
+
+sol! {
+    #[sol(rpc)]
+    interface IFelixPriceFeed {
+        function fetchPrice() external view returns (uint256 price, bool isNewOracleFailureDetected);
+        function lastGoodPrice() external view returns (uint256);
+    }
+}
+
+/// Felix price feed oracle (Liquity V2 style).
+/// Returns the price of the collateral asset (WHYPE) in USD with 18 decimals.
+pub struct FelixOracle {
+    name: String,
+    price_feed: Address,
+    /// The collateral asset this price feed reports on (e.g. WHYPE)
+    asset: Address,
+    rpc_url: String,
+}
+
+impl FelixOracle {
+    pub fn new(name: String, price_feed: Address, asset: Address, rpc_url: String) -> Self {
+        Self {
+            name,
+            price_feed,
+            asset,
+            rpc_url,
+        }
+    }
+
+    pub fn from_contracts(
+        name: String,
+        contracts: &std::collections::HashMap<String, Address>,
+        asset: Address,
+        rpc_url: String,
+    ) -> Result<Self> {
+        let price_feed = contracts.get("price_feed").copied().ok_or_else(|| {
+            DefiError::ContractError(format!("[{name}] Missing 'price_feed' contract address"))
+        })?;
+        Ok(Self {
+            name,
+            price_feed,
+            asset,
+            rpc_url,
+        })
+    }
+
+    fn rpc_url(&self) -> Result<url::Url> {
+        self.rpc_url
+            .parse()
+            .map_err(|e| DefiError::RpcError(format!("Invalid RPC URL: {e}")))
+    }
+}
+
+#[async_trait]
+impl Oracle for FelixOracle {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    async fn get_price(&self, asset: Address) -> Result<PriceData> {
+        if asset != self.asset {
+            return Err(DefiError::Unsupported(format!(
+                "[{}] Felix PriceFeed only supports asset {:?}",
+                self.name, self.asset
+            )));
+        }
+
+        let url = self.rpc_url()?;
+        let provider = ProviderBuilder::new().connect_http(url);
+        let feed = IFelixPriceFeed::new(self.price_feed, &provider);
+
+        // Try fetchPrice first, fall back to lastGoodPrice
+        let price_val = match feed.fetchPrice().call().await {
+            Ok(result) => result.price,
+            Err(_) => {
+                // Fall back to lastGoodPrice
+                feed.lastGoodPrice().call().await.map_err(|e| {
+                    DefiError::RpcError(format!("[{}] lastGoodPrice failed: {e}", self.name))
+                })?
+            }
+        };
+
+        // Felix prices are already in 18-decimal USD
+        let price_f64 = price_val.to::<u128>() as f64 / 1e18;
+
+        Ok(PriceData {
+            source: "Felix PriceFeed".to_string(),
+            source_type: "oracle".to_string(),
+            asset,
+            price_usd: price_val,
+            price_f64,
+            block_number: None,
+            timestamp: None,
+        })
+    }
+
+    async fn get_prices(&self, assets: &[Address]) -> Result<Vec<PriceData>> {
+        let mut results = Vec::new();
+        for &asset in assets {
+            match self.get_price(asset).await {
+                Ok(price) => results.push(price),
+                Err(_) => continue, // Skip unsupported assets
+            }
+        }
+        Ok(results)
+    }
+}