polynode 0.5.5__py3-none-any.whl

polynode/subscription.py

@@ -0,0 +1,137 @@
+"""Subscription builder and async iterator for PolyNode WebSocket events."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any, Callable
+
+from .types.enums import EventType, SubscriptionType
+from .types.events import PolyNodeEvent
+from .types.ws import SubscriptionFilters
+
+if TYPE_CHECKING:
+    from .ws import PolyNodeWS
+
+
+class SubscriptionBuilder:
+    """Fluent builder for WebSocket subscriptions."""
+
+    def __init__(self, ws: PolyNodeWS, type: SubscriptionType) -> None:
+        self._ws = ws
+        self._type = type
+        self._filters = SubscriptionFilters()
+
+    def wallets(self, addresses: list[str]) -> SubscriptionBuilder:
+        self._filters.wallets = addresses
+        return self
+
+    def tokens(self, token_ids: list[str]) -> SubscriptionBuilder:
+        self._filters.tokens = token_ids
+        return self
+
+    def slugs(self, slugs: list[str]) -> SubscriptionBuilder:
+        self._filters.slugs = slugs
+        return self
+
+    def condition_ids(self, ids: list[str]) -> SubscriptionBuilder:
+        self._filters.condition_ids = ids
+        return self
+
+    def side(self, side: str) -> SubscriptionBuilder:
+        self._filters.side = side
+        return self
+
+    def status(self, status: str) -> SubscriptionBuilder:
+        self._filters.status = status
+        return self
+
+    def min_size(self, usd: float) -> SubscriptionBuilder:
+        self._filters.min_size = usd
+        return self
+
+    def max_size(self, usd: float) -> SubscriptionBuilder:
+        self._filters.max_size = usd
+        return self
+
+    def event_types(self, types: list[EventType]) -> SubscriptionBuilder:
+        self._filters.event_types = types
+        return self
+
+    def snapshot_count(self, count: int) -> SubscriptionBuilder:
+        self._filters.snapshot_count = count
+        return self
+
+    def feeds(self, feed_names: list[str]) -> SubscriptionBuilder:
+        self._filters.feeds = feed_names
+        return self
+
+    async def send(self) -> Subscription:
+        return await self._ws._subscribe(self._type, self._filters)
+
+
+class Subscription:
+    """An active WebSocket subscription with event handling and async iteration."""
+
+    def __init__(self, ws: PolyNodeWS, type: SubscriptionType, filters: SubscriptionFilters) -> None:
+        self._ws = ws
+        self.type = type
+        self.filters = filters
+        self._id: str | None = None
+        self._handlers: dict[str, set[Callable]] = {}
+        self._queue: asyncio.Queue[PolyNodeEvent | None] = asyncio.Queue()
+        self._closed = False
+
+    @property
+    def id(self) -> str | None:
+        return self._id
+
+    def _set_id(self, id: str) -> None:
+        self._id = id
+
+    def on(self, type: str, handler: Callable) -> Subscription:
+        if type not in self._handlers:
+            self._handlers[type] = set()
+        self._handlers[type].add(handler)
+        return self
+
+    def off(self, type: str, handler: Callable) -> Subscription:
+        if type in self._handlers:
+            self._handlers[type].discard(handler)
+        return self
+
+    def _emit(self, event: PolyNodeEvent) -> None:
+        # Typed handlers
+        event_type = event.event_type  # type: ignore[union-attr]
+        handlers = self._handlers.get(event_type)
+        if handlers:
+            for h in handlers:
+                h(event)
+        # Catch-all
+        star = self._handlers.get("*")
+        if star:
+            for h in star:
+                h(event)
+        # Async iterator queue
+        self._queue.put_nowait(event)
+
+    def unsubscribe(self) -> None:
+        self._closed = True
+        self._queue.put_nowait(None)
+        self._ws._unsubscribe(self._id)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self) -> PolyNodeEvent:
+        if self._closed:
+            raise StopAsyncIteration
+        event = await self._queue.get()
+        if event is None:
+            raise StopAsyncIteration
+        return event
+
+    async def __aenter__(self) -> Subscription:
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        self.unsubscribe()

polynode/testing.py

@@ -0,0 +1,83 @@
+"""Testing utilities for SDK examples and tests."""
+
+from __future__ import annotations
+
+import re
+
+import httpx
+
+FALLBACK_WALLETS = [
+    "0xc2e7800b5af46e6093872b177b7a5e7f0563be51",
+    "0x02227b8f5a9636e895607edd3185ed6ee5598ff7",
+    "0xefbc5fec8d7b0acdc8911bdd9a98d6964308f9a2",
+    "0x2a2c53bd278c04da9962fcf96490e17f3dfb9bc1",
+    "0x37c1874a60d348903594a96703e0507c518fc53a",
+]
+
+
+async def get_active_test_wallet(*, fresh: bool = False) -> str:
+    if not fresh:
+        return FALLBACK_WALLETS[0]
+    try:
+        traders = await _fetch_top_traders(1)
+        return traders[0]["wallet"] if traders else FALLBACK_WALLETS[0]
+    except Exception:
+        return FALLBACK_WALLETS[0]
+
+
+async def get_active_test_wallets(count: int = 5, *, fresh: bool = False) -> list[str]:
+    if not fresh:
+        return FALLBACK_WALLETS[:count]
+    try:
+        traders = await _fetch_top_traders(count)
+        if traders:
+            return [t["wallet"] for t in traders]
+        return FALLBACK_WALLETS[:count]
+    except Exception:
+        return FALLBACK_WALLETS[:count]
+
+
+async def _fetch_top_traders(count: int) -> list[dict]:
+    build_id = await _discover_build_id()
+    if not build_id:
+        return []
+
+    url = f"https://polymarket.com/_next/data/{build_id}/en/leaderboard/overall/monthly/profit.json?segment=overall&period=monthly&sort=profit"
+
+    async with httpx.AsyncClient(timeout=10.0) as http:
+        resp = await http.get(url, headers={"User-Agent": "polynode-sdk/testing"})
+        if not resp.is_success:
+            return []
+        data = resp.json()
+
+    queries = data.get("pageProps", {}).get("dehydratedState", {}).get("queries", [])
+    for q in queries:
+        key = q.get("queryKey", [])
+        if isinstance(key, list) and "profit" in key and "/leaderboard" in str(key):
+            records = q.get("state", {}).get("data", [])
+            if isinstance(records, list):
+                return [
+                    {
+                        "wallet": r.get("proxyWallet", ""),
+                        "name": r.get("pseudonym") or r.get("name", ""),
+                        "pnl": r.get("pnl") or r.get("amount", 0),
+                        "volume": r.get("volume", 0),
+                    }
+                    for r in records[:count]
+                ]
+    return []
+
+
+async def _discover_build_id() -> str | None:
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as http:
+            resp = await http.get(
+                "https://polymarket.com/",
+                headers={"User-Agent": "polynode-sdk/testing"},
+            )
+            if not resp.is_success:
+                return None
+            match = re.search(r"/_next/data/([^/]+)/", resp.text)
+            return match.group(1) if match else None
+    except Exception:
+        return None

polynode/trading/__init__.py

@@ -0,0 +1,19 @@
+"""Trading module — place orders on Polymarket with local credential custody."""
+
+from .types import *  # noqa: F401, F403
+from .constants import *  # noqa: F401, F403
+from .signer import NormalizedSigner, normalize_signer
+from .cosigner import build_l2_headers, send_via_cosigner
+from .onboarding import derive_safe_address, derive_proxy_address, detect_wallet_type
+from .trader import PolyNodeTrader
+
+__all__ = [
+    "PolyNodeTrader",
+    "NormalizedSigner",
+    "normalize_signer",
+    "build_l2_headers",
+    "send_via_cosigner",
+    "derive_safe_address",
+    "derive_proxy_address",
+    "detect_wallet_type",
+]

polynode/trading/clob_api.py

@@ -0,0 +1,158 @@
+"""Direct CLOB HTTP calls for order management."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .constants import CLOB_HOST
+from .cosigner import build_l2_headers
+
+
+async def post_order(
+    cosigner_url: str,
+    polynode_key: str,
+    fallback_direct: bool,
+    credentials: dict[str, str],
+    wallet_address: str,
+    order_body: str,
+) -> dict[str, Any]:
+    """Submit a signed order to the CLOB."""
+    from .cosigner import send_via_cosigner
+
+    headers = build_l2_headers(
+        credentials["apiKey"],
+        credentials["apiSecret"],
+        credentials["apiPassphrase"],
+        wallet_address,
+        "POST",
+        "/order",
+        order_body,
+    )
+
+    return await send_via_cosigner(
+        cosigner_url,
+        polynode_key,
+        fallback_direct,
+        {"method": "POST", "path": "/order", "body": order_body, "headers": headers},
+    )
+
+
+async def cancel_order(
+    cosigner_url: str,
+    polynode_key: str,
+    fallback_direct: bool,
+    credentials: dict[str, str],
+    wallet_address: str,
+    order_id: str,
+) -> dict[str, Any]:
+    """Cancel a specific order."""
+    from .cosigner import send_via_cosigner
+    import json
+
+    body = json.dumps({"orderID": order_id})
+    headers = build_l2_headers(
+        credentials["apiKey"],
+        credentials["apiSecret"],
+        credentials["apiPassphrase"],
+        wallet_address,
+        "DELETE",
+        "/order",
+        body,
+    )
+
+    return await send_via_cosigner(
+        cosigner_url,
+        polynode_key,
+        fallback_direct,
+        {"method": "DELETE", "path": "/order", "body": body, "headers": headers},
+    )
+
+
+async def cancel_all_orders(
+    cosigner_url: str,
+    polynode_key: str,
+    fallback_direct: bool,
+    credentials: dict[str, str],
+    wallet_address: str,
+    market: str | None = None,
+) -> dict[str, Any]:
+    """Cancel all orders, optionally for a specific market."""
+    from .cosigner import send_via_cosigner
+    import json
+
+    path = "/cancel-market-orders" if market else "/cancel-all"
+    body = json.dumps({"market": market}) if market else None
+    headers = build_l2_headers(
+        credentials["apiKey"],
+        credentials["apiSecret"],
+        credentials["apiPassphrase"],
+        wallet_address,
+        "DELETE",
+        path,
+        body,
+    )
+
+    return await send_via_cosigner(
+        cosigner_url,
+        polynode_key,
+        fallback_direct,
+        {"method": "DELETE", "path": path, "body": body, "headers": headers},
+    )
+
+
+async def get_open_orders(
+    cosigner_url: str,
+    polynode_key: str,
+    fallback_direct: bool,
+    credentials: dict[str, str],
+    wallet_address: str,
+    market: str | None = None,
+    asset_id: str | None = None,
+) -> list[dict[str, Any]]:
+    """Get open orders from the CLOB."""
+    from .cosigner import send_via_cosigner
+
+    path = "/data/orders"
+    params = []
+    if market:
+        params.append(f"market={market}")
+    if asset_id:
+        params.append(f"asset_id={asset_id}")
+    if params:
+        path += "?" + "&".join(params)
+
+    headers = build_l2_headers(
+        credentials["apiKey"],
+        credentials["apiSecret"],
+        credentials["apiPassphrase"],
+        wallet_address,
+        "GET",
+        path,
+    )
+
+    result = await send_via_cosigner(
+        cosigner_url,
+        polynode_key,
+        fallback_direct,
+        {"method": "GET", "path": path, "headers": headers},
+    )
+
+    if isinstance(result, list):
+        return result
+    return result.get("data") or result.get("orders") or []
+
+
+async def fetch_tick_size(token_id: str) -> str:
+    """Fetch tick size for a token from the CLOB."""
+    async with httpx.AsyncClient(timeout=5.0) as http:
+        resp = await http.get(f"{CLOB_HOST}/tick-size?token_id={token_id}")
+        return str(resp.json())
+
+
+async def fetch_neg_risk(token_id: str) -> bool:
+    """Fetch neg-risk flag for a token from the CLOB."""
+    async with httpx.AsyncClient(timeout=5.0) as http:
+        resp = await http.get(f"{CLOB_HOST}/neg-risk?token_id={token_id}")
+        return bool(resp.json())

