Add strategies module

polymarket_bot/strategies.py

@@ -0,0 +1,539 @@
+"""
+Stratégies de trading pour Polymarket.
+3 stratégies basées sur la recherche académique:
+1. Arbitrage intra-marché (YES+NO < $1)
+2. Value Bet assisté par LLM
+3. Leader-Follower sémantique
+"""
+import asyncio
+import logging
+import math
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional
+
+from .config import BotConfig
+from .data import Market, OrderBook, CLOBDataClient, GammaClient
+from .execution import ExecutionEngine, Trade
+
+logger = logging.getLogger("polybot.strategies")
+
+
+# ══════════════════════════════════════════════════════════════════
+# UTILS
+# ══════════════════════════════════════════════════════════════════
+def kelly_fraction(p_true: float, p_market: float, kelly_mult: float = 0.25) -> float:
+    """
+    Calcule la fraction Kelly pour un marché binaire.
+    p_true:     probabilité estimée réelle
+    p_market:   prix du marché (probabilité implicite)
+    kelly_mult: multiplicateur Kelly (0.25 = quart Kelly, conservateur)
+    """
+    if p_market <= 0 or p_market >= 1 or p_true <= 0 or p_true >= 1:
+        return 0.0
+
+    b = (1.0 - p_market) / p_market  # cote nette
+    q = 1.0 - p_true
+    kelly = (b * p_true - q) / b
+
+    return max(0.0, min(kelly * kelly_mult, 0.20))  # Cap à 20% du bankroll
+
+
+@dataclass
+class Signal:
+    """Signal de trading généré par une stratégie."""
+    market_id: str
+    strategy: str
+    action: str           # "BUY_YES", "BUY_NO", "ARB_LONG", "ARB_SHORT"
+    confidence: float     # 0-1
+    expected_profit: float
+    size_usd: float
+    metadata: dict = None
+
+    def __post_init__(self):
+        if self.metadata is None:
+            self.metadata = {}
+
+
+# ══════════════════════════════════════════════════════════════════
+# BASE STRATEGY
+# ══════════════════════════════════════════════════════════════════
+class BaseStrategy(ABC):
+    """Classe de base pour toutes les stratégies."""
+
+    def __init__(self, config: BotConfig, clob_client: CLOBDataClient):
+        self.config = config
+        self.clob = clob_client
+
+    @abstractmethod
+    async def scan(self, markets: list[Market]) -> list[Signal]:
+        """Scanne les marchés et retourne des signaux."""
+        pass
+
+    @abstractmethod
+    async def execute(self, signal: Signal, engine: ExecutionEngine) -> Optional[Trade]:
+        """Exécute un signal."""
+        pass
+
+
+# ══════════════════════════════════════════════════════════════════
+# STRATÉGIE 1: ARBITRAGE INTRA-MARCHÉ
+# ══════════════════════════════════════════════════════════════════
+class ArbitrageStrategy(BaseStrategy):
+    """
+    Arbitrage sans risque: acheter YES + NO quand la somme < $1.
+    Basé sur arxiv:2508.03474 — $40M de profit réalisé sur Polymarket.
+
+    Logique:
+    - Détecter quand best_ask(YES) + best_ask(NO) < 1.0 - min_spread
+    - Acheter les deux côtés simultanément
+    - Profit garanti à la résolution ($1 par paire)
+    """
+
+    async def scan(self, markets: list[Market]) -> list[Signal]:
+        signals = []
+
+        for market in markets:
+            yes = market.yes_token
+            no = market.no_token
+
+            if not yes or not no:
+                continue
+
+            # Filtre: ignorer les marchés quasi-résolus
+            if yes.price > self.config.arb_max_price_filter or \
+               no.price > self.config.arb_max_price_filter:
+                continue
+
+            # Récupérer les carnets d'ordres
+            try:
+                yes_book, no_book = await asyncio.gather(
+                    self.clob.get_order_book(yes.token_id),
+                    self.clob.get_order_book(no.token_id),
+                )
+            except Exception as e:
+                logger.debug(f"Failed to get order books for {market.market_id}: {e}")
+                continue
+
+            if not yes_book or not no_book:
+                continue
+            if not yes_book.asks or not no_book.asks:
+                continue
+
+            best_yes_ask = yes_book.best_ask
+            best_no_ask = no_book.best_ask
+
+            if best_yes_ask is None or best_no_ask is None:
+                continue
+
+            combined = best_yes_ask + best_no_ask
+            spread = 1.0 - combined
+
+            # LONG ARBITRAGE: YES + NO < $1
+            if spread > self.config.arb_min_spread:
+                # Calculer la taille maximale (limitée par la liquidité)
+                max_yes_size = sum(l.size for l in yes_book.asks[:3])
+                max_no_size = sum(l.size for l in no_book.asks[:3])
+                max_size = min(max_yes_size, max_no_size)
+
+                # Limiter par capital
+                cost_per_share = combined
+                max_affordable = self.config.arb_max_position_usd / cost_per_share
+                size = min(max_size, max_affordable)
+
+                if size * spread > 1.0:  # Min $1 de profit
+                    expected_profit = size * spread
+                    signals.append(Signal(
+                        market_id=market.market_id,
+                        strategy="arbitrage",
+                        action="ARB_LONG",
+                        confidence=min(spread / 0.10, 1.0),
+                        expected_profit=expected_profit,
+                        size_usd=size * cost_per_share,
+                        metadata={
+                            "yes_ask": best_yes_ask,
+                            "no_ask": best_no_ask,
+                            "combined": combined,
+                            "spread": spread,
+                            "size_shares": size,
+                            "yes_token_id": yes.token_id,
+                            "no_token_id": no.token_id,
+                            "yes_depth": yes_book.total_ask_depth,
+                            "no_depth": no_book.total_ask_depth,
+                            "question": market.question,
+                        }
+                    ))
+
+            # SHORT ARBITRAGE: YES + NO > $1 (sell both)
+            if yes_book.bids and no_book.bids:
+                best_yes_bid = yes_book.best_bid
+                best_no_bid = no_book.best_bid
+                if best_yes_bid and best_no_bid:
+                    combined_bid = best_yes_bid + best_no_bid
+                    if combined_bid > 1.0 + self.config.arb_min_spread:
+                        short_spread = combined_bid - 1.0
+                        max_size = min(
+                            sum(l.size for l in yes_book.bids[:3]),
+                            sum(l.size for l in no_book.bids[:3]),
+                        )
+                        if max_size * short_spread > 1.0:
+                            signals.append(Signal(
+                                market_id=market.market_id,
+                                strategy="arbitrage",
+                                action="ARB_SHORT",
+                                confidence=min(short_spread / 0.10, 1.0),
+                                expected_profit=max_size * short_spread,
+                                size_usd=max_size * combined_bid,
+                                metadata={
+                                    "yes_bid": best_yes_bid,
+                                    "no_bid": best_no_bid,
+                                    "combined": combined_bid,
+                                    "spread": short_spread,
+                                    "size_shares": max_size,
+                                    "yes_token_id": yes.token_id,
+                                    "no_token_id": no.token_id,
+                                    "question": market.question,
+                                }
+                            ))
+
+        if signals:
+            logger.info(f"🔍 Arbitrage scan: {len(signals)} opportunities found")
+        return signals
+
+    async def execute(self, signal: Signal, engine: ExecutionEngine) -> Optional[Trade]:
+        meta = signal.metadata
+        if signal.action == "ARB_LONG":
+            yes_trade, no_trade = await engine.place_arb_pair(
+                market_id=signal.market_id,
+                yes_token_id=meta["yes_token_id"],
+                no_token_id=meta["no_token_id"],
+                yes_price=meta["yes_ask"],
+                no_price=meta["no_ask"],
+                size=meta["size_shares"],
+            )
+            return yes_trade
+        return None
+
+
+# ══════════════════════════════════════════════════════════════════
+# STRATÉGIE 2: VALUE BET
+# ══════════════════════════════════════════════════════════════════
+class ValueBetStrategy(BaseStrategy):
+    """
+    Value Bet: identifier les marchés où le prix ne reflète pas la vraie probabilité.
+    Basé sur arxiv:2604.14199 (PolyBench) — meilleurs résultats avec news-catalyst.
+
+    Utilise des heuristiques + optionnellement un LLM pour estimer la vraie probabilité.
+    Sans LLM, utilise des indicateurs de marché (volume, momentum, convergence).
+    """
+
+    def __init__(self, config: BotConfig, clob_client: CLOBDataClient):
+        super().__init__(config, clob_client)
+        self._price_history: dict = {}  # token_id -> [prices]
+
+    def _update_price_history(self, token_id: str, price: float):
+        if token_id not in self._price_history:
+            self._price_history[token_id] = []
+        self._price_history[token_id].append((time.time(), price))
+        # Garder 1h d'historique max
+        cutoff = time.time() - 3600
+        self._price_history[token_id] = [
+            (t, p) for t, p in self._price_history[token_id] if t > cutoff
+        ]
+
+    def _calculate_momentum(self, token_id: str) -> Optional[float]:
+        """Calcule le momentum du prix (variation sur les N dernières minutes)."""
+        history = self._price_history.get(token_id, [])
+        if len(history) < 5:
+            return None
+
+        recent = [p for _, p in history[-5:]]
+        older = [p for _, p in history[:5]]
+        return sum(recent) / len(recent) - sum(older) / len(older)
+
+    def _calculate_volume_signal(self, market: Market) -> float:
+        """Signal basé sur le volume (marchés à fort volume = plus informatifs)."""
+        if market.volume > 100000:
+            return 0.8
+        elif market.volume > 50000:
+            return 0.6
+        elif market.volume > 10000:
+            return 0.4
+        return 0.2
+
+    def _estimate_edge(self, market: Market, book: OrderBook) -> tuple[float, str]:
+        """
+        Estime l'edge (avantage) sur le marché.
+        Retourne (edge, direction) où direction = "YES" ou "NO".
+
+        Heuristiques:
+        1. Bid-ask asymétrie: si le bid depth >> ask depth, pression acheteuse
+        2. Momentum: tendance récente du prix
+        3. Convergence vers 0 ou 1: les marchés proches de la résolution convergent
+        """
+        yes = market.yes_token
+        if not yes or not book:
+            return 0.0, ""
+
+        self._update_price_history(yes.token_id, yes.price)
+
+        # Asymétrie du carnet
+        bid_depth = book.total_bid_depth
+        ask_depth = book.total_ask_depth
+        if bid_depth + ask_depth > 0:
+            depth_imbalance = (bid_depth - ask_depth) / (bid_depth + ask_depth)
+        else:
+            depth_imbalance = 0.0
+
+        # Momentum
+        momentum = self._calculate_momentum(yes.token_id) or 0.0
+
+        # Score composite
+        score = 0.3 * depth_imbalance + 0.5 * momentum * 10 + 0.2 * self._calculate_volume_signal(market)
+
+        if score > self.config.value_bet_min_edge:
+            return abs(score), "YES"
+        elif score < -self.config.value_bet_min_edge:
+            return abs(score), "NO"
+        return 0.0, ""
+
+    async def scan(self, markets: list[Market]) -> list[Signal]:
+        signals = []
+
+        for market in markets:
+            yes = market.yes_token
+            no = market.no_token
+            if not yes or not no:
+                continue
+
+            # Ignorer les marchés presque résolus
+            if yes.price > 0.90 or yes.price < 0.10:
+                continue
+
+            try:
+                yes_book = await self.clob.get_order_book(yes.token_id)
+            except Exception:
+                continue
+
+            if not yes_book:
+                continue
+
+            edge, direction = self._estimate_edge(market, yes_book)
+
+            if edge > self.config.value_bet_min_edge:
+                # Kelly sizing
+                p_true = yes.price + edge if direction == "YES" else yes.price - edge
+                p_true = max(0.05, min(0.95, p_true))
+                p_market = yes.price if direction == "YES" else (1 - yes.price)
+
+                frac = kelly_fraction(p_true, p_market, self.config.kelly_fraction)
+                if frac > 0:
+                    size_usd = min(
+                        frac * self.config.max_total_exposure_usd,
+                        self.config.value_bet_max_position_usd,
+                    )
+
+                    token = yes if direction == "YES" else no
+                    price = yes_book.best_ask if direction == "YES" else (1 - yes.price)
+
+                    signals.append(Signal(
+                        market_id=market.market_id,
+                        strategy="value_bet",
+                        action=f"BUY_{direction}",
+                        confidence=min(edge * 5, 1.0),
+                        expected_profit=size_usd * edge,
+                        size_usd=size_usd,
+                        metadata={
+                            "token_id": token.token_id,
+                            "outcome": direction,
+                            "price": price,
+                            "edge": edge,
+                            "kelly_frac": frac,
+                            "p_true": p_true,
+                            "p_market": p_market,
+                            "question": market.question,
+                        }
+                    ))
+
+        if signals:
+            logger.info(f"💡 Value Bet scan: {len(signals)} signals found")
+        return signals
+
+    async def execute(self, signal: Signal, engine: ExecutionEngine) -> Optional[Trade]:
+        meta = signal.metadata
+        size_shares = signal.size_usd / meta["price"] if meta["price"] > 0 else 0
+        if size_shares <= 0:
+            return None
+
+        return await engine.place_order(
+            token_id=meta["token_id"],
+            market_id=signal.market_id,
+            outcome=meta["outcome"],
+            side="BUY",
+            price=meta["price"],
+            size=size_shares,
+            strategy="value_bet",
+            order_type="GTC",
+        )
+
+
+# ══════════════════════════════════════════════════════════════════
+# STRATÉGIE 3: LEADER-FOLLOWER SÉMANTIQUE
+# ══════════════════════════════════════════════════════════════════
+class LeaderFollowerStrategy(BaseStrategy):
+    """
+    Stratégie Leader-Follower basée sur la similarité sémantique des marchés.
+    Basé sur arxiv:2512.02436 — 47.5% ROI mensuel (Juin 2025).
+
+    Logique:
+    1. Embedder les questions des marchés
+    2. Identifier les clusters de marchés corrélés
+    3. Quand un "leader" bouge fortement, trader le "follower"
+    """
+
+    def __init__(self, config: BotConfig, clob_client: CLOBDataClient):
+        super().__init__(config, clob_client)
+        self._embeddings: dict = {}
+        self._clusters: dict = {}
+        self._model = None
+        self._price_snapshots: dict = {}  # market_id -> (timestamp, yes_price)
+
+    def _ensure_model(self):
+        """Charge le modèle d'embedding si nécessaire."""
+        if self._model is None:
+            try:
+                from sentence_transformers import SentenceTransformer
+                self._model = SentenceTransformer("all-MiniLM-L6-v2")
+                logger.info("Sentence transformer loaded for Leader-Follower")
+            except Exception as e:
+                logger.error(f"Failed to load sentence transformer: {e}")
+
+    def _compute_similarity(self, q1: str, q2: str) -> float:
+        """Calcule la similarité cosinus entre deux questions."""
+        self._ensure_model()
+        if not self._model:
+            return 0.0
+
+        import numpy as np
+        embs = self._model.encode([q1, q2])
+        cos_sim = np.dot(embs[0], embs[1]) / (np.linalg.norm(embs[0]) * np.linalg.norm(embs[1]))
+        return float(cos_sim)
+
+    def _find_correlated_pairs(self, markets: list[Market]) -> list[tuple[Market, Market, float]]:
+        """Trouve les paires de marchés sémantiquement corrélés."""
+        self._ensure_model()
+        if not self._model:
+            return []
+
+        import numpy as np
+
+        questions = [m.question for m in markets]
+        if len(questions) < 2:
+            return []
+
+        embeddings = self._model.encode(questions)
+
+        # Matrice de similarité
+        norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+        normalized = embeddings / (norms + 1e-8)
+        sim_matrix = normalized @ normalized.T
+
+        pairs = []
+        for i in range(len(markets)):
+            for j in range(i + 1, len(markets)):
+                sim = float(sim_matrix[i, j])
+                if sim > self.config.lf_similarity_threshold:
+                    pairs.append((markets[i], markets[j], sim))
+
+        pairs.sort(key=lambda x: x[2], reverse=True)
+        return pairs[:20]  # Top 20 paires
+
+    async def scan(self, markets: list[Market]) -> list[Signal]:
+        signals = []
+
+        # Trouver les paires corrélées
+        pairs = self._find_correlated_pairs(markets)
+
+        for leader, follower, similarity in pairs:
+            leader_yes = leader.yes_token
+            follower_yes = follower.yes_token
+            follower_no = follower.no_token
+
+            if not leader_yes or not follower_yes or not follower_no:
+                continue
+
+            # Vérifier si le leader a bougé significativement
+            prev = self._price_snapshots.get(leader.market_id)
+            current_price = leader_yes.price
+
+            if prev:
+                prev_time, prev_price = prev
+                price_change = current_price - prev_price
+                time_elapsed = time.time() - prev_time
+
+                # Signal si mouvement > 5% en moins de 10 min
+                if abs(price_change) > 0.05 and time_elapsed < 600:
+                    # Le follower devrait bouger dans la même direction
+                    direction = "YES" if price_change > 0 else "NO"
+                    target_token = follower_yes if direction == "YES" else follower_no
+                    target_price = follower_yes.price if direction == "YES" else (1 - follower_yes.price)
+
+                    # Ne trader que si le follower n'a PAS encore bougé
+                    follower_prev = self._price_snapshots.get(follower.market_id)
+                    if follower_prev:
+                        _, fp = follower_prev
+                        follower_change = abs(follower_yes.price - fp)
+                        if follower_change < abs(price_change) * 0.3:  # Follower en retard
+                            edge = abs(price_change) * similarity * 0.5
+                            size_usd = min(
+                                kelly_fraction(target_price + edge, target_price, self.config.kelly_fraction)
+                                * self.config.max_total_exposure_usd,
+                                self.config.lf_max_position_usd,
+                            )
+
+                            if size_usd > self.config.arb_min_position_usd:
+                                signals.append(Signal(
+                                    market_id=follower.market_id,
+                                    strategy="leader_follower",
+                                    action=f"BUY_{direction}",
+                                    confidence=similarity * min(abs(price_change) * 10, 1.0),
+                                    expected_profit=size_usd * edge,
+                                    size_usd=size_usd,
+                                    metadata={
+                                        "token_id": target_token.token_id,
+                                        "outcome": direction,
+                                        "price": target_price,
+                                        "leader_question": leader.question,
+                                        "follower_question": follower.question,
+                                        "similarity": similarity,
+                                        "leader_move": price_change,
+                                        "edge": edge,
+                                    }
+                                ))
+
+            # Update snapshot
+            self._price_snapshots[leader.market_id] = (time.time(), current_price)
+            if follower_yes:
+                self._price_snapshots[follower.market_id] = (time.time(), follower_yes.price)
+
+        if signals:
+            logger.info(f"🔗 Leader-Follower scan: {len(signals)} signals found")
+        return signals
+
+    async def execute(self, signal: Signal, engine: ExecutionEngine) -> Optional[Trade]:
+        meta = signal.metadata
+        size_shares = signal.size_usd / meta["price"] if meta["price"] > 0 else 0
+        if size_shares <= 0:
+            return None
+
+        return await engine.place_order(
+            token_id=meta["token_id"],
+            market_id=signal.market_id,
+            outcome=meta["outcome"],
+            side="BUY",
+            price=meta["price"],
+            size=size_shares,
+            strategy="leader_follower",
+            order_type="GTC",
+        )