polynode 0.6.3__py3-none-any.whl → 0.7.1__py3-none-any.whl

polynode/trading/__init__.py

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

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/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,15 @@ 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"
+
+# Fee Escrow
+FEE_ESCROW_ADDRESS = "0xa11D28433B79D0A88F3119b16A090075752258EA"
 
 # Metadata cache TTL (5 minutes)
 META_TTL_SECONDS = 300

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/trading/eip712.py

@@ -5,11 +5,17 @@ from __future__ import annotations
 import math
 from typing import Any
 
-from .constants import CTF_EXCHANGE, NEG_RISK_CTF_EXCHANGE
-from .types import Eip712Payload, SignatureType
+from .constants import (
+    CTF_EXCHANGE,
+    CTF_EXCHANGE_V2,
+    NEG_RISK_CTF_EXCHANGE,
+    NEG_RISK_CTF_EXCHANGE_V2_A,
+)
+from .types import Eip712Payload, ExchangeVersion, SignatureType
 
 
-# EIP-712 domain for Polymarket Exchange
+# ── V1 EIP-712 domains ──
+
 EXCHANGE_DOMAIN = {
     "name": "Polymarket CTF Exchange",
     "version": "1",
@@ -41,6 +47,38 @@ ORDER_TYPES = {
     ],
 }
 
+# ── 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,
@@ -125,7 +163,7 @@ async def create_signed_order(
     expiration: int = 0,
     nonce: int = 0,
 ) -> dict[str, Any]:
-    """Create and sign a Polymarket order. Returns the order dict ready for CLOB submission."""
+    """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(
@@ -167,3 +205,126 @@ async def create_signed_order(
         "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,
+    }

polynode/trading/escrow.py

@@ -0,0 +1,166 @@
+"""Fee Escrow — EIP-712 signing, fee calculation, and nonce fetching
+for the on-chain FeeEscrow contract.
+
+The escrow is completely optional. When fee_bps=0, none of this code runs.
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import secrets
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from .constants import CHAIN_ID, FEE_ESCROW_ADDRESS
+from .types import Eip712Payload
+
+# ── EIP-712 Types ──
+
+FEE_AUTH_DOMAIN = {
+    "name": "PolyNodeFeeEscrow",
+    "version": "1",
+    "chainId": CHAIN_ID,
+    "verifyingContract": FEE_ESCROW_ADDRESS,
+}
+
+FEE_AUTH_TYPES = {
+    "FeeAuth": [
+        {"name": "orderId", "type": "bytes32"},
+        {"name": "payer", "type": "address"},
+        {"name": "signer", "type": "address"},
+        {"name": "feeAmount", "type": "uint256"},
+        {"name": "deadline", "type": "uint256"},
+        {"name": "nonce", "type": "uint256"},
+    ],
+}
+
+ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
+
+
+# ── Fee Calculation ──
+
+def calculate_fee(price: float, size: float, fee_bps: int) -> int:
+    """Calculate fee amount in raw USDC (6 decimals).
+
+    Args:
+        price: Order price (e.g. 0.55)
+        size: Order size in tokens (e.g. 100)
+        fee_bps: Fee in basis points (e.g. 50 = 0.5%)
+
+    Returns:
+        Fee amount as int in raw USDC units
+    """
+    notional_raw = math.floor(price * size * 1e6)
+    fee = math.floor(notional_raw * fee_bps / 10000)
+    return max(fee, 0)
+
+
+# ── Order ID Generation ──
+
+def generate_escrow_order_id() -> str:
+    """Generate a random bytes32 escrow order ID (0x-prefixed hex)."""
+    return "0x" + secrets.token_hex(32)
+
+
+# ── Nonce Fetching ──
+
+async def fetch_escrow_nonce(rpc_url: str, signer_address: str) -> int:
+    """Fetch the current nonce for a signer from the FeeEscrow contract via eth_call."""
+    # getNonce(address) selector = 0x2d0335ab
+    addr = signer_address.lower().replace("0x", "").zfill(64)
+    data = "0x2d0335ab" + addr
+
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(
+            rpc_url,
+            json={
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "eth_call",
+                "params": [{"to": FEE_ESCROW_ADDRESS, "data": data}, "latest"],
+            },
+        )
+        result = resp.json()
+
+    if "error" in result:
+        raise RuntimeError(f"Failed to fetch escrow nonce: {result['error']}")
+    return int(result.get("result", "0x0"), 16)
+
+
+# ── EIP-712 Signing ──
+
+@dataclass
+class FeeAuthRequest:
+    escrow_order_id: str
+    payer: str
+    signer: str
+    fee_amount: str
+    deadline: int
+    nonce: int
+    signature: str
+    affiliate: str
+    affiliate_share_bps: int
+
+
+async def sign_fee_auth(
+    sign_typed_data: Any,
+    *,
+    escrow_order_id: str,
+    payer: str,
+    signer_address: str,
+    fee_amount: int,
+    deadline: int,
+    nonce: int,
+    affiliate: str | None = None,
+    affiliate_share_bps: int | None = None,
+) -> FeeAuthRequest:
+    """Sign a FeeAuth EIP-712 message.
+
+    Args:
+        sign_typed_data: Callable that signs an Eip712Payload and returns a hex signature.
+        escrow_order_id: Random bytes32 hex string.
+        payer: Safe wallet address (where USDC is pulled from).
+        signer_address: EOA address (signs the message).
+        fee_amount: Fee in raw USDC (6 decimals).
+        deadline: Unix timestamp — authorization expires after this.
+        nonce: Signer's current nonce from the escrow contract.
+        affiliate: Partner wallet address.
+        affiliate_share_bps: Partner's share of fee in bps.
+
+    Returns:
+        FeeAuthRequest ready for the cosigner.
+    """
+    message = {
+        "orderId": escrow_order_id,
+        "payer": payer,
+        "signer": signer_address,
+        "feeAmount": str(fee_amount),
+        "deadline": str(deadline),
+        "nonce": str(nonce),
+    }
+
+    payload = Eip712Payload(
+        domain=FEE_AUTH_DOMAIN,
+        types=FEE_AUTH_TYPES,
+        primary_type="FeeAuth",
+        message=message,
+    )
+
+    signature = await sign_typed_data(payload)
+    if not signature.startswith("0x"):
+        signature = f"0x{signature}"
+
+    return FeeAuthRequest(
+        escrow_order_id=escrow_order_id,
+        payer=payer,
+        signer=signer_address,
+        fee_amount=str(fee_amount),
+        deadline=deadline,
+        nonce=nonce,
+        signature=signature,
+        affiliate=affiliate or ZERO_ADDRESS,
+        affiliate_share_bps=affiliate_share_bps or 0,
+    )