polynode 0.5.5__py3-none-any.whl

polynode/redemption_watcher.py

@@ -0,0 +1,339 @@
+"""Redemption watcher — tracks wallet positions and alerts on market resolution."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from .client import PolyNode
+from .ws import PolyNodeWS
+
+
+@dataclass
+class RedeemableAlert:
+    wallet: str
+    condition_id: str
+    token_id: str
+    outcome: str
+    winning_outcome: str
+    is_winner: bool
+    size: float
+    estimated_payout_usd: float
+    market_title: str
+    market_slug: str
+    market_image: str | None
+    resolved_price: float
+    payouts: list[float]
+    block_number: int
+    timestamp: float
+
+
+@dataclass
+class TrackedPosition:
+    wallet: str
+    token_id: str
+    condition_id: str
+    outcome: str
+    size: float
+    market_title: str
+    market_slug: str
+    market_image: str | None = None
+    outcomes: list[str] = field(default_factory=list)
+    token_ids: list[str] = field(default_factory=list)
+    neg_risk: bool | None = None
+
+
+class RedemptionWatcher:
+    """Tracks wallet positions and emits alerts when markets resolve."""
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str | None = None,
+        ws_url: str | None = None,
+        compress: bool = True,
+        auto_reconnect: bool = True,
+        track_position_changes: bool = True,
+        refresh_interval: float = 300.0,
+    ) -> None:
+        self._client = PolyNode(api_key, base_url=base_url or "https://api.polynode.dev")
+        from .types.ws import WsOptions
+        self._ws = PolyNodeWS(
+            api_key,
+            ws_url or "wss://ws.polynode.dev/ws",
+            WsOptions(compress=compress, auto_reconnect=auto_reconnect),
+        )
+        self._track_position_changes = track_position_changes
+        self._refresh_interval = refresh_interval
+
+        self._by_condition: dict[str, list[TrackedPosition]] = {}
+        self._by_wallet: dict[str, set[str]] = {}
+
+        self._oracle_sub = None
+        self._wallet_sub = None
+        self._refresh_task: asyncio.Task | None = None
+        self._closed = False
+
+        self._handlers: dict[str, list[Callable]] = {"alert": [], "ready": [], "error": []}
+        self._alert_queue: asyncio.Queue[RedeemableAlert | None] = asyncio.Queue()
+
+    async def start(self, wallets: list[str]) -> None:
+        if self._closed:
+            raise RuntimeError("RedemptionWatcher is closed")
+
+        await self._fetch_and_load(wallets)
+
+        self._oracle_sub = await self._ws.subscribe("oracle").send()
+        self._oracle_sub.on("oracle", self._handle_oracle_event)
+
+        if self._track_position_changes and wallets:
+            self._wallet_sub = await self._ws.subscribe("wallets").wallets(wallets).send()
+            self._wallet_sub.on("position_change", self._handle_position_change)
+
+        if self._refresh_interval > 0:
+            self._refresh_task = asyncio.ensure_future(self._refresh_loop())
+
+        for h in self._handlers["ready"]:
+            h()
+
+    async def add_wallets(self, wallets: list[str]) -> None:
+        if self._closed:
+            raise RuntimeError("RedemptionWatcher is closed")
+        await self._fetch_and_load(wallets)
+        if self._track_position_changes:
+            await self._resubscribe_wallets()
+
+    def remove_wallets(self, wallets: list[str]) -> None:
+        for wallet in wallets:
+            conditions = self._by_wallet.pop(wallet, set())
+            for cond_id in conditions:
+                positions = self._by_condition.get(cond_id, [])
+                filtered = [p for p in positions if p.wallet.lower() != wallet.lower()]
+                if filtered:
+                    self._by_condition[cond_id] = filtered
+                else:
+                    self._by_condition.pop(cond_id, None)
+        if self._track_position_changes and not self._closed:
+            asyncio.ensure_future(self._resubscribe_wallets())
+
+    def on(self, event: str, handler: Callable) -> RedemptionWatcher:
+        if event in self._handlers:
+            self._handlers[event].append(handler)
+        return self
+
+    def off(self, event: str, handler: Callable) -> RedemptionWatcher:
+        if event in self._handlers:
+            try:
+                self._handlers[event].remove(handler)
+            except ValueError:
+                pass
+        return self
+
+    @property
+    def wallets(self) -> list[str]:
+        return list(self._by_wallet.keys())
+
+    @property
+    def conditions(self) -> list[str]:
+        return list(self._by_condition.keys())
+
+    def positions_for(self, wallet: str) -> list[TrackedPosition]:
+        conditions = self._by_wallet.get(wallet, set())
+        result = []
+        for cond_id in conditions:
+            for p in self._by_condition.get(cond_id, []):
+                if p.wallet.lower() == wallet.lower():
+                    result.append(p)
+        return result
+
+    @property
+    def size(self) -> int:
+        return sum(len(ps) for ps in self._by_condition.values())
+
+    def close(self) -> None:
+        self._closed = True
+        if self._refresh_task and not self._refresh_task.done():
+            self._refresh_task.cancel()
+        if self._oracle_sub:
+            self._oracle_sub.unsubscribe()
+        if self._wallet_sub:
+            self._wallet_sub.unsubscribe()
+        self._ws.disconnect()
+        self._client.close()
+        self._alert_queue.put_nowait(None)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self) -> RedeemableAlert:
+        if self._closed:
+            raise StopAsyncIteration
+        alert = await self._alert_queue.get()
+        if alert is None:
+            raise StopAsyncIteration
+        return alert
+
+    # ── Private ──
+
+    async def _fetch_and_load(self, wallets: list[str]) -> None:
+        for wallet in wallets:
+            try:
+                data = self._client.wallet_positions(wallet)
+                self._load_positions(wallet, data.get("positions", []))
+            except Exception as e:
+                for h in self._handlers["error"]:
+                    h(e)
+
+    def _load_positions(self, wallet: str, positions: list[dict]) -> None:
+        wallet_conditions = self._by_wallet.get(wallet, set())
+
+        for pos in positions:
+            condition_id = pos.get("conditionId") or pos.get("condition_id")
+            token_id = pos.get("asset") or pos.get("token_id")
+            size = pos.get("size", 0)
+            if not condition_id or not token_id or size <= 0:
+                continue
+
+            tracked = TrackedPosition(
+                wallet=wallet,
+                token_id=token_id,
+                condition_id=condition_id,
+                outcome=pos.get("outcome", ""),
+                size=size,
+                market_title=pos.get("market_title") or pos.get("title", ""),
+                market_slug=pos.get("market_slug") or pos.get("slug", ""),
+                market_image=pos.get("market_image") or pos.get("icon") or pos.get("image"),
+                outcomes=pos.get("outcomes", []),
+                token_ids=pos.get("token_ids", []),
+                neg_risk=pos.get("neg_risk") or pos.get("negativeRisk"),
+            )
+
+            existing = self._by_condition.get(condition_id, [])
+            dup_idx = next(
+                (i for i, p in enumerate(existing) if p.wallet.lower() == wallet.lower() and p.token_id == token_id),
+                None,
+            )
+            if dup_idx is not None:
+                existing[dup_idx] = tracked
+            else:
+                existing.append(tracked)
+            self._by_condition[condition_id] = existing
+            wallet_conditions.add(condition_id)
+
+        self._by_wallet[wallet] = wallet_conditions
+
+    def _handle_oracle_event(self, event: Any) -> None:
+        if event.oracle_type != "condition_resolution":
+            return
+        condition_id = event.condition_id
+        if not condition_id:
+            return
+
+        positions = self._by_condition.get(condition_id, [])
+        if not positions:
+            return
+
+        for pos in positions:
+            token_ids = event.token_ids or []
+            token_index = token_ids.index(pos.token_id) if pos.token_id in token_ids else -1
+            is_winner = token_index >= 0 and (event.payouts or [])[token_index] > 0 if event.payouts and token_index >= 0 else False
+
+            alert = RedeemableAlert(
+                wallet=pos.wallet,
+                condition_id=pos.condition_id,
+                token_id=pos.token_id,
+                outcome=pos.outcome,
+                winning_outcome=event.resolved_outcome or "Unknown",
+                is_winner=is_winner,
+                size=pos.size,
+                estimated_payout_usd=pos.size if is_winner else 0,
+                market_title=pos.market_title,
+                market_slug=pos.market_slug,
+                market_image=pos.market_image,
+                resolved_price=event.resolved_price or 0,
+                payouts=event.payouts or [],
+                block_number=event.block_number,
+                timestamp=event.timestamp,
+            )
+
+            for h in self._handlers["alert"]:
+                h(alert)
+            self._alert_queue.put_nowait(alert)
+
+        # Evict resolved condition
+        self._by_condition.pop(condition_id, None)
+        for wc in self._by_wallet.values():
+            wc.discard(condition_id)
+
+    def _handle_position_change(self, event: Any) -> None:
+        matched = False
+        affected_condition_id = None
+
+        for cond_id, positions in self._by_condition.items():
+            for pos in positions:
+                if pos.token_id != event.token_id:
+                    continue
+                matched = True
+                affected_condition_id = cond_id
+                if event.to.lower() == pos.wallet.lower():
+                    pos.size += event.amount
+                if event.from_address.lower() == pos.wallet.lower():
+                    pos.size -= event.amount
+                    if pos.size < 0:
+                        pos.size = 0
+
+        if affected_condition_id:
+            positions = self._by_condition.get(affected_condition_id, [])
+            remaining = [p for p in positions if p.size > 0]
+            if not remaining:
+                self._by_condition.pop(affected_condition_id, None)
+                for wc in self._by_wallet.values():
+                    wc.discard(affected_condition_id)
+            elif len(remaining) < len(positions):
+                self._by_condition[affected_condition_id] = remaining
+
+        if not matched and hasattr(event, "condition_id") and event.condition_id:
+            to_wallet = event.to.lower()
+            if to_wallet in self._by_wallet:
+                tracked = TrackedPosition(
+                    wallet=to_wallet,
+                    token_id=event.token_id,
+                    condition_id=event.condition_id,
+                    outcome=getattr(event, "outcome", "") or "",
+                    size=event.amount,
+                    market_title=getattr(event, "market_title", "") or "",
+                    market_slug=getattr(event, "market_slug", "") or "",
+                    market_image=getattr(event, "market_image", None),
+                    outcomes=getattr(event, "outcomes", []) or [],
+                    token_ids=getattr(event, "token_ids", []) or [],
+                    neg_risk=getattr(event, "neg_risk", None),
+                )
+                existing = self._by_condition.get(event.condition_id, [])
+                existing.append(tracked)
+                self._by_condition[event.condition_id] = existing
+                self._by_wallet[to_wallet].add(event.condition_id)
+
+    async def _resubscribe_wallets(self) -> None:
+        if self._wallet_sub:
+            self._wallet_sub.unsubscribe()
+            self._wallet_sub = None
+        all_wallets = list(self._by_wallet.keys())
+        if not all_wallets:
+            return
+        self._wallet_sub = await self._ws.subscribe("wallets").wallets(all_wallets).send()
+        self._wallet_sub.on("position_change", self._handle_position_change)
+
+    async def _refresh_loop(self) -> None:
+        while not self._closed:
+            await asyncio.sleep(self._refresh_interval)
+            if self._closed:
+                break
+            all_wallets = list(self._by_wallet.keys())
+            if all_wallets:
+                try:
+                    await self._fetch_and_load(all_wallets)
+                except Exception as e:
+                    for h in self._handlers["error"]:
+                        h(e)

polynode/short_form.py

@@ -0,0 +1,321 @@
+"""Auto-rotating stream for Polymarket short-form crypto markets."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+from datetime import datetime
+from typing import Any, Callable
+from zoneinfo import ZoneInfo
+
+import httpx
+
+from .types.events import PolyNodeEvent
+from .types.short_form import (
+    RotationEvent,
+    ShortFormCoin,
+    ShortFormInterval,
+    ShortFormMarket,
+)
+
+ALL_COINS: list[ShortFormCoin] = ["btc", "eth", "sol", "xrp", "doge", "hype", "bnb"]
+
+COIN_FULL_NAMES: dict[ShortFormCoin, str] = {
+    "btc": "bitcoin",
+    "eth": "ethereum",
+    "sol": "solana",
+    "xrp": "xrp",
+    "doge": "dogecoin",
+    "hype": "hype",
+    "bnb": "bnb",
+}
+
+COIN_SYMBOLS: dict[ShortFormCoin, str] = {
+    "btc": "BTC", "eth": "ETH", "sol": "SOL", "xrp": "XRP",
+    "doge": "DOGE", "hype": "HYPE", "bnb": "BNB",
+}
+
+INTERVAL_VARIANT: dict[ShortFormInterval, str] = {
+    "5m": "five", "15m": "fifteen", "1h": "sixty",
+}
+
+WINDOW_SECONDS: dict[ShortFormInterval, int] = {
+    "5m": 300, "15m": 900, "1h": 3600,
+}
+
+DEFAULT_API_BASE = "https://api.polynode.dev"
+DEFAULT_ROTATION_BUFFER = 3
+DISCOVERY_RETRIES = 3
+DISCOVERY_RETRY_DELAY = 2.0
+
+
+class ShortFormStream:
+    """Auto-rotating stream for Polymarket short-form crypto markets."""
+
+    def __init__(
+        self,
+        ws: Any,
+        interval: ShortFormInterval,
+        *,
+        coins: list[ShortFormCoin] | None = None,
+        api_base_url: str | None = None,
+        rotation_buffer: int = DEFAULT_ROTATION_BUFFER,
+    ) -> None:
+        self._ws = ws
+        self.interval = interval
+        self.coins: list[ShortFormCoin] = coins or list(ALL_COINS)
+        self._api_base = (api_base_url or DEFAULT_API_BASE).rstrip("/")
+        self._rotation_buffer = rotation_buffer
+        self._handlers: dict[str, set[Callable]] = {}
+        self._sub = None
+        self._markets: list[ShortFormMarket] = []
+        self._rotation_task: asyncio.Task | None = None
+        self._rotating = False
+        self._stopped = False
+
+    def on(self, type: str, handler: Callable) -> ShortFormStream:
+        if type not in self._handlers:
+            self._handlers[type] = set()
+        self._handlers[type].add(handler)
+        return self
+
+    def off(self, type: str, handler: Callable) -> ShortFormStream:
+        if type in self._handlers:
+            self._handlers[type].discard(handler)
+        return self
+
+    @property
+    def markets(self) -> list[ShortFormMarket]:
+        return self._markets
+
+    @property
+    def time_remaining(self) -> int:
+        if not self._markets:
+            return 0
+        window_end = max(m.window_end for m in self._markets)
+        return max(0, window_end - int(time.time()))
+
+    async def start(self) -> None:
+        if self._stopped:
+            return
+        self._ws.on_reconnect(lambda _: asyncio.ensure_future(self._rotate()) if not self._stopped else None)
+        await self._rotate()
+
+    def stop(self) -> None:
+        self._stopped = True
+        if self._rotation_task and not self._rotation_task.done():
+            self._rotation_task.cancel()
+        if self._sub:
+            self._sub.unsubscribe()
+            self._sub = None
+
+    async def _rotate(self) -> None:
+        if self._stopped or self._rotating:
+            return
+        self._rotating = True
+
+        try:
+            if self._sub:
+                self._sub.unsubscribe()
+                self._sub = None
+
+            markets = await self._discover_markets()
+            if self._stopped:
+                return
+
+            self._markets = markets
+
+            if not markets:
+                self._emit("error", Exception(f"No markets found for {self.interval}"))
+                self._schedule_rotation()
+                return
+
+            slugs = [m.slug for m in markets]
+            sub = await self._ws.subscribe("settlements").slugs(slugs).status("all").send()
+
+            if self._stopped:
+                sub.unsubscribe()
+                return
+
+            self._sub = sub
+            sub.on("*", lambda event: (self._emit(event.event_type, event), self._emit("*", event)))
+
+            window_end = max(m.window_end for m in markets)
+            window_start = min(m.window_start for m in markets)
+            self._emit("rotation", RotationEvent(
+                interval=self.interval,
+                markets=markets,
+                window_start=window_start,
+                window_end=window_end,
+                time_remaining=max(0, window_end - int(time.time())),
+            ))
+
+            self._schedule_rotation(window_end)
+        except Exception as e:
+            self._emit("error", e)
+            if not self._stopped:
+                self._rotation_task = asyncio.ensure_future(self._delayed_rotate(self._rotation_buffer))
+        finally:
+            self._rotating = False
+
+    async def _delayed_rotate(self, delay: float) -> None:
+        await asyncio.sleep(delay)
+        await self._rotate()
+
+    def _schedule_rotation(self, window_end: int | None = None) -> None:
+        if self._rotation_task and not self._rotation_task.done():
+            self._rotation_task.cancel()
+        end = window_end or self._compute_window_end()
+        delay = max((end - int(time.time()) + self._rotation_buffer), 1)
+        self._rotation_task = asyncio.ensure_future(self._delayed_rotate(delay))
+
+    def _compute_window_end(self) -> int:
+        now = int(time.time())
+        w = WINDOW_SECONDS[self.interval]
+        return (now // w) * w + w
+
+    async def _discover_markets(self) -> list[ShortFormMarket]:
+        results: list[ShortFormMarket] = []
+        async with httpx.AsyncClient(timeout=5.0) as http:
+            tasks = [self._discover_coin(http, coin) for coin in self.coins]
+            for coro in asyncio.as_completed(tasks):
+                market = await coro
+                if market:
+                    results.append(market)
+            # Fetch price-to-beat in parallel
+            ptb_tasks = [self._fetch_price_to_beat(http, m) for m in results]
+            prices = await asyncio.gather(*ptb_tasks, return_exceptions=True)
+            for m, p in zip(results, prices):
+                if isinstance(p, (int, float)):
+                    m.price_to_beat = p
+        return results
+
+    async def _discover_coin(self, http: httpx.AsyncClient, coin: ShortFormCoin) -> ShortFormMarket | None:
+        for attempt in range(DISCOVERY_RETRIES):
+            try:
+                url = self._build_discovery_url(coin)
+                resp = await http.get(url)
+                if not resp.is_success:
+                    if attempt < DISCOVERY_RETRIES - 1:
+                        await asyncio.sleep(DISCOVERY_RETRY_DELAY)
+                        continue
+                    return None
+                data = resp.json()
+                if not data:
+                    if attempt < DISCOVERY_RETRIES - 1:
+                        await asyncio.sleep(DISCOVERY_RETRY_DELAY)
+                        continue
+                    return None
+                return self._parse_gamma_event(coin, data[0])
+            except Exception:
+                if attempt < DISCOVERY_RETRIES - 1:
+                    await asyncio.sleep(DISCOVERY_RETRY_DELAY)
+        return None
+
+    def _build_discovery_url(self, coin: ShortFormCoin) -> str:
+        if self.interval == "1h":
+            slug = _build_hourly_slug(coin)
+            return f"{self._api_base}/proxy/gamma/events?slug={slug}"
+        w = WINDOW_SECONDS[self.interval]
+        now = int(time.time())
+        ts = (now // w) * w
+        slug = f"{coin}-updown-{self.interval}-{ts}"
+        return f"{self._api_base}/proxy/gamma/events?slug={slug}"
+
+    async def _fetch_price_to_beat(self, http: httpx.AsyncClient, market: ShortFormMarket) -> float | None:
+        try:
+            symbol = COIN_SYMBOLS[market.coin]
+            variant = INTERVAL_VARIANT[self.interval]
+            start_time = datetime.fromtimestamp(market.window_start).isoformat() + "Z"
+            end_date = datetime.fromtimestamp(market.window_end).isoformat() + "Z"
+            url = (
+                f"{self._api_base}/proxy/polymarket/api/crypto/crypto-price"
+                f"?symbol={symbol}&eventStartTime={start_time}&variant={variant}&endDate={end_date}"
+            )
+            resp = await http.get(url)
+            if not resp.is_success:
+                return None
+            data = resp.json()
+            return data.get("openPrice")
+        except Exception:
+            return None
+
+    def _parse_gamma_event(self, coin: ShortFormCoin, event: dict) -> ShortFormMarket | None:
+        market = (event.get("markets") or [{}])[0] if event.get("markets") else None
+        if not market:
+            return None
+
+        outcomes = _safe_json_parse(market.get("outcomes"), [])
+        raw_prices = [float(p) for p in _safe_json_parse(market.get("outcomePrices"), [])]
+        clob_token_ids = _safe_json_parse(market.get("clobTokenIds"), [])
+
+        up_odds = 0.5
+        down_odds = 0.5
+        for i, label in enumerate(outcomes):
+            price = raw_prices[i] if i < len(raw_prices) else 0
+            if "up" in label.lower():
+                up_odds = price
+            if "down" in label.lower():
+                down_odds = price
+
+        slug = event.get("slug", "")
+        if self.interval == "1h":
+            now = int(time.time())
+            window_start = (now // 3600) * 3600
+            window_end = window_start + 3600
+            if event.get("endDate"):
+                window_end = int(datetime.fromisoformat(event["endDate"].replace("Z", "+00:00")).timestamp())
+                window_start = window_end - 3600
+        else:
+            w = WINDOW_SECONDS[self.interval]
+            parts = slug.split("-")
+            slug_ts = int(parts[-1]) if parts and parts[-1].isdigit() else 0
+            window_start = slug_ts or (int(time.time()) // w) * w
+            window_end = window_start + w
+
+        return ShortFormMarket(
+            coin=coin,
+            slug=slug,
+            title=event.get("title", ""),
+            condition_id=market.get("conditionId", ""),
+            window_start=window_start,
+            window_end=window_end,
+            outcomes=outcomes,
+            outcome_prices=raw_prices,
+            clob_token_ids=clob_token_ids,
+            up_odds=up_odds,
+            down_odds=down_odds,
+            liquidity=float(market.get("liquidity", 0)),
+            volume_24h=float(market.get("volume24hr") or market.get("volume") or 0),
+            price_to_beat=None,
+        )
+
+    def _emit(self, type: str, data: Any) -> None:
+        handlers = self._handlers.get(type)
+        if handlers:
+            for h in handlers:
+                h(data)
+
+
+def _build_hourly_slug(coin: ShortFormCoin) -> str:
+    et = ZoneInfo("America/New_York")
+    now = datetime.now(et)
+    month = now.strftime("%B").lower()
+    day = str(now.day)
+    year = str(now.year)
+    hour = now.strftime("%I").lstrip("0") or "12"
+    ampm = now.strftime("%p").lower()
+    coin_name = COIN_FULL_NAMES[coin]
+    return f"{coin_name}-up-or-down-{month}-{day}-{year}-{hour}{ampm}-et"
+
+
+def _safe_json_parse(value: Any, fallback: Any) -> Any:
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except Exception:
+            return fallback
+    if isinstance(value, list):
+        return value
+    return fallback