polynode 0.6.3__py3-none-any.whl → 0.7.0__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,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/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/onboarding.py

@@ -9,10 +9,17 @@ import httpx
 from .constants import (
     CHAIN_ID,
     CLOB_HOST,
+    CLOB_HOST_V2,
+    COLLATERAL_OFFRAMP,
+    COLLATERAL_ONRAMP,
     CTF,
     CTF_EXCHANGE,
+    CTF_EXCHANGE_V2,
     NEG_RISK_ADAPTER,
     NEG_RISK_CTF_EXCHANGE,
+    NEG_RISK_CTF_EXCHANGE_V2_A,
+    NEG_RISK_CTF_EXCHANGE_V2_B,
+    POLY_USD,
     PROXY_FACTORY,
     PROXY_INIT_CODE_HASH,
     RELAYER_HOST,
@@ -20,8 +27,9 @@ from .constants import (
     SAFE_INIT_CODE_HASH,
     SPENDERS,
     USDC,
+    V2_SPENDERS,
 )
-from .types import ApprovalStatus, BalanceInfo, SignatureType
+from .types import ApprovalStatus, BalanceInfo, ExchangeVersion, SignatureType
 
 
 def derive_safe_address(eoa: str) -> str:
@@ -126,8 +134,17 @@ async def is_safe_deployed(funder_address: str) -> bool:
     return False
 
 
-async def check_approvals(funder_address: str, rpc_url: str) -> ApprovalStatus:
-    """Check token approvals for all spender contracts."""
+async def check_approvals(
+    funder_address: str,
+    rpc_url: str,
+    version: ExchangeVersion = ExchangeVersion.V1,
+) -> ApprovalStatus:
+    """Check token approvals for all spender contracts.
+
+    V1: checks USDC allowance to SPENDERS (CTF Exchange, NegRisk, Adapter)
+    V2: checks PolyUSD allowance to V2_SPENDERS (V2 Exchange, NegRisk V2 A/B)
+    Both: checks CTF isApprovedForAll to the respective spenders
+    """
     try:
         from web3 import Web3
     except ImportError:
@@ -137,7 +154,22 @@ async def check_approvals(funder_address: str, rpc_url: str) -> ApprovalStatus:
     erc20_abi = [{"inputs": [{"name": "owner", "type": "address"}, {"name": "spender", "type": "address"}], "name": "allowance", "outputs": [{"name": "", "type": "uint256"}], "stateMutability": "view", "type": "function"}]
     erc1155_abi = [{"inputs": [{"name": "account", "type": "address"}, {"name": "operator", "type": "address"}], "name": "isApprovedForAll", "outputs": [{"name": "", "type": "bool"}], "stateMutability": "view", "type": "function"}]
 
-    usdc_contract = w3.eth.contract(address=Web3.to_checksum_address(USDC), abi=erc20_abi)
+    if version == ExchangeVersion.V2:
+        collateral_token = POLY_USD
+        spender_list = [
+            (CTF_EXCHANGE_V2, "ctf_exchange_v2"),
+            (NEG_RISK_CTF_EXCHANGE_V2_A, "neg_risk_ctf_exchange_v2_a"),
+            (NEG_RISK_CTF_EXCHANGE_V2_B, "neg_risk_ctf_exchange_v2_b"),
+        ]
+    else:
+        collateral_token = USDC
+        spender_list = [
+            (CTF_EXCHANGE, "ctf_exchange"),
+            (NEG_RISK_CTF_EXCHANGE, "neg_risk_ctf_exchange"),
+            (NEG_RISK_ADAPTER, "neg_risk_adapter"),
+        ]
+
+    token_contract = w3.eth.contract(address=Web3.to_checksum_address(collateral_token), abi=erc20_abi)
     ctf_contract = w3.eth.contract(address=Web3.to_checksum_address(CTF), abi=erc1155_abi)
 
     funder = Web3.to_checksum_address(funder_address)
@@ -146,9 +178,9 @@ async def check_approvals(funder_address: str, rpc_url: str) -> ApprovalStatus:
 
     usdc_status = {}
     ctf_status = {}
-    for spender, name in [(CTF_EXCHANGE, "ctf_exchange"), (NEG_RISK_CTF_EXCHANGE, "neg_risk_ctf_exchange"), (NEG_RISK_ADAPTER, "neg_risk_adapter")]:
+    for spender, name in spender_list:
         spender_addr = Web3.to_checksum_address(spender)
-        allowance = usdc_contract.functions.allowance(funder, spender_addr).call()
+        allowance = token_contract.functions.allowance(funder, spender_addr).call()
         usdc_status[name] = allowance >= threshold
         approved = ctf_contract.functions.isApprovedForAll(funder, spender_addr).call()
         ctf_status[name] = approved
@@ -163,6 +195,78 @@ async def check_approvals(funder_address: str, rpc_url: str) -> ApprovalStatus:
     )
 
 