polynode/trading/constants.py

@@ -0,0 +1,31 @@
+"""Contract addresses and constants for Polymarket on Polygon (chain 137)."""
+
+CHAIN_ID = 137
+CLOB_HOST = "https://clob.polymarket.com"
+RELAYER_HOST = "https://relayer-v2.polymarket.com"
+DEFAULT_RPC = "https://polygon-bor-rpc.publicnode.com"
+DEFAULT_COSIGNER = "https://trade.polynode.dev"
+
+# Exchange contracts
+CTF_EXCHANGE = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E"
+NEG_RISK_CTF_EXCHANGE = "0xC5d563A36AE78145C45a50134d48A1215220f80a"
+NEG_RISK_ADAPTER = "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
+
+# Token contracts
+USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+CTF = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"
+
+# Safe derivation
+SAFE_FACTORY = "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b"
+SAFE_MULTISEND = "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761"
+SAFE_INIT_CODE_HASH = "0x2bce2127ff07fb632d16c8347c4ebf501f4841168bed00d9e6ef715ddb6fcecf"
+
+# Proxy derivation
+PROXY_FACTORY = "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052"
+PROXY_INIT_CODE_HASH = "0xd21df8dc65880a8606f09fe0ce3df9b8869287ab0b058be05aa9e8af6330a00b"
+
+# All spender contracts that need approval
+SPENDERS = [CTF_EXCHANGE, NEG_RISK_CTF_EXCHANGE, NEG_RISK_ADAPTER]
+
+# Metadata cache TTL (5 minutes)
+META_TTL_SECONDS = 300

