scan_markets.py

#!/usr/bin/env python3
"""
📊 Polymarket Bot — Backtester / Scanner de marchés.
Test rapide des stratégies sur les marchés actuels sans placer d'ordres.
"""
import asyncio
import json
import logging
import time
from datetime import datetime

from polymarket_bot import (
    BotConfig, GammaClient, CLOBDataClient,
    ArbitrageStrategy, ValueBetStrategy, LeaderFollowerStrategy,
)

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(name)-20s | %(levelname)-5s | %(message)s",
    datefmt="%H:%M:%S",
)
logger = logging.getLogger("scanner")


async def scan_markets():
    """Scanne les marchés actuels pour les opportunités."""
    print("""
╔══════════════════════════════════════════════════════════════╗
║        🔍 POLYMARKET MARKET SCANNER — SINGLE PASS 🔍        ║
╚══════════════════════════════════════════════════════════════╝
""")

    config = BotConfig(dry_run=True)
    gamma = GammaClient()
    clob = CLOBDataClient()

    # 1. Charger les marchés
    logger.info("Loading markets from Gamma API...")
    markets = await gamma.get_all_active_markets()
    logger.info(f"Loaded {len(markets)} active markets")

    # Filtrer
    filtered = [
        m for m in markets
        if m.volume >= config.min_market_volume
        and not m.closed
        and m.active
        and m.yes_token
        and m.no_token
        and not any(tag in config.excluded_tags for tag in m.tags)
    ]
    logger.info(f"After filtering: {len(filtered)} markets")

    # 2. Afficher les top marchés
    print("\n📈 TOP 10 MARCHÉS PAR VOLUME:")
    print("-" * 80)
    sorted_markets = sorted(filtered, key=lambda m: m.volume, reverse=True)[:10]
    for i, m in enumerate(sorted_markets, 1):
        yes = m.yes_token
        no = m.no_token
        spread = 1.0 - (yes.price + no.price) if yes and no else 0
        print(
            f"  {i:2d}. {m.question[:60]:<60s}\n"
            f"      Volume: ${m.volume:>12,.0f} | YES: {yes.price:.2f} | NO: {no.price:.2f} | "
            f"Spread: {spread:+.4f}"
        )

    # 3. Scanner les stratégies
    print("\n\n🔍 SCANNING STRATEGIES...")
    print("=" * 80)

    # Arbitrage
    print("\n📊 STRATÉGIE 1: ARBITRAGE")
    print("-" * 40)
    arb = ArbitrageStrategy(config, clob)
    arb_signals = await arb.scan(filtered[:50])

    if arb_signals:
        for s in arb_signals[:10]:
            meta = s.metadata
            print(
                f"  💰 {s.action} | Spread: {meta.get('spread', 0):.4f} | "
                f"Size: ${s.size_usd:.2f} | Expected: ${s.expected_profit:.2f}\n"
                f"     {meta.get('question', '')[:70]}"
            )
    else:
        print("  Aucune opportunité d'arbitrage détectée (normal — marchés efficaces)")

    # Value Bet
    print("\n\n💡 STRATÉGIE 2: VALUE BET")
    print("-" * 40)
    vb = ValueBetStrategy(config, clob)
    vb_signals = await vb.scan(filtered[:30])

    if vb_signals:
        for s in vb_signals[:10]:
            meta = s.metadata
            print(
                f"  📈 {s.action} | Edge: {meta.get('edge', 0):.4f} | "
                f"Kelly: {meta.get('kelly_frac', 0):.4f} | "
                f"Size: ${s.size_usd:.2f}\n"
                f"     {meta.get('question', '')[:70]}"
            )
    else:
        print("  Pas assez d'historique pour détecter des signaux (nécessite plusieurs cycles)")

    # Leader-Follower
    print("\n\n🔗 STRATÉGIE 3: LEADER-FOLLOWER")
    print("-" * 40)
    lf = LeaderFollowerStrategy(config, clob)
    lf_pairs = lf._find_correlated_pairs(filtered[:30])
    if lf_pairs:
        print(f"  {len(lf_pairs)} paires corrélées détectées:")
        for leader, follower, sim in lf_pairs[:5]:
            print(
                f"  🔗 Similarité: {sim:.4f}\n"
                f"     Leader:   {leader.question[:60]}\n"
                f"     Follower: {follower.question[:60]}"
            )
    else:
        print("  Aucune paire fortement corrélée trouvée")

    # Résumé
    total_signals = len(arb_signals) + len(vb_signals)
    total_expected = sum(s.expected_profit for s in arb_signals + vb_signals)

    print(f"""
╔══════════════════════════════════════════════════════════════╗
║                    📊 SCAN SUMMARY                          ║
╠══════════════════════════════════════════════════════════════╣
║ Markets scanned:    {len(filtered):>6d}
║ Arb signals:        {len(arb_signals):>6d}
║ Value bet signals:  {len(vb_signals):>6d}
║ Correlated pairs:   {len(lf_pairs):>6d}
║ Total expected:     ${total_expected:>10,.2f}
║ Time:               {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
╚══════════════════════════════════════════════════════════════╝""")

    # Export
    scan_results = {
        "timestamp": datetime.now().isoformat(),
        "markets_scanned": len(filtered),
        "arb_signals": len(arb_signals),
        "vb_signals": len(vb_signals),
        "lf_pairs": len(lf_pairs),
        "arb_details": [
            {
                "market": s.metadata.get("question", ""),
                "spread": s.metadata.get("spread", 0),
                "expected_profit": s.expected_profit,
                "size_usd": s.size_usd,
            }
            for s in arb_signals
        ],
    }
    with open("scan_results.json", "w") as f:
        json.dump(scan_results, f, indent=2)
    logger.info("Results saved to scan_results.json")

    await gamma.close()
    await clob.close()


if __name__ == "__main__":
    asyncio.run(scan_markets())