+async def set_approvals(
+    signer_key: str,
+    funder_address: str,
+    rpc_url: str,
+    version: ExchangeVersion = ExchangeVersion.V1,
+) -> list[str]:
+    """Set max approvals for collateral and CTF tokens to exchange spenders.
+
+    V1: approve USDC to SPENDERS
+    V2: approve PolyUSD to V2_SPENDERS
+    Both: setApprovalForAll on CTF to the respective spenders
+
+    Returns a list of submitted transaction hashes.
+    """
+    try:
+        from web3 import Web3
+        from eth_account import Account
+    except ImportError:
+        raise ImportError("web3 required. Install with: pip install polynode[trading]")
+
+    w3 = Web3(Web3.HTTPProvider(rpc_url))
+    account = Account.from_key(signer_key if signer_key.startswith("0x") else f"0x{signer_key}")
+    max_uint = 2**256 - 1
+
+    erc20_abi = [
+        {"inputs": [{"name": "spender", "type": "address"}, {"name": "amount", "type": "uint256"}], "name": "approve", "outputs": [{"name": "", "type": "bool"}], "stateMutability": "nonpayable", "type": "function"},
+    ]
+    erc1155_abi = [
+        {"inputs": [{"name": "operator", "type": "address"}, {"name": "approved", "type": "bool"}], "name": "setApprovalForAll", "outputs": [], "stateMutability": "nonpayable", "type": "function"},
+    ]
+
+    if version == ExchangeVersion.V2:
+        collateral_token = POLY_USD
+        spender_list = V2_SPENDERS
+    else:
+        collateral_token = USDC
+        spender_list = SPENDERS
+
+    token_contract = w3.eth.contract(address=Web3.to_checksum_address(collateral_token), abi=erc20_abi)
+    ctf_contract = w3.eth.contract(address=Web3.to_checksum_address(CTF), abi=erc1155_abi)
+
+    tx_hashes: list[str] = []
+    nonce = w3.eth.get_transaction_count(account.address)
+
+    for spender in spender_list:
+        spender_addr = Web3.to_checksum_address(spender)
+
+        # Approve collateral token
+        tx = token_contract.functions.approve(spender_addr, max_uint).build_transaction({
+            "from": account.address,
+            "nonce": nonce,
+            "chainId": CHAIN_ID,
+        })
+        signed = account.sign_transaction(tx)
+        tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+        tx_hashes.append(tx_hash.hex())
+        nonce += 1
+
+        # Approve CTF (ERC-1155)
+        tx = ctf_contract.functions.setApprovalForAll(spender_addr, True).build_transaction({
+            "from": account.address,
+            "nonce": nonce,
+            "chainId": CHAIN_ID,
+        })
+        signed = account.sign_transaction(tx)
+        tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+        tx_hashes.append(tx_hash.hex())
+        nonce += 1
+
+    return tx_hashes
+
+
 async def check_balance(funder_address: str, rpc_url: str) -> BalanceInfo:
     """Check USDC and MATIC balance."""
     try:
@@ -243,17 +347,26 @@ def _parse_clob_credentials(data: dict) -> dict[str, str]:
     }
 
 
-async def create_clob_credentials(signer: Any, funder_address: str) -> dict[str, str]:
+async def create_clob_credentials(
+    signer: Any,
+    funder_address: str,
+    version: ExchangeVersion = ExchangeVersion.V1,
+) -> dict[str, str]:
     """Create or derive CLOB API credentials via the Polymarket CLOB API.
 
     Tries POST /auth/api-key first (create new), falls back to
     GET /auth/derive-api-key (derive existing). Matches Rust SDK flow.
+
+    Same API key works on both V1 and V2 CLOBs (shared database),
+    but we route to the correct CLOB host for the version.
     """