polynode/trading/cosigner.py

@@ -0,0 +1,86 @@
+"""Co-signer client — routes orders through the PolyNode builder attribution proxy."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import time
+from typing import Any
+
+import httpx
+
+from .constants import CLOB_HOST
+
+
+def build_l2_headers(
+    api_key: str,
+    api_secret: str,
+    api_passphrase: str,
+    wallet_address: str,
+    method: str,
+    path: str,
+    body: str | None = None,
+) -> dict[str, str]:
+    """Build L2 HMAC headers for Polymarket CLOB authentication."""
+    timestamp = str(int(time.time()))
+    message = f"{timestamp}{method}{path}"
+    if body:
+        message += body
+
+    secret_bytes = base64.b64decode(api_secret)
+    sig = base64.b64encode(
+        hmac.new(secret_bytes, message.encode(), hashlib.sha256).digest()
+    ).decode()
+    sig = sig.replace("+", "-").replace("/", "_")
+
+    return {
+        "POLY_ADDRESS": wallet_address,
+        "POLY_SIGNATURE": sig,
+        "POLY_TIMESTAMP": timestamp,
+        "POLY_API_KEY": api_key,
+        "POLY_PASSPHRASE": api_passphrase,
+    }
+
+
+async def send_via_cosigner(
+    cosigner_url: str,
+    polynode_key: str,
+    fallback_direct: bool,
+    request: dict[str, Any],
+) -> Any:
+    """Send a request through the co-signer with optional fallback to direct CLOB."""
+    if cosigner_url:
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as http:
+                resp = await http.post(
+                    f"{cosigner_url}/submit",
+                    headers={
+                        "Content-Type": "application/json",
+                        "X-PolyNode-Key": polynode_key,
+                    },
+                    json=request,
+                )
+                data = resp.json()
+                if resp.status_code >= 500 and fallback_direct:
+                    return await _send_direct(request)
+                return data
+        except Exception as e:
+            if fallback_direct:
+                return await _send_direct(request)
+            raise RuntimeError(f"Co-signer unreachable: {e}")
+
+    return await _send_direct(request)
+
+
+async def _send_direct(request: dict[str, Any]) -> Any:
+    """Send directly to Polymarket CLOB (no builder attribution)."""
+    url = f"{CLOB_HOST}{request['path']}"
+    async with httpx.AsyncClient(timeout=10.0) as http:
+        resp = await http.request(
+            request["method"],
+            url,
+            headers={**request.get("headers", {}), "Content-Type": "application/json"},
+            content=request.get("body"),
+        )
+        return resp.json()

polynode/trading/eip712.py

@@ -0,0 +1,163 @@
+"""Pure Python EIP-712 order signing for Polymarket exchange contracts."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from .constants import CTF_EXCHANGE, NEG_RISK_CTF_EXCHANGE
+from .types import Eip712Payload, SignatureType
+
+
+# EIP-712 domain for Polymarket Exchange
+EXCHANGE_DOMAIN = {
+    "name": "PolymarketExchange",
+    "version": "1",
+    "chainId": 137,
+    "verifyingContract": CTF_EXCHANGE,
+}
+
+NEG_RISK_DOMAIN = {
+    "name": "PolymarketExchange",
+    "version": "1",
+    "chainId": 137,
+    "verifyingContract": NEG_RISK_CTF_EXCHANGE,
+}
+
+ORDER_TYPES = {
+    "Order": [
+        {"name": "salt", "type": "uint256"},
+        {"name": "maker", "type": "address"},
+        {"name": "signer", "type": "address"},
+        {"name": "taker", "type": "address"},
+        {"name": "tokenId", "type": "uint256"},
+        {"name": "makerAmount", "type": "uint256"},
+        {"name": "takerAmount", "type": "uint256"},
+        {"name": "expiration", "type": "uint256"},
+        {"name": "nonce", "type": "uint256"},
+        {"name": "feeRateBps", "type": "uint256"},
+        {"name": "side", "type": "uint8"},
+        {"name": "signatureType", "type": "uint8"},
+    ],
+}
+
+
+def compute_amounts(
+    price: float,
+    size: float,
+    side: str,
+    tick_size: str,
+) -> tuple[int, int]:
+    """Compute maker_amount and taker_amount from price/size/tick_size."""
+    decimals = len(tick_size.rstrip("0").split(".")[-1]) if "." in tick_size else 0
+    raw_price = round(price * (10 ** decimals))
+    raw_size = round(size * 1_000_000)  # USDC has 6 decimals
+    price_denom = 10 ** decimals
+
+    if side == "BUY":
+        maker_amount = raw_size * raw_price // price_denom
+        taker_amount = raw_size
+    else:
+        maker_amount = raw_size
+        taker_amount = raw_size * raw_price // price_denom
+
+    return maker_amount, taker_amount
+
+
+def build_order_payload(
+    *,
+    maker: str,
+    signer: str,
+    token_id: str,
+    maker_amount: int,
+    taker_amount: int,
+    side: str,
+    signature_type: SignatureType,
+    fee_rate_bps: int = 0,
+    nonce: int = 0,
+    expiration: int = 0,
+    neg_risk: bool = False,
+) -> Eip712Payload:
+    """Build an EIP-712 typed data payload for a Polymarket order."""
+    import secrets
+
+    salt = int(secrets.token_hex(32), 16)
+    side_int = 0 if side == "BUY" else 1
+
+    domain = NEG_RISK_DOMAIN if neg_risk else EXCHANGE_DOMAIN
+
+    message = {
+        "salt": salt,
+        "maker": maker,
+        "signer": signer,
+        "taker": "0x0000000000000000000000000000000000000000",
+        "tokenId": int(token_id),
+        "makerAmount": maker_amount,
+        "takerAmount": taker_amount,
+        "expiration": expiration,
+        "nonce": nonce,
+        "feeRateBps": fee_rate_bps,
+        "side": side_int,
+        "signatureType": int(signature_type),
+    }
+
+    return Eip712Payload(
+        domain=domain,
+        types=ORDER_TYPES,
+        primary_type="Order",
+        message=message,
+    )
+
+
+async def create_signed_order(
+    sign_typed_data: Any,
+    *,
+    signer_address: str,
+    funder_address: str,
+    token_id: str,
+    price: float,
+    size: float,
+    side: str,
+    signature_type: SignatureType,
+    tick_size: str = "0.01",
+    neg_risk: bool = False,
+    fee_rate_bps: int = 0,
+    expiration: int = 0,
+    nonce: int = 0,
+) -> dict[str, Any]:
+    """Create and sign a Polymarket order. Returns the order dict ready for CLOB submission."""
+    maker_amount, taker_amount = compute_amounts(price, size, side, tick_size)
+
+    payload = build_order_payload(
+        maker=funder_address,
+        signer=signer_address,
+        token_id=token_id,
+        maker_amount=maker_amount,
+        taker_amount=taker_amount,
+        side=side,
+        signature_type=signature_type,
+        fee_rate_bps=fee_rate_bps,
+        nonce=nonce,
+        expiration=expiration,
+        neg_risk=neg_risk,
+    )
+
+    signature = await sign_typed_data(payload)
+    if not signature.startswith("0x"):
+        signature = f"0x{signature}"
+
+    return {
+        "salt": str(payload.message["salt"]),
+        "maker": funder_address,
+        "signer": signer_address,
+        "taker": "0x0000000000000000000000000000000000000000",
+        "tokenId": token_id,
+        "makerAmount": str(maker_amount),
+        "takerAmount": str(taker_amount),
+        "expiration": str(expiration),
+        "nonce": str(nonce),
+        "feeRateBps": str(fee_rate_bps),
+        "side": side,
+        "signatureType": int(signature_type),
+        "signature": signature,
+    }