@ebowwa/quant-rust 0.1.0

package/src/prediction/amm.rs

@@ -0,0 +1,338 @@
+//! # AMM Calculations (Constant Product Market Maker)
+//!
+//! Calculations for constant product AMMs (Uniswap V2 style) used in prediction markets.
+
+use crate::prediction::Outcome;
+
+/// State of a constant product AMM
+#[derive(Debug, Clone, Copy)]
+pub struct AMMState {
+    /// Shares in YES pool
+    pub pool_yes: f64,
+    /// Shares in NO pool
+    pub pool_no: f64,
+    /// Constant product (pool_yes * pool_no)
+    pub k: f64,
+    /// Total LP tokens outstanding
+    pub lp_token_supply: f64,
+    /// Fee in basis points
+    pub fee: f64,
+}
+
+impl AMMState {
+    /// Create a new AMM state
+    pub fn new(pool_yes: f64, pool_no: f64, lp_token_supply: f64, fee: f64) -> Self {
+        let k = pool_yes * pool_no;
+        Self {
+            pool_yes,
+            pool_no,
+            k,
+            lp_token_supply,
+            fee,
+        }
+    }
+}
+
+/// Result of price impact calculation
+#[derive(Debug, Clone, Copy)]
+pub struct PriceImpactResult {
+    /// Current price before trade
+    pub current_price: f64,
+    /// Price after trade execution
+    pub new_price: f64,
+    /// Average price paid per share
+    pub avg_price: f64,
+    /// Price impact as percentage
+    pub price_impact: f64,
+    /// Slippage from current price
+    pub slippage: f64,
+}
+
+/// Calculate price after buying shares (constant product AMM).
+///
+/// Uses xy = k invariant. When buying YES, the YES price increases.
+///
+/// # Arguments
+/// * `state` - Current AMM state
+/// * `outcome` - Which outcome to buy (Yes or No)
+/// * `shares` - Number of shares to buy
+///
+/// # Returns
+/// Price after the trade
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::amm::{AMMState, amm_price_after_buy};
+/// use quant_rust::prediction::Outcome;
+/// let state = AMMState::new(1000.0, 1000.0, 1000.0, 0.0);
+/// let price = amm_price_after_buy(&state, Outcome::Yes, 100.0);
+/// assert!(price > 0.5); // Price increases after buying YES
+/// ```
+pub fn amm_price_after_buy(state: &AMMState, outcome: Outcome, shares: f64) -> f64 {
+    let AMMState { pool_yes, pool_no, .. } = *state;
+
+    match outcome {
+        Outcome::Yes => {
+            // Buying YES: poolNo increases (you're betting against NO)
+            // The pool balances shift to reflect higher YES probability
+            let new_pool_no = pool_no + shares * (pool_no / pool_yes);
+            new_pool_no / (pool_yes + new_pool_no)
+        }
+        Outcome::No => {
+            // Buying NO: poolYes increases
+            let new_pool_yes = pool_yes + shares * (pool_yes / pool_no);
+            new_pool_yes / (new_pool_yes + pool_no)
+        }
+    }
+}
+
+/// Calculate cost to buy shares (constant product AMM).
+///
+/// # Arguments
+/// * `state` - Current AMM state
+/// * `outcome` - Which outcome to buy
+/// * `shares` - Number of shares to buy
+///
+/// # Returns
+/// Cost in quote currency
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::amm::{AMMState, amm_buy_cost};
+/// use quant_rust::prediction::Outcome;
+/// let state = AMMState::new(1000.0, 1000.0, 1000.0, 0.0);
+/// let cost = amm_buy_cost(&state, Outcome::Yes, 100.0);
+/// assert!(cost > 0.0);
+/// ```
+pub fn amm_buy_cost(state: &AMMState, outcome: Outcome, shares: f64) -> f64 {
+    let AMMState { pool_yes, pool_no, k, .. } = *state;
+
+    match outcome {
+        Outcome::Yes => {
+            // Buying YES shares
+            // After: newPoolYes = poolYes + shares
+            // newPoolNo = k / (poolYes + shares)
+            let new_pool_no = k / (pool_yes + shares);
+            pool_no - new_pool_no
+        }
+        Outcome::No => {
+            // Buying NO shares
+            let new_pool_yes = k / (pool_no + shares);
+            pool_yes - new_pool_yes
+        }
+    }
+}
+
+/// Calculate shares received for a given cost.
+///
+/// # Arguments
+/// * `state` - Current AMM state
+/// * `outcome` - Which outcome to buy
+/// * `cost` - Amount to spend in quote currency
+///
+/// # Returns
+/// Number of shares received
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::amm::{AMMState, amm_shares_received};
+/// use quant_rust::prediction::Outcome;
+/// let state = AMMState::new(1000.0, 1000.0, 1000.0, 0.0);
+/// let shares = amm_shares_received(&state, Outcome::Yes, 50.0);
+/// assert!(shares > 0.0);
+/// ```
+pub fn amm_shares_received(state: &AMMState, outcome: Outcome, cost: f64) -> f64 {
+    let AMMState { pool_yes, pool_no, k, .. } = *state;
+
+    match outcome {
+        Outcome::Yes => {
+            // Spending from NO pool side
+            let new_pool_no = pool_no - cost;
+            let new_pool_yes = k / new_pool_no;
+            new_pool_yes - pool_yes
+        }
+        Outcome::No => {
+            let new_pool_yes = pool_yes - cost;
+            let new_pool_no = k / new_pool_yes;
+            new_pool_no - pool_no
+        }
+    }
+}
+
+/// Calculate price impact of a trade.
+///
+/// # Arguments
+/// * `state` - Current AMM state
+/// * `outcome` - Which outcome to buy
+/// * `shares` - Number of shares to buy
+///
+/// # Returns
+/// PriceImpactResult with detailed metrics
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::amm::{AMMState, amm_price_impact};
+/// use quant_rust::prediction::Outcome;
+/// let state = AMMState::new(1000.0, 1000.0, 1000.0, 0.0);
+/// let impact = amm_price_impact(&state, Outcome::Yes, 100.0);
+/// assert!(impact.price_impact > 0.0);
+/// ```
+pub fn amm_price_impact(state: &AMMState, outcome: Outcome, shares: f64) -> PriceImpactResult {
+    let AMMState { pool_yes, pool_no, .. } = *state;
+
+    // Current price
+    let current_price = match outcome {
+        Outcome::Yes => pool_no / (pool_yes + pool_no),
+        Outcome::No => pool_yes / (pool_yes + pool_no),
+    };
+
+    let new_price = amm_price_after_buy(state, outcome, shares);
+    let cost = amm_buy_cost(state, outcome, shares);
+    let avg_price = if shares > 0.0 { cost / shares } else { 0.0 };
+
+    let price_impact = if current_price > 0.0 {
+        (new_price - current_price).abs() / current_price
+    } else {
+        0.0
+    };
+
+    let slippage = if current_price > 0.0 {
+        (avg_price - current_price).abs() / current_price
+    } else {
+        0.0
+    };
+
+    PriceImpactResult {
+        current_price,
+        new_price,
+        avg_price,
+        price_impact,
+        slippage,
+    }
+}
+
+/// Calculate impermanent loss for LP.
+///
+/// Impermanent loss is the loss incurred by providing liquidity compared to
+/// simply holding the assets.
+///
+/// # Arguments
+/// * `initial_price` - Initial price (as probability 0-1)
+/// * `current_price` - Current price
+///
+/// # Returns
+/// Impermanent loss as a decimal (e.g., 0.05 = 5% loss)
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::amm::amm_impermanent_loss;
+/// let il = amm_impermanent_loss(0.5, 0.6);
+/// assert!(il > 0.0);
+/// ```
+pub fn amm_impermanent_loss(initial_price: f64, current_price: f64) -> f64 {
+    if initial_price <= 0.0 || current_price <= 0.0 {
+        return 0.0;
+    }
+
+    let price_ratio = current_price / initial_price;
+
+    // IL = 2 * sqrt(price_ratio) / (1 + price_ratio) - 1
+    let il = (2.0 * price_ratio.sqrt()) / (1.0 + price_ratio) - 1.0;
+    il.abs()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn create_balanced_pool() -> AMMState {
+        AMMState::new(1000.0, 1000.0, 1000.0, 0.0)
+    }
+
+    #[test]
+    fn test_amm_state_creation() {
+        let state = create_balanced_pool();
+        assert_eq!(state.pool_yes, 1000.0);
+        assert_eq!(state.pool_no, 1000.0);
+        assert_eq!(state.k, 1000000.0);
+    }
+
+    #[test]
+    fn test_amm_buy_cost_yes() {
+        let state = create_balanced_pool();
+        let cost = amm_buy_cost(&state, Outcome::Yes, 100.0);
+        // Cost should be less than shares at current price (0.5)
+        // because we get a better rate initially
+        assert!(cost > 0.0);
+        assert!(cost < 100.0); // Less than 100 * 0.5 would be at current price
+    }
+
+    #[test]
+    fn test_amm_buy_cost_no() {
+        let state = create_balanced_pool();
+        let cost = amm_buy_cost(&state, Outcome::No, 100.0);
+        assert!(cost > 0.0);
+    }
+
+    #[test]
+    fn test_amm_price_after_buy() {
+        let state = create_balanced_pool();
+        let price_before = 0.5;
+        let price_after = amm_price_after_buy(&state, Outcome::Yes, 100.0);
+        // Buying YES should increase YES price
+        assert!(price_after > price_before);
+    }
+
+    #[test]
+    fn test_amm_shares_received() {
+        let state = create_balanced_pool();
+        let cost = 50.0;
+        let shares = amm_shares_received(&state, Outcome::Yes, cost);
+        assert!(shares > 0.0);
+        // Verify round-trip: shares received for cost should equal cost to buy shares
+        let cost_check = amm_buy_cost(&state, Outcome::Yes, shares);
+        assert!((cost - cost_check).abs() < 1e-6);
+    }
+
+    #[test]
+    fn test_amm_price_impact() {
+        let state = create_balanced_pool();
+        let impact = amm_price_impact(&state, Outcome::Yes, 100.0);
+        assert_eq!(impact.current_price, 0.5);
+        assert!(impact.new_price > 0.5);
+        assert!(impact.price_impact > 0.0);
+        assert!(impact.slippage >= 0.0);
+    }
+
+    #[test]
+    fn test_amm_impermanent_loss_no_change() {
+        let il = amm_impermanent_loss(0.5, 0.5);
+        assert!((il - 0.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_amm_impermanent_loss_with_change() {
+        let il = amm_impermanent_loss(0.5, 0.6);
+        assert!(il > 0.0);
+        assert!(il < 0.1); // Should be relatively small for this price change
+    }
+
+    #[test]
+    fn test_amm_impermanent_loss_symmetry() {
+        // IL is symmetric in terms of price RATIOS that are inverses
+        // price_ratio = 0.7/0.5 = 1.4 and price_ratio = 0.5/0.7 ≈ 0.714
+        // These give the same IL (using reciprocal ratios)
+        let il_up = amm_impermanent_loss(0.5, 0.7);
+        let il_down = amm_impermanent_loss(0.7, 0.5);
+        // IL should be the same for inverse price moves
+        assert!((il_up - il_down).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_large_trade_high_impact() {
+        let state = create_balanced_pool();
+        // Buying 50% of pool should cause significant impact
+        let impact = amm_price_impact(&state, Outcome::Yes, 500.0);
+        assert!(impact.price_impact > 0.1); // More than 10% impact
+    }
+}

package/src/prediction/arbitrage.rs

@@ -0,0 +1,230 @@
+//! # Arbitrage Detection
+//!
+//! Detect arbitrage opportunities in prediction markets.
+
+/// A single arbitrage opportunity
+#[derive(Debug, Clone, Copy)]
+pub struct ArbitrageOpportunity {
+    /// Price of YES shares
+    pub yes_price: f64,
+    /// Price of NO shares
+    pub no_price: f64,
+    /// Profit per $1 invested
+    pub profit: f64,
+    /// Amount to invest in YES
+    pub yes_size: f64,
+    /// Amount to invest in NO
+    pub no_size: f64,
+}
+
+/// Market price information for cross-market arbitrage
+#[derive(Debug, Clone)]
+pub struct MarketPrice {
+    /// Market name/identifier
+    pub name: String,
+    /// YES price
+    pub yes_price: f64,
+    /// NO price
+    pub no_price: f64,
+}
+
+/// Cross-market arbitrage opportunity
+#[derive(Debug, Clone)]
+pub struct CrossMarketArbitrage {
+    /// Market to buy YES from
+    pub yes_market: String,
+    /// Market to buy NO from
+    pub no_market: String,
+    /// Price of YES
+    pub yes_price: f64,
+    /// Price of NO
+    pub no_price: f64,
+    /// Total cost (yes_price + no_price)
+    pub total_cost: f64,
+    /// Profit per $1 invested
+    pub profit: f64,
+}
+
+/// Detect arbitrage opportunity (YES + NO prices < 1).
+///
+/// If YES price + NO price < 1, you can buy both and guarantee a profit.
+///
+/// # Arguments
+/// * `yes_price` - Price of YES shares (0-1)
+/// * `no_price` - Price of NO shares (0-1)
+///
+/// # Returns
+/// Some(ArbitrageOpportunity) if arbitrage exists, None otherwise
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::arbitrage::detect_arbitrage;
+/// let arb = detect_arbitrage(0.45, 0.45);
+/// assert!(arb.is_some());
+/// assert!((arb.unwrap().profit - 0.10).abs() < 1e-10);
+/// ```
+pub fn detect_arbitrage(yes_price: f64, no_price: f64) -> Option<ArbitrageOpportunity> {
+    let total = yes_price + no_price;
+
+    if total >= 1.0 {
+        return None;
+    }
+
+    // Buy equal amounts of both, guaranteed $1 back
+    let profit = 1.0 - total;
+
+    // For $1 investment: buy such that we get same payout either way
+    // If we spend $x on YES at price p_yes and $y on NO at price p_no
+    // x + y = 1 and x/p_yes = y/p_no (equal shares)
+    // x = p_yes / (p_yes + p_no), y = p_no / (p_yes + p_no)
+    let yes_size = yes_price / total;
+    let no_size = no_price / total;
+
+    Some(ArbitrageOpportunity {
+        yes_price,
+        no_price,
+        profit,
+        yes_size,
+        no_size,
+    })
+}
+
+/// Find best arbitrage across multiple markets on the same question.
+///
+/// Looks for cheapest YES and cheapest NO across all markets.
+///
+/// # Arguments
+/// * `markets` - Slice of market prices
+///
+/// # Returns
+/// Some(CrossMarketArbitrage) if arbitrage exists, None otherwise
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::arbitrage::{find_cross_market_arbitrage, MarketPrice};
+/// let markets = vec![
+///     MarketPrice { name: "market_a".to_string(), yes_price: 0.50, no_price: 0.55 },
+///     MarketPrice { name: "market_b".to_string(), yes_price: 0.45, no_price: 0.60 },
+/// ];
+/// let arb = find_cross_market_arbitrage(&markets);
+/// // Cheapest YES (0.45) + cheapest NO (0.55) = 1.0, no arb
+/// assert!(arb.is_none());
+/// ```
+pub fn find_cross_market_arbitrage(markets: &[MarketPrice]) -> Option<CrossMarketArbitrage> {
+    if markets.is_empty() {
+        return None;
+    }
+
+    // Find cheapest YES and cheapest NO across markets
+    let mut cheapest_yes = Option::<(&MarketPrice, f64)>::None;
+    let mut cheapest_no = Option::<(&MarketPrice, f64)>::None;
+
+    for market in markets {
+        if cheapest_yes.is_none() || market.yes_price < cheapest_yes.unwrap().1 {
+            cheapest_yes = Some((market, market.yes_price));
+        }
+        if cheapest_no.is_none() || market.no_price < cheapest_no.unwrap().1 {
+            cheapest_no = Some((market, market.no_price));
+        }
+    }
+
+    let (yes_market, yes_price) = cheapest_yes?;
+    let (no_market, no_price) = cheapest_no?;
+
+    // Check if combined < 1
+    let total_cost = yes_price + no_price;
+
+    if total_cost >= 1.0 {
+        return None;
+    }
+
+    let profit = 1.0 - total_cost;
+
+    Some(CrossMarketArbitrage {
+        yes_market: yes_market.name.clone(),
+        no_market: no_market.name.clone(),
+        yes_price,
+        no_price,
+        total_cost,
+        profit,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_detect_arbitrage_exists() {
+        let arb = detect_arbitrage(0.45, 0.45);
+        assert!(arb.is_some());
+        let arb = arb.unwrap();
+        assert!((arb.profit - 0.10).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_detect_arbitrage_none() {
+        let arb = detect_arbitrage(0.55, 0.55);
+        assert!(arb.is_none());
+    }
+
+    #[test]
+    fn test_detect_arbitrage_exactly_one() {
+        let arb = detect_arbitrage(0.50, 0.50);
+        assert!(arb.is_none()); // No profit if exactly 1.0
+    }
+
+    #[test]
+    fn test_detect_arbitrage_sizes() {
+        let arb = detect_arbitrage(0.40, 0.50).unwrap();
+        // Total = 0.90, so yes_size = 0.40/0.90, no_size = 0.50/0.90
+        assert!((arb.yes_size - 0.4444).abs() < 0.01);
+        assert!((arb.no_size - 0.5556).abs() < 0.01);
+        assert!((arb.yes_size + arb.no_size - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_find_cross_market_arbitrage_exists() {
+        let markets = vec![
+            MarketPrice { name: "a".to_string(), yes_price: 0.40, no_price: 0.65 },
+            MarketPrice { name: "b".to_string(), yes_price: 0.55, no_price: 0.45 },
+        ];
+        let arb = find_cross_market_arbitrage(&markets);
+        assert!(arb.is_some());
+        let arb = arb.unwrap();
+        // Cheapest: YES=0.40 (a), NO=0.45 (b), total=0.85
+        assert_eq!(arb.yes_market, "a");
+        assert_eq!(arb.no_market, "b");
+        assert!((arb.profit - 0.15).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_find_cross_market_arbitrage_none() {
+        let markets = vec![
+            MarketPrice { name: "a".to_string(), yes_price: 0.55, no_price: 0.55 },
+            MarketPrice { name: "b".to_string(), yes_price: 0.60, no_price: 0.50 },
+        ];
+        let arb = find_cross_market_arbitrage(&markets);
+        assert!(arb.is_none()); // Cheapest 0.55 + 0.50 = 1.05 > 1
+    }
+
+    #[test]
+    fn test_find_cross_market_empty() {
+        let markets: Vec<MarketPrice> = vec![];
+        let arb = find_cross_market_arbitrage(&markets);
+        assert!(arb.is_none());
+    }
+
+    #[test]
+    fn test_find_cross_market_same_market() {
+        // Arb can exist within a single market
+        let markets = vec![
+            MarketPrice { name: "a".to_string(), yes_price: 0.45, no_price: 0.45 },
+        ];
+        let arb = find_cross_market_arbitrage(&markets);
+        assert!(arb.is_some());
+        let arb = arb.unwrap();
+        assert_eq!(arb.yes_market, "a");
+        assert_eq!(arb.no_market, "a");
+    }
+}