polynode 0.6.3__tar.gz → 0.7.0__tar.gz

{polynode-0.6.3 → polynode-0.7.0}/.gitignore

@@ -36,3 +36,5 @@ docs/
 # Compiled binaries
 ob/ob
 ob/ob.bak
+wallet-resolver/wallets.db
+__pycache__/

{polynode-0.6.3 → polynode-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polynode
-Version: 0.6.3
+Version: 0.7.0
 Summary: Python SDK for the PolyNode real-time prediction market data platform
 Project-URL: Homepage, https://polynode.dev
 Project-URL: Documentation, https://docs.polynode.dev

{polynode-0.6.3 → polynode-0.7.0}/polynode/trading/__init__.py

@@ -12,6 +12,7 @@ from .privy import PrivySigner, PrivyConfig
 __all__ = [
     "PolyNodeTrader",
     "BuilderCredentials",
+    "ExchangeVersion",
     "PrivySigner",
     "PrivyConfig",
     "NormalizedSigner",

{polynode-0.6.3 → polynode-0.7.0}/polynode/trading/clob_api.py

@@ -6,8 +6,9 @@ from typing import Any
 
 import httpx
 
-from .constants import CLOB_HOST
+from .constants import CLOB_HOST, CLOB_HOST_V2
 from .cosigner import build_l2_headers
+from .types import ExchangeVersion
 
 
 async def post_order(
@@ -18,6 +19,7 @@ async def post_order(
     wallet_address: str,
     order_body: str,
     builder_credentials: Any | None = None,
+    clob_host: str | None = None,
 ) -> dict[str, Any]:
     """Submit a signed order to the CLOB."""
     from .cosigner import send_via_cosigner
@@ -38,6 +40,7 @@ async def post_order(
         fallback_direct,
         {"method": "POST", "path": "/order", "body": order_body, "headers": headers},
         builder_credentials=builder_credentials,
+        clob_host=clob_host,
     )
 
 
@@ -49,6 +52,7 @@ async def cancel_order(
     wallet_address: str,
     order_id: str,
     builder_credentials: Any | None = None,
+    clob_host: str | None = None,
 ) -> dict[str, Any]:
     """Cancel a specific order."""
     from .cosigner import send_via_cosigner
@@ -71,6 +75,7 @@ async def cancel_order(
         fallback_direct,
         {"method": "DELETE", "path": "/order", "body": body, "headers": headers},
         builder_credentials=builder_credentials,
+        clob_host=clob_host,
     )
 
 
@@ -82,6 +87,7 @@ async def cancel_all_orders(
     wallet_address: str,
     market: str | None = None,
     builder_credentials: Any | None = None,
+    clob_host: str | None = None,
 ) -> dict[str, Any]:
     """Cancel all orders, optionally for a specific market."""
     from .cosigner import send_via_cosigner
@@ -105,6 +111,7 @@ async def cancel_all_orders(
         fallback_direct,
         {"method": "DELETE", "path": path, "body": body, "headers": headers},
         builder_credentials=builder_credentials,
+        clob_host=clob_host,
     )
 
 
@@ -117,6 +124,7 @@ async def get_open_orders(
     market: str | None = None,
     asset_id: str | None = None,
     builder_credentials: Any | None = None,
+    clob_host: str | None = None,
 ) -> list[dict[str, Any]]:
     """Get open orders from the CLOB."""
     from .cosigner import send_via_cosigner
@@ -145,6 +153,7 @@ async def get_open_orders(
         fallback_direct,
         {"method": "GET", "path": path, "headers": headers},
         builder_credentials=builder_credentials,
+        clob_host=clob_host,
     )
 
     if isinstance(result, list):
@@ -152,17 +161,30 @@ async def get_open_orders(
     return result.get("data") or result.get("orders") or []
 
 
-async def fetch_tick_size(token_id: str) -> str:
+def _clob_host(version: ExchangeVersion = ExchangeVersion.V1) -> str:
+    """Return the CLOB host URL for the given exchange version."""
+    return CLOB_HOST_V2 if version == ExchangeVersion.V2 else CLOB_HOST
+
+
+async def fetch_tick_size(
+    token_id: str,
+    version: ExchangeVersion = ExchangeVersion.V1,
+) -> str:
     """Fetch tick size for a token from the CLOB."""
+    host = _clob_host(version)
     async with httpx.AsyncClient(timeout=5.0) as http:
-        resp = await http.get(f"{CLOB_HOST}/tick-size?token_id={token_id}")
+        resp = await http.get(f"{host}/tick-size?token_id={token_id}")
         data = resp.json()
         return str(data.get("minimum_tick_size", data) if isinstance(data, dict) else data)
 
 
-async def fetch_neg_risk(token_id: str) -> bool:
+async def fetch_neg_risk(
+    token_id: str,
+    version: ExchangeVersion = ExchangeVersion.V1,
+) -> bool:
     """Fetch neg-risk flag for a token from the CLOB."""
+    host = _clob_host(version)
     async with httpx.AsyncClient(timeout=5.0) as http:
-        resp = await http.get(f"{CLOB_HOST}/neg-risk?token_id={token_id}")
+        resp = await http.get(f"{host}/neg-risk?token_id={token_id}")
         data = resp.json()
         return bool(data.get("neg_risk", data) if isinstance(data, dict) else data)

{polynode-0.6.3 → polynode-0.7.0}/polynode/trading/constants.py

@@ -1,16 +1,22 @@
 """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
+# ── V1 ──
+CLOB_HOST = "https://clob.polymarket.com"
 CTF_EXCHANGE = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E"
 NEG_RISK_CTF_EXCHANGE = "0xC5d563A36AE78145C45a50134d48A1215220f80a"
 NEG_RISK_ADAPTER = "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
 
+# ── V2 ──
+CLOB_HOST_V2 = "https://clob-v2.polymarket.com"
+CTF_EXCHANGE_V2 = "0xe111180000d2663c0091e4f400237545b87b996b"
+NEG_RISK_CTF_EXCHANGE_V2_A = "0xe2222d279d744050d28e00520010520000310f59"
+NEG_RISK_CTF_EXCHANGE_V2_B = "0xe2222d002000ba0053cef3375333610f64600036"
+
 # Token contracts
 USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
 CTF = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"
@@ -26,6 +32,12 @@ PROXY_INIT_CODE_HASH = "0xd21df8dc65880a8606f09fe0ce3df9b8869287ab0b058be05aa9e8
 
 # All spender contracts that need approval
 SPENDERS = [CTF_EXCHANGE, NEG_RISK_CTF_EXCHANGE, NEG_RISK_ADAPTER]
+V2_SPENDERS = [CTF_EXCHANGE_V2, NEG_RISK_CTF_EXCHANGE_V2_A, NEG_RISK_CTF_EXCHANGE_V2_B]
+
+# PolyUSD wrapping contracts
+POLY_USD = "0xc011a7e12a19f7b1f670d46f03b03f3342e82dfb"
+COLLATERAL_ONRAMP = "0x93070a847efef7f70739046a929d47a521f5b8ee"
+COLLATERAL_OFFRAMP = "0x2957922eb93258b93368531d39facca3b4dc5854"
 
 # Metadata cache TTL (5 minutes)
 META_TTL_SECONDS = 300

{polynode-0.6.3 → polynode-0.7.0}/polynode/trading/cosigner.py

@@ -49,6 +49,7 @@ async def send_via_cosigner(
     fallback_direct: bool,
     request: dict[str, Any],
     builder_credentials: Any | None = None,
+    clob_host: str | None = None,
 ) -> Any:
     """Send a request through the co-signer with optional fallback to direct CLOB."""
     if cosigner_url:
@@ -70,19 +71,20 @@ async def send_via_cosigner(
                 )
                 data = resp.json()
                 if resp.status_code >= 500 and fallback_direct:
-                    return await _send_direct(request)
+                    return await _send_direct(request, clob_host=clob_host)
                 return data
         except Exception as e:
             if fallback_direct:
-                return await _send_direct(request)
+                return await _send_direct(request, clob_host=clob_host)
             raise RuntimeError(f"Co-signer unreachable: {e}")
 
-    return await _send_direct(request)
+    return await _send_direct(request, clob_host=clob_host)
 
 
-async def _send_direct(request: dict[str, Any]) -> Any:
+async def _send_direct(request: dict[str, Any], clob_host: str | None = None) -> Any:
     """Send directly to Polymarket CLOB (no builder attribution)."""
-    url = f"{CLOB_HOST}{request['path']}"
+    host = clob_host or CLOB_HOST
+    url = f"{host}{request['path']}"
     async with httpx.AsyncClient(timeout=10.0) as http:
         resp = await http.request(
             request["method"],

polynode-0.7.0/polynode/trading/eip712.py

@@ -0,0 +1,330 @@
+"""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,
+    CTF_EXCHANGE_V2,
+    NEG_RISK_CTF_EXCHANGE,
+    NEG_RISK_CTF_EXCHANGE_V2_A,
+)
+from .types import Eip712Payload, ExchangeVersion, SignatureType
+
+
+# ── V1 EIP-712 domains ──
+
+EXCHANGE_DOMAIN = {
+    "name": "Polymarket CTF Exchange",
+    "version": "1",
+    "chainId": 137,
+    "verifyingContract": CTF_EXCHANGE,
+}
+
+NEG_RISK_DOMAIN = {
+    "name": "Polymarket CTF Exchange",
+    "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"},
+    ],
+}
+
+# ── V2 EIP-712 domains ──
+
+EXCHANGE_DOMAIN_V2 = {
+    "name": "Polymarket CTF Exchange",
+    "version": "2",
+    "chainId": 137,
+    "verifyingContract": CTF_EXCHANGE_V2,
+}
+
+NEG_RISK_DOMAIN_V2 = {
+    "name": "Polymarket CTF Exchange",
+    "version": "2",
+    "chainId": 137,
+    "verifyingContract": NEG_RISK_CTF_EXCHANGE_V2_A,
+}
+
+ORDER_TYPES_V2 = {
+    "Order": [
+        {"name": "salt", "type": "uint256"},
+        {"name": "maker", "type": "address"},
+        {"name": "signer", "type": "address"},
+        {"name": "tokenId", "type": "uint256"},
+        {"name": "makerAmount", "type": "uint256"},
+        {"name": "takerAmount", "type": "uint256"},
+        {"name": "side", "type": "uint8"},
+        {"name": "signatureType", "type": "uint8"},
+        {"name": "timestamp", "type": "uint256"},
+        {"name": "metadata", "type": "bytes32"},
+        {"name": "builder", "type": "bytes32"},
+    ],
+}
+
+
+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 = secrets.randbelow(2**32)
+    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 V1 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}"
+
+    # Normalize v to raw recovery id (0/1): CLOB expects v=0/1 for order signatures
+    sig_bytes = bytearray(bytes.fromhex(signature[2:]))
+    if len(sig_bytes) == 65 and sig_bytes[-1] >= 27:
+        sig_bytes[-1] -= 27
+    signature = "0x" + sig_bytes.hex()
+
+    return {
+        "salt": 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,
+    }
+
+
+# ── V2 order building ──
+
+
+def build_order_payload_v2(
+    *,
+    maker: str,
+    signer: str,
+    token_id: str,
+    maker_amount: int,
+    taker_amount: int,
+    side: str,
+    signature_type: SignatureType,
+    neg_risk: bool = False,
+    timestamp_ms: int | None = None,
+    metadata: str = "0x" + "00" * 32,
+    builder: str = "0x" + "00" * 32,
+) -> Eip712Payload:
+    """Build a V2 EIP-712 typed data payload for a Polymarket order."""
+    import time
+
+    if timestamp_ms is None:
+        timestamp_ms = int(time.time() * 1000)
+
+    salt = timestamp_ms
+    side_int = 0 if side == "BUY" else 1
+    domain = NEG_RISK_DOMAIN_V2 if neg_risk else EXCHANGE_DOMAIN_V2
+
+    # Pad metadata/builder to bytes32
+    meta_hex = metadata if metadata.startswith("0x") else f"0x{metadata}"
+    meta_hex = meta_hex[:2] + meta_hex[2:].ljust(64, "0")
+    builder_hex = builder if builder.startswith("0x") else f"0x{builder}"
+    builder_hex = builder_hex[:2] + builder_hex[2:].ljust(64, "0")
+
+    message = {
+        "salt": salt,
+        "maker": maker,
+        "signer": signer,
+        "tokenId": int(token_id),
+        "makerAmount": maker_amount,
+        "takerAmount": taker_amount,
+        "side": side_int,
+        "signatureType": int(signature_type),
+        "timestamp": timestamp_ms,
+        "metadata": meta_hex,
+        "builder": builder_hex,
+    }
+
+    return Eip712Payload(
+        domain=domain,
+        types=ORDER_TYPES_V2,
+        primary_type="Order",
+        message=message,
+    )
+
+
+async def create_signed_order_v2(
+    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,
+    timestamp_ms: int | None = None,
+    metadata: str = "0x" + "00" * 32,
+    builder: str = "0x" + "00" * 32,
+) -> dict[str, Any]:
+    """Create and sign a V2 Polymarket order. Returns the order dict ready for V2 CLOB submission.
+
+    V2 differences from V1:
+    - No taker, expiration, nonce, or feeRateBps fields
+    - Adds timestamp (ms), metadata (bytes32), builder (bytes32)
+    - Domain version "2" with V2 exchange addresses
+    - salt is a number (not string) in the payload
+    - side is a string ("BUY"/"SELL") in the payload
+    - timestamp is a string in the payload
+    """
+    maker_amount, taker_amount = compute_amounts(price, size, side, tick_size)
+
+    payload = build_order_payload_v2(
+        maker=funder_address,
+        signer=signer_address,
+        token_id=token_id,
+        maker_amount=maker_amount,
+        taker_amount=taker_amount,
+        side=side,
+        signature_type=signature_type,
+        neg_risk=neg_risk,
+        timestamp_ms=timestamp_ms,
+        metadata=metadata,
+        builder=builder,
+    )
+
+    signature = await sign_typed_data(payload)
+    if not signature.startswith("0x"):
+        signature = f"0x{signature}"
+
+    # Normalize v to raw recovery id (0/1): CLOB expects v=0/1 for order signatures
+    sig_bytes = bytearray(bytes.fromhex(signature[2:]))
+    if len(sig_bytes) == 65 and sig_bytes[-1] >= 27:
+        sig_bytes[-1] -= 27
+    signature = "0x" + sig_bytes.hex()
+
+    return {
+        "salt": payload.message["salt"],  # number
+        "maker": funder_address,
+        "signer": signer_address,
+        "tokenId": token_id,
+        "makerAmount": str(maker_amount),
+        "takerAmount": str(taker_amount),
+        "side": side,  # string "BUY"/"SELL"
+        "signatureType": int(signature_type),  # number
+        "timestamp": str(payload.message["timestamp"]),  # string
+        "metadata": payload.message["metadata"],
+        "builder": payload.message["builder"],
+        "signature": signature,
+    }