+    host = CLOB_HOST_V2 if version == ExchangeVersion.V2 else CLOB_HOST
+
     async with httpx.AsyncClient(timeout=10.0) as http:
         # Step 1: Try creating a new API key
         headers = await _build_l1_headers(signer, funder_address)
         resp = await http.post(
-            f"{CLOB_HOST}/auth/api-key",
+            f"{host}/auth/api-key",
             headers={**headers, "Accept": "*/*", "Content-Type": "application/json"},
         )
         if resp.is_success:
@@ -265,7 +378,7 @@ async def create_clob_credentials(signer: Any, funder_address: str) -> dict[str,
         # Step 2: Fall back to deriving existing key
         headers = await _build_l1_headers(signer, funder_address)
         resp = await http.get(
-            f"{CLOB_HOST}/auth/derive-api-key",
+            f"{host}/auth/derive-api-key",
             headers={**headers, "Accept": "*/*", "Content-Type": "application/json"},
         )
         if not resp.is_success:

polynode/trading/signer.py

@@ -15,6 +15,7 @@ class NormalizedSigner:
     sign_message: Any  # callable or None
     signature_type: SignatureType
     funder_address: str | None = None
+    _private_key: str | None = None  # stored for on-chain txn signing (wrap/unwrap)
 
 
 async def normalize_signer(
@@ -66,6 +67,7 @@ async def normalize_signer(
             sign_typed_data=_sign_typed_data,
             sign_message=_sign_message,
             signature_type=default_signature_type,
+            _private_key=key,
         )
 
     if isinstance(signer, RouterSigner):

polynode/trading/trader.py

@@ -7,6 +7,7 @@ import time
 from typing import Any
 
 from .clob_api import (
+    _clob_host,
     cancel_all_orders,
     cancel_order as clob_cancel_order,
     fetch_neg_risk,
@@ -14,9 +15,15 @@ from .clob_api import (
     get_open_orders as clob_get_open_orders,
     post_order,
 )
-from .constants import DEFAULT_COSIGNER
+from .constants import (
+    COLLATERAL_OFFRAMP,
+    COLLATERAL_ONRAMP,
+    DEFAULT_COSIGNER,
+    POLY_USD,
+    USDC,
+)
 from .cosigner import build_l2_headers, send_via_cosigner
-from .eip712 import create_signed_order
+from .eip712 import create_signed_order, create_signed_order_v2
 from .onboarding import (
     check_approvals as check_approvals_onchain,
     check_balance as check_balance_onchain,
@@ -24,6 +31,7 @@ from .onboarding import (
     derive_funder_address,
     detect_wallet_type,
     is_safe_deployed,
+    set_approvals as set_approvals_onchain,
 )
 from .signer import NormalizedSigner, normalize_signer
 from .sqlite_backend import TradingSqliteBackend
@@ -31,6 +39,7 @@ from .types import (
     ApprovalStatus,
     BalanceInfo,
     CancelResult,
+    ExchangeVersion,
     GeneratedWallet,
     HistoryParams,
     LinkResult,
@@ -61,6 +70,7 @@ class PolyNodeTrader:
         self._default_sig_type = c.default_signature_type
         self._rpc_url = c.rpc_url
         self._builder_credentials = c.builder_credentials
+        self._exchange_version = c.exchange_version
 
         self._db: TradingSqliteBackend | None = None
         self._active_signer: NormalizedSigner | None = None
@@ -123,7 +133,7 @@ class PolyNodeTrader:
         # Check approvals
         if sig_type in (SignatureType.POLY_GNOSIS_SAFE, SignatureType.EOA) and not approvals_set:
             try:
-                approval_status = await check_approvals_onchain(funder, self._rpc_url)
+                approval_status = await check_approvals_onchain(funder, self._rpc_url, self._exchange_version)
                 if approval_status.all_approved:
                     approvals_set = True
                     actions.append("approvals_already_set")
@@ -134,7 +144,7 @@ class PolyNodeTrader:
 
         # Create CLOB credentials
         if not stored:
-            creds = await create_clob_credentials(normalized, funder)
+            creds = await create_clob_credentials(normalized, funder, self._exchange_version)
             stored = StoredCredentials(
                 wallet_address=normalized.address,
                 funder_address=funder,
@@ -195,7 +205,7 @@ class PolyNodeTrader:
                 "apiPassphrase": existing.api_passphrase,
             }
         else:
-            creds_dict = await create_clob_credentials(normalized, funder)
+            creds_dict = await create_clob_credentials(normalized, funder, self._exchange_version)
 
         db.upsert_credentials(StoredCredentials(
             wallet_address=normalized.address,
@@ -326,34 +336,223 @@ class PolyNodeTrader:
 
     async def check_approvals(self, wallet: str | None = None) -> ApprovalStatus:
         creds = self._get_stored_creds(wallet)
-        return await check_approvals_onchain(creds.funder_address or creds.wallet_address, self._rpc_url)
+        return await check_approvals_onchain(creds.funder_address or creds.wallet_address, self._rpc_url, self._exchange_version)
 
     async def check_balance(self, wallet: str | None = None) -> BalanceInfo:
         creds = self._get_stored_creds(wallet)
         return await check_balance_onchain(creds.funder_address or creds.wallet_address, self._rpc_url)
 
+    # ── PolyUSD Wrap / Unwrap ──
+
+    async def wrap_to_polyusd(self, amount: int) -> str:
+        """Wrap USDC.e into PolyUSD via the Collateral Onramp.
+
+        Args:
+            amount: Amount in raw units (6 decimals, e.g. 1_000_000 = $1).
+
+        Returns:
+            Transaction hash as a hex string.
+        """
+        try:
+            from web3 import Web3
+            from eth_account import Account
+        except ImportError:
+            raise ImportError("web3 required. Install with: pip install polynode[trading]")
+
+        signer = self._require_signer()
+        creds = self._get_stored_creds()
+        funder = creds.funder_address or creds.wallet_address
+
+        w3 = Web3(Web3.HTTPProvider(self._rpc_url))
+
+        erc20_abi = [
+            {"inputs": [{"name": "spender", "type": "address"}, {"name": "amount", "type": "uint256"}], "name": "approve", "outputs": [{"name": "", "type": "bool"}], "stateMutability": "nonpayable", "type": "function"},
+            {"inputs": [{"name": "owner", "type": "address"}, {"name": "spender", "type": "address"}], "name": "allowance", "outputs": [{"name": "", "type": "uint256"}], "stateMutability": "view", "type": "function"},
+        ]
+
+        usdc_contract = w3.eth.contract(address=Web3.to_checksum_address(USDC), abi=erc20_abi)
+        onramp_addr = Web3.to_checksum_address(COLLATERAL_ONRAMP)
+        signer_addr = Web3.to_checksum_address(signer.address)
+
+        # Build account from the signer's private key (requires sign_message support)
+        # For private-key signers, we can reconstruct the account
+        if not signer._private_key:
+            raise RuntimeError("wrap_to_polyusd requires a private key signer (not RouterSigner)")
+
+        nonce = w3.eth.get_transaction_count(signer_addr)
+
+        # Step 1: Check and set USDC.e allowance for Onramp
+        allowance = usdc_contract.functions.allowance(signer_addr, onramp_addr).call()
+        if allowance < amount:
+            max_uint = 2**256 - 1
+            tx = usdc_contract.functions.approve(onramp_addr, max_uint).build_transaction({
+                "from": signer_addr,
+                "nonce": nonce,
+                "chainId": 137,
+            })
+            signed = w3.eth.account.sign_transaction(tx, signer._private_key)
+            w3.eth.send_raw_transaction(signed.raw_transaction)
+            nonce += 1
+
+        # Step 2: Call wrap(address token, address funder, uint256 amount) on Onramp
+        # wrap selector: 0x62355638
+        wrap_abi = [
+            {"inputs": [{"name": "token", "type": "address"}, {"name": "funder", "type": "address"}, {"name": "amount", "type": "uint256"}], "name": "wrap", "outputs": [], "stateMutability": "nonpayable", "type": "function"},
+        ]
+        onramp_contract = w3.eth.contract(address=onramp_addr, abi=wrap_abi)
+        tx = onramp_contract.functions.wrap(
+            Web3.to_checksum_address(USDC),
+            Web3.to_checksum_address(funder),
+            amount,
+        ).build_transaction({
+            "from": signer_addr,
+            "nonce": nonce,
+            "chainId": 137,
+        })
+        signed = w3.eth.account.sign_transaction(tx, signer._private_key)
+        tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+        return tx_hash.hex()
+
+    async def unwrap_from_polyusd(self, amount: int) -> str:
+        """Unwrap PolyUSD back into USDC.e via the Collateral Offramp.
+
+        Args:
+            amount: Amount in raw units (6 decimals, e.g. 1_000_000 = $1).
+
+        Returns:
+            Transaction hash as a hex string.
+        """
+        try:
+            from web3 import Web3
+        except ImportError:
+            raise ImportError("web3 required. Install with: pip install polynode[trading]")
+
+        signer = self._require_signer()
+        creds = self._get_stored_creds()
+        funder = creds.funder_address or creds.wallet_address
+
+        w3 = Web3(Web3.HTTPProvider(self._rpc_url))
+
+        if not signer._private_key:
+            raise RuntimeError("unwrap_from_polyusd requires a private key signer (not RouterSigner)")
+
+        signer_addr = Web3.to_checksum_address(signer.address)
+        offramp_addr = Web3.to_checksum_address(COLLATERAL_OFFRAMP)
+
+        # Check and set PolyUSD allowance for Offramp
+        erc20_abi = [
+            {"inputs": [{"name": "spender", "type": "address"}, {"name": "amount", "type": "uint256"}], "name": "approve", "outputs": [{"name": "", "type": "bool"}], "stateMutability": "nonpayable", "type": "function"},
+            {"inputs": [{"name": "owner", "type": "address"}, {"name": "spender", "type": "address"}], "name": "allowance", "outputs": [{"name": "", "type": "uint256"}], "stateMutability": "view", "type": "function"},
+        ]
+        polyusd_contract = w3.eth.contract(address=Web3.to_checksum_address(POLY_USD), abi=erc20_abi)
+
+        nonce = w3.eth.get_transaction_count(signer_addr)
+
+        allowance = polyusd_contract.functions.allowance(signer_addr, offramp_addr).call()
+        if allowance < amount:
+            max_uint = 2**256 - 1
+            tx = polyusd_contract.functions.approve(offramp_addr, max_uint).build_transaction({
+                "from": signer_addr,
+                "nonce": nonce,
+                "chainId": 137,
+            })
+            signed = w3.eth.account.sign_transaction(tx, signer._private_key)
+            w3.eth.send_raw_transaction(signed.raw_transaction)
+            nonce += 1
+
+        # Call unwrap(address token, address receiver, uint256 amount) on Offramp
+        unwrap_abi = [
+            {"inputs": [{"name": "token", "type": "address"}, {"name": "receiver", "type": "address"}, {"name": "amount", "type": "uint256"}], "name": "unwrap", "outputs": [], "stateMutability": "nonpayable", "type": "function"},
+        ]
+        offramp_contract = w3.eth.contract(address=offramp_addr, abi=unwrap_abi)
+        tx = offramp_contract.functions.unwrap(
+            Web3.to_checksum_address(USDC),
+            Web3.to_checksum_address(funder),
+            amount,
+        ).build_transaction({
+            "from": signer_addr,
+            "nonce": nonce,
+            "chainId": 137,
+        })
+        signed = w3.eth.account.sign_transaction(tx, signer._private_key)
+        tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
+        return tx_hash.hex()
+
+    def get_polyusd_balance(self) -> int:
+        """Get PolyUSD balance for the active funder address.
+
+        Returns:
+            Balance in raw units (6 decimals).
+        """
+        try:
+            from web3 import Web3
+        except ImportError:
+            raise ImportError("web3 required. Install with: pip install polynode[trading]")
+
+        creds = self._get_stored_creds()
+        funder = creds.funder_address or creds.wallet_address
+
+        w3 = Web3(Web3.HTTPProvider(self._rpc_url))
+        erc20_abi = [{"inputs": [{"name": "account", "type": "address"}], "name": "balanceOf", "outputs": [{"name": "", "type": "uint256"}], "stateMutability": "view", "type": "function"}]
+        contract = w3.eth.contract(address=Web3.to_checksum_address(POLY_USD), abi=erc20_abi)
+        return contract.functions.balanceOf(Web3.to_checksum_address(funder)).call()
+
+    def get_usdce_balance(self) -> int:
+        """Get USDC.e balance for the active funder address.
+
+        Returns:
+            Balance in raw units (6 decimals).
+        """
+        try:
+            from web3 import Web3
+        except ImportError:
+            raise ImportError("web3 required. Install with: pip install polynode[trading]")
+
+        creds = self._get_stored_creds()
+        funder = creds.funder_address or creds.wallet_address
+
+        w3 = Web3(Web3.HTTPProvider(self._rpc_url))
+        erc20_abi = [{"inputs": [{"name": "account", "type": "address"}], "name": "balanceOf", "outputs": [{"name": "", "type": "uint256"}], "stateMutability": "view", "type": "function"}]
+        contract = w3.eth.contract(address=Web3.to_checksum_address(USDC), abi=erc20_abi)
+        return contract.functions.balanceOf(Web3.to_checksum_address(funder)).call()
+
     # ── Trading ──
 
     async def order(self, params: OrderParams) -> OrderResult:
-        """Place an order on Polymarket."""
+        """Place an order on Polymarket. Routes to V1 or V2 CLOB based on exchange_version."""
         creds = self._get_stored_creds()
         signer = self._require_signer()
         meta = await self._fetch_meta(params.token_id)
-
-        signed_order = await create_signed_order(
-            signer.sign_typed_data,
-            signer_address=signer.address,
-            funder_address=creds.funder_address or creds.wallet_address,
-            token_id=params.token_id,
-            price=params.price,
-            size=params.size,
-            side=params.side,
-            signature_type=creds.signature_type,
-            tick_size=meta.tick_size,
-            neg_risk=meta.neg_risk,
-            fee_rate_bps=meta.fee_rate_bps,
-            expiration=params.expiration or 0,
-        )
+        clob_host = _clob_host(self._exchange_version)
+
+        if self._exchange_version == ExchangeVersion.V2:
+            signed_order = await create_signed_order_v2(
+                signer.sign_typed_data,
+                signer_address=signer.address,
+                funder_address=creds.funder_address or creds.wallet_address,
+                token_id=params.token_id,
+                price=params.price,
+                size=params.size,
+                side=params.side,
+                signature_type=creds.signature_type,
+                tick_size=meta.tick_size,
+                neg_risk=meta.neg_risk,
+            )
+        else:
+            signed_order = await create_signed_order(
+                signer.sign_typed_data,
+                signer_address=signer.address,
+                funder_address=creds.funder_address or creds.wallet_address,
+                token_id=params.token_id,
+                price=params.price,
+                size=params.size,
+                side=params.side,
+                signature_type=creds.signature_type,
+                tick_size=meta.tick_size,
+                neg_risk=meta.neg_risk,
+                fee_rate_bps=meta.fee_rate_bps,
+                expiration=params.expiration or 0,
+            )
 
         payload = {
             "order": signed_order,
@@ -384,6 +583,7 @@ class PolyNodeTrader:
             self._cosigner_url, self._polynode_key, self._fallback_direct,
             {"method": "POST", "path": "/order", "body": body_str, "headers": headers},
             builder_credentials=self._builder_credentials,
+            clob_host=clob_host,
         )
 
         order_id = result.get("orderID") or result.get("orderId")
@@ -407,11 +607,13 @@ class PolyNodeTrader:
 
     async def cancel_order(self, order_id: str) -> CancelResult:
         creds = self._get_stored_creds()
+        clob_host = _clob_host(self._exchange_version)
         result = await clob_cancel_order(
             self._cosigner_url, self._polynode_key, self._fallback_direct,
             {"apiKey": creds.api_key, "apiSecret": creds.api_secret, "apiPassphrase": creds.api_passphrase},
             creds.wallet_address, order_id,
             builder_credentials=self._builder_credentials,
+            clob_host=clob_host,
         )
         return CancelResult(
             canceled=result.get("canceled", []),
@@ -420,11 +622,13 @@ class PolyNodeTrader:
 
     async def cancel_all(self, market: str | None = None) -> CancelResult:
         creds = self._get_stored_creds()
+        clob_host = _clob_host(self._exchange_version)
         result = await cancel_all_orders(
             self._cosigner_url, self._polynode_key, self._fallback_direct,
             {"apiKey": creds.api_key, "apiSecret": creds.api_secret, "apiPassphrase": creds.api_passphrase},
             creds.wallet_address, market,
             builder_credentials=self._builder_credentials,
+            clob_host=clob_host,
         )
         return CancelResult(
             canceled=result.get("canceled", []),
@@ -435,11 +639,13 @@ class PolyNodeTrader:
         self, *, market: str | None = None, asset_id: str | None = None
     ) -> list[OpenOrder]:
         creds = self._get_stored_creds()
+        clob_host = _clob_host(self._exchange_version)
         result = await clob_get_open_orders(
             self._cosigner_url, self._polynode_key, self._fallback_direct,
             {"apiKey": creds.api_key, "apiSecret": creds.api_secret, "apiPassphrase": creds.api_passphrase},
             creds.wallet_address, market, asset_id,
             builder_credentials=self._builder_credentials,
+            clob_host=clob_host,
         )
         return [
             OpenOrder(
@@ -467,7 +673,10 @@ class PolyNodeTrader:
             return cached
 
         import asyncio
-        tick, neg = await asyncio.gather(fetch_tick_size(token_id), fetch_neg_risk(token_id))
+        tick, neg = await asyncio.gather(
+            fetch_tick_size(token_id, self._exchange_version),
+            fetch_neg_risk(token_id, self._exchange_version),
+        )
         meta = MarketMeta(
             token_id=token_id,
             tick_size=tick,

polynode/trading/types.py

@@ -13,6 +13,11 @@ class SignatureType(IntEnum):
     POLY_GNOSIS_SAFE = 2
 
 
+class ExchangeVersion(IntEnum):
+    V1 = 1
+    V2 = 2
+
+
 @runtime_checkable
 class RouterSigner(Protocol):
     async def get_address(self) -> str: ...
@@ -50,6 +55,7 @@ class TraderConfig:
     default_signature_type: SignatureType = SignatureType.POLY_GNOSIS_SAFE
     rpc_url: str = "https://polygon-bor-rpc.publicnode.com"
     builder_credentials: BuilderCredentials | None = None
+    exchange_version: ExchangeVersion = ExchangeVersion.V1
 
 
 @dataclass

{polynode-0.6.3.dist-info → polynode-0.7.0.dist-info}/METADATA

@@ -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.dist-info → polynode-0.7.0.dist-info}/RECORD

@@ -11,18 +11,18 @@ polynode/subscription.py,sha256=O2yKfdllI0px-1qrVK-0Qq9S4KUmIiXjjYCNC7QW0jM,4121
 polynode/testing.py,sha256=bSSgV18ZSaRoLZPlNRCCLmRNwNIQDS35qi7NhuTg8Bg,2802
 polynode/ws.py,sha256=VZdn2dkUJH2-CYBu_L45YnvCU0kQejxHcy2Ji2pRu60,9653
 polynode/cache/__init__.py,sha256=A9lXcIE3ISKKo1r0o3o-CkmQpBhLdKwdQfCR0eW5i9o,519
-polynode/trading/__init__.py,sha256=grC3dembNNSuRzgbOHC6nJZ6YEfj5iDdh4n-H0bJnNo,883
-polynode/trading/clob_api.py,sha256=X_07Zp__GxG0_pkGtaKnNju9f6lw5dTOkEg8fM0WJ9M,4628
-polynode/trading/constants.py,sha256=q_QTi1w8XVw-6PRNltP9hinE4PUH0GFGgKNbkEyMdR4,1200
-polynode/trading/cosigner.py,sha256=aQGbKVNWp3VaEBZNoStcsj4goWKILOyOnGuFjT1RkRQ,2902
-polynode/trading/eip712.py,sha256=ekD0l0wocVl-OQiBOuLEENyZP89_KqDA0QtjNg5HiEg,4796
-polynode/trading/onboarding.py,sha256=UgPLP9WJcETzGXUrP7zrBUUe5dHBxWhFZMI6e3dM7A4,9933
+polynode/trading/__init__.py,sha256=0mtvY4w2k1x000YOX7_ua9JZj4CY27Cz7p0u6L3Hfrw,906
+polynode/trading/clob_api.py,sha256=ygaOoMIg4PGtMzNBT70wk4XrSbVX0EyCCU6PmXK3xrs,5308
+polynode/trading/constants.py,sha256=CjHcfaOTzPFvlorY4XeyGtMS8XNKH4jjoxqKtpN6NmY,1782
+polynode/trading/cosigner.py,sha256=Fww9OgaKdHQAHd8Kom1AJBtmMGC8FbNZxdFaFALNBY8,3058
+polynode/trading/eip712.py,sha256=pZf0Pf4DDIPpK4qbz4DWfcdOeU8PlCQhJPpKSQ97pC4,9553
+polynode/trading/onboarding.py,sha256=ouP9bzioFHCt4fnluAXLWL8O8U6d_1ePeu5JmBXeDyc,13768
 polynode/trading/position_management.py,sha256=z2pYls4ErhyRE6thQdOs45BF4llKvKNNruQgcMEFT_U,3827
 polynode/trading/privy.py,sha256=iiUQZsBqjj29C7oUiFFktoT2muZY06bcMzABKstFKqE,4523
-polynode/trading/signer.py,sha256=5KTARp6BnSorRt6n3YB11wpmivX_zOhVm-jzn098iAA,3298
+polynode/trading/signer.py,sha256=piifRquwnwFwrKLL24jsRQYMh_cdkz8wNz99Vx8_KTY,3413
 polynode/trading/sqlite_backend.py,sha256=9ho7DnQVE_nJqmPH5yPSAYcVjVmTS1XmD3NebR-UAwA,7986
-polynode/trading/trader.py,sha256=_zZhHrCGd33SCy6DAnCzN4sA4BYz_t08HZ89JcbDJyM,19970
-polynode/trading/types.py,sha256=W42iikSyQ6NZ4xAnxQ4mELbSKJflzN-tkbTQT3_y6tM,4829
+polynode/trading/trader.py,sha256=VVNQ_DEkum5u3IC2M5IfLml7s06A7fCqjGXvSX3ayCg,29497
+polynode/trading/types.py,sha256=WGSH25c1LIZax4KNPavHz0G6HEPLUK9ak9VnEYd8fxM,4944
 polynode/types/__init__.py,sha256=0v_CByqG-zT1xucbT2So_77YDmsPj9u956at94nyrLM,280
 polynode/types/enums.py,sha256=2cx9l10A-LUeDNBJZn7l0XBTka2YfxRQcXW0s7s3_4k,1082
 polynode/types/events.py,sha256=MJGZqxBFKfT1y44dZ96bHbwvoPpGvtutBwYE6OTT6nU,6880
@@ -30,6 +30,6 @@ polynode/types/orderbook.py,sha256=MwD6P3poo3F70bONUZ5i3ajk1sgw39hHTOw6D0fP5_8,1
 polynode/types/rest.py,sha256=ftJKQZH0wBrR_l199rDMqnVS8cyt8YnCvo9cKIsTcCw,7012
 polynode/types/short_form.py,sha256=xfGklDi587u6K2aXaRWiwbxqkipW8BiEPeNIDT45v2Y,799
 polynode/types/ws.py,sha256=EzE9Vzrb6cILemfssmnqM8fbHt4USn3latpUHKatwk4,994
-polynode-0.6.3.dist-info/METADATA,sha256=Faq2Cb3B797tpO1snnRm9xWtx5de9mGEPMwIDfmZDhc,3302
-polynode-0.6.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-polynode-0.6.3.dist-info/RECORD,,
+polynode-0.7.0.dist-info/METADATA,sha256=qIF1aMlx-nQAUySzKpoqj3y9Mx66vRNnG4Cuuwvbt0Q,3302
+polynode-0.7.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+polynode-0.7.0.dist-info/RECORD,,