Arbitrage Detection Algorithms for Multi-Platform Agents

import numpy as np
from dataclasses import dataclass, field
from typing import Optional


@dataclass
class ArbOpportunity:
    """Represents a detected arbitrage opportunity."""
    event: str
    outcomes: list[str]
    odds: list[float]          # decimal odds, one per outcome
    platforms: list[str]       # platform name per outcome
    margin: float              # arb margin (1 - sum of inverse odds)
    stakes: list[float]        # optimal stake per outcome for $1 total
    guaranteed_profit: float   # profit per $1 total stake


@dataclass
class OddsEntry:
    """Odds for one outcome from one platform."""
    platform: str
    outcome: str
    decimal_odds: float
    american_odds: Optional[int] = None


def american_to_decimal(american: int) -> float:
    """Convert American odds to decimal odds.

    Args:
        american: American odds (e.g., -110, +250)

    Returns:
        Decimal odds (e.g., 1.909, 3.50)
    """
    if american > 0:
        return 1 + american / 100
    else:
        return 1 + 100 / abs(american)


def detect_two_way_arb(
    odds_a: float,
    odds_b: float,
    fee_rate: float = 0.0
) -> Optional[dict]:
    """Detect arbitrage between two opposing outcomes.

    Args:
        odds_a: Decimal odds for outcome A (from platform 1)
        odds_b: Decimal odds for outcome B (from platform 2)
        fee_rate: Combined fee rate across platforms (decimal)

    Returns:
        Dict with arb details if arb exists, None otherwise.
    """
    implied_sum = 1 / odds_a + 1 / odds_b
    margin = 1 - implied_sum

    if margin <= fee_rate:
        return None

    net_margin = margin - fee_rate
    total_inverse = implied_sum

    stake_a = (1 / odds_a) / total_inverse
    stake_b = (1 / odds_b) / total_inverse

    return {
        "margin": margin,
        "net_margin": net_margin,
        "implied_sum": implied_sum,
        "stake_a_pct": stake_a,
        "stake_b_pct": stake_b,
        "profit_per_dollar": net_margin / total_inverse,
    }


def detect_n_way_arb(
    odds: list[float],
    fee_rate: float = 0.0
) -> Optional[dict]:
    """Detect arbitrage across n outcomes.

    Args:
        odds: List of best decimal odds, one per outcome.
        fee_rate: Combined fee rate across platforms (decimal).

    Returns:
        Dict with arb details if arb exists, None otherwise.
    """
    inverses = np.array([1 / o for o in odds])
    implied_sum = float(np.sum(inverses))
    margin = 1 - implied_sum

    if margin <= fee_rate:
        return None

    net_margin = margin - fee_rate
    stakes = inverses / implied_sum  # dutching allocation

    return {
        "margin": margin,
        "net_margin": net_margin,
        "implied_sum": implied_sum,
        "stakes": stakes.tolist(),
        "profit_per_dollar": net_margin / implied_sum,
    }


def compute_stakes(
    total_bankroll: float,
    odds: list[float],
) -> list[float]:
    """Compute optimal dutching stakes for a given bankroll.

    Args:
        total_bankroll: Total amount to allocate across all outcomes.
        odds: Decimal odds per outcome.

    Returns:
        List of dollar amounts to stake on each outcome.
    """
    inverses = np.array([1 / o for o in odds])
    implied_sum = float(np.sum(inverses))
    stakes = total_bankroll * inverses / implied_sum
    return stakes.tolist()


def scan_sportsbook_arbs(
    events: list[dict],
    min_margin: float = 0.005,
    max_fee: float = 0.0
) -> list[ArbOpportunity]:
    """Scan a list of events for two-way arb opportunities.

    Each event dict has format:
    {
        "name": "Lakers vs Celtics",
        "outcomes": {
            "Lakers": [{"platform": "BetOnline", "odds": 2.65}, ...],
            "Celtics": [{"platform": "Bookmaker", "odds": 1.667}, ...]
        }
    }

    Args:
        events: List of event dicts with odds per outcome per platform.
        min_margin: Minimum arb margin to report (default 0.5%).
        max_fee: Maximum combined fee rate to deduct.

    Returns:
        List of ArbOpportunity objects sorted by margin descending.
    """
    arbs = []

    for event in events:
        outcomes = list(event["outcomes"].keys())
        if len(outcomes) < 2:
            continue

        # For two-way: find best odds for each outcome across platforms
        if len(outcomes) == 2:
            best = {}
            for outcome_name in outcomes:
                platform_odds = event["outcomes"][outcome_name]
                best_entry = max(platform_odds, key=lambda x: x["odds"])
                best[outcome_name] = best_entry

            names = list(best.keys())
            odds_list = [best[n]["odds"] for n in names]
            platforms = [best[n]["platform"] for n in names]

            result = detect_two_way_arb(odds_list[0], odds_list[1], max_fee)
            if result and result["net_margin"] >= min_margin:
                stakes = compute_stakes(1.0, odds_list)
                arbs.append(ArbOpportunity(
                    event=event["name"],
                    outcomes=names,
                    odds=odds_list,
                    platforms=platforms,
                    margin=result["margin"],
                    stakes=stakes,
                    guaranteed_profit=result["profit_per_dollar"],
                ))

        # For three-way (or n-way): find best odds per outcome
        else:
            best = {}
            for outcome_name in outcomes:
                platform_odds = event["outcomes"][outcome_name]
                best_entry = max(platform_odds, key=lambda x: x["odds"])
                best[outcome_name] = best_entry

            names = list(best.keys())
            odds_list = [best[n]["odds"] for n in names]
            platforms = [best[n]["platform"] for n in names]

            result = detect_n_way_arb(odds_list, max_fee)
            if result and result["net_margin"] >= min_margin:
                stakes = compute_stakes(1.0, odds_list)
                arbs.append(ArbOpportunity(
                    event=event["name"],
                    outcomes=names,
                    odds=odds_list,
                    platforms=platforms,
                    margin=result["margin"],
                    stakes=stakes,
                    guaranteed_profit=result["profit_per_dollar"],
                ))

    arbs.sort(key=lambda a: a.margin, reverse=True)
    return arbs


# ── Example: scan with real-format data ──────────────────────────

if __name__ == "__main__":
    # Simulated multi-platform odds (format matches The Odds API output)
    events = [
        {
            "name": "Lakers vs Celtics — NBA 2026-03-22",
            "outcomes": {
                "Lakers": [
                    {"platform": "BetOnline", "odds": 2.65},
                    {"platform": "Bovada", "odds": 2.50},
                    {"platform": "Bookmaker", "odds": 2.55},
                ],
                "Celtics": [
                    {"platform": "BetOnline", "odds": 1.55},
                    {"platform": "Bovada", "odds": 1.60},
                    {"platform": "Bookmaker", "odds": 1.667},
                ],
            }
        },
        {
            "name": "Arsenal vs Chelsea — EPL 2026-03-22",
            "outcomes": {
                "Arsenal": [
                    {"platform": "BetOnline", "odds": 2.40},
                    {"platform": "Bovada", "odds": 2.35},
                ],
                "Draw": [
                    {"platform": "BetOnline", "odds": 3.80},
                    {"platform": "Bovada", "odds": 3.50},
                ],
                "Chelsea": [
                    {"platform": "BetOnline", "odds": 3.10},
                    {"platform": "Bookmaker", "odds": 3.25},
                ],
            }
        },
    ]

    arbs = scan_sportsbook_arbs(events, min_margin=0.001)

    if not arbs:
        print("No arbs found.")
    else:
        for arb in arbs:
            print(f"\n{'='*60}")
            print(f"EVENT: {arb.event}")
            print(f"MARGIN: {arb.margin:.2%}")
            print(f"PROFIT per $1,000: ${arb.guaranteed_profit * 1000:.2f}")
            print()
            total_stake = 1000
            stakes = compute_stakes(total_stake, arb.odds)
            for i, outcome in enumerate(arb.outcomes):
                print(f"  {outcome:>12} @ {arb.odds[i]:.3f} on {arb.platforms[i]:<12} "
                      f"→ Stake ${stakes[i]:>8.2f}  "
                      f"→ Payout ${stakes[i] * arb.odds[i]:>8.2f}")

import requests
import numpy as np
from itertools import product


def fetch_odds_api(
    api_key: str,
    sport: str = "basketball_nba",
    regions: str = "us,us2,eu",
    markets: str = "h2h",
    odds_format: str = "decimal"
) -> list[dict]:
    """Fetch live odds from The Odds API.

    Args:
        api_key: Your Odds API key.
        sport: Sport key (e.g., basketball_nba, soccer_epl).
        regions: Comma-separated regions (us, us2, eu, uk, au).
        markets: Market type (h2h, spreads, totals).
        odds_format: decimal or american.

    Returns:
        List of event dicts from the API.
    """
    url = "https://api.the-odds-api.com/v4/sports/{}/odds/".format(sport)
    resp = requests.get(url, params={
        "apiKey": api_key,
        "regions": regions,
        "markets": markets,
        "oddsFormat": odds_format,
    })
    resp.raise_for_status()
    return resp.json()


def parse_odds_api_to_events(raw_events: list[dict]) -> list[dict]:
    """Convert Odds API response to our scanner format.

    Args:
        raw_events: Raw JSON from The Odds API.

    Returns:
        List of event dicts compatible with scan_sportsbook_arbs().
    """
    parsed = []
    for event in raw_events:
        outcomes_map: dict[str, list[dict]] = {}
        for bookmaker in event.get("bookmakers", []):
            platform = bookmaker["title"]
            for market in bookmaker.get("markets", []):
                if market["key"] != "h2h":
                    continue
                for outcome in market["outcomes"]:
                    name = outcome["name"]
                    odds = outcome["price"]
                    if name not in outcomes_map:
                        outcomes_map[name] = []
                    outcomes_map[name].append({
                        "platform": platform,
                        "odds": odds,
                    })

        if len(outcomes_map) >= 2:
            parsed.append({
                "name": f"{event['home_team']} vs {event['away_team']}",
                "outcomes": outcomes_map,
            })

    return parsed


# ── Full pipeline ────────────────────────────────────────────────

def run_arb_scan(api_key: str, sport: str = "basketball_nba") -> list:
    """End-to-end arb scan: fetch odds → detect arbs → return results.

    Args:
        api_key: The Odds API key.
        sport: Sport key to scan.

    Returns:
        List of ArbOpportunity objects.
    """
    raw = fetch_odds_api(api_key, sport=sport)
    events = parse_odds_api_to_events(raw)
    arbs = scan_sportsbook_arbs(events, min_margin=0.005)
    return arbs

import requests


def fetch_polymarket_price(condition_id: str) -> dict:
    """Fetch YES/NO prices from Polymarket for a condition.

    Args:
        condition_id: The Polymarket condition ID.

    Returns:
        Dict with yes_price, no_price, and spread.
    """
    url = f"https://clob.polymarket.com/midpoint?token_id={condition_id}"
    resp = requests.get(url)
    resp.raise_for_status()
    data = resp.json()
    mid = float(data.get("mid", 0))
    return {
        "yes_price": mid,
        "no_price": 1 - mid,
    }


def detect_cross_platform_arb(
    pm_yes_price: float,
    sportsbook_no_implied: float,
    pm_fee: float = 0.02,
    sb_fee: float = 0.0
) -> Optional[dict]:
    """Detect arb between a prediction market YES and sportsbook NO.

    Args:
        pm_yes_price: Polymarket YES price (e.g., 0.42).
        sportsbook_no_implied: Sportsbook implied NO probability (e.g., 0.53).
        pm_fee: Polymarket fee on winnings (default 2%).
        sb_fee: Sportsbook effective fee rate.

    Returns:
        Dict with arb details or None.
    """
    total_cost = pm_yes_price + sportsbook_no_implied
    raw_margin = 1 - total_cost

    if raw_margin <= 0:
        return None

    # Worst-case fee: PM fee on YES profit if event happens
    pm_profit_if_yes = 1 - pm_yes_price
    pm_fee_cost = pm_fee * pm_profit_if_yes

    # Sportsbook fee on NO profit if event doesn't happen
    sb_profit_if_no = 1 - sportsbook_no_implied
    sb_fee_cost = sb_fee * sb_profit_if_no

    max_fee = max(pm_fee_cost, sb_fee_cost)
    net_margin = raw_margin - max_fee

    if net_margin <= 0:
        return None

    return {
        "raw_margin": raw_margin,
        "net_margin": net_margin,
        "total_cost": total_cost,
        "pm_yes_stake_pct": pm_yes_price / total_cost,
        "sb_no_stake_pct": sportsbook_no_implied / total_cost,
    }


# ── Example: Trump 2028 cross-platform arb ──────────────────────

pm_yes = 0.42   # Polymarket YES price
sb_no = 0.53    # Sportsbook implied NO probability (from +170 underdog line)

result = detect_cross_platform_arb(pm_yes, sb_no)
if result:
    print(f"Cross-platform arb detected!")
    print(f"  Raw margin:   {result['raw_margin']:.2%}")
    print(f"  Net margin:   {result['net_margin']:.2%}")
    print(f"  Total cost:   ${result['total_cost']:.2f} per $1 payout")
    print(f"  PM stake:     {result['pm_yes_stake_pct']:.1%} of total")
    print(f"  SB stake:     {result['sb_no_stake_pct']:.1%} of total")