polynode 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

polynode/_version.py

@@ -1 +1 @@
-__version__ = "0.9.0"
+__version__ = "0.9.1"

polynode/trading/constants.py

@@ -54,7 +54,10 @@ COLLATERAL_ONRAMP = "0x93070a847efef7f70739046a929d47a521f5b8ee"
 COLLATERAL_OFFRAMP = "0x2957922eb93258b93368531d39facca3b4dc5854"
 
 # Fee Escrow
+# V1 (USDC.e collateral, paired with the V1 CLOB)
 FEE_ESCROW_ADDRESS = "0xa11D28433B79D0A88F3119b16A090075752258EA"
+# V2 (pUSD collateral, paired with the V2 CLOB). Deployed 2026-04-24.
+FEE_ESCROW_ADDRESS_V2 = "0x3A43D88ef8Aae4dF5a50B3abf67122CAAeEF7c9F"
 
 # Metadata cache TTL (5 minutes)
 META_TTL_SECONDS = 300

polynode/trading/escrow.py

@@ -14,10 +14,15 @@ from typing import Any
 
 import httpx
 
-from .constants import CHAIN_ID, FEE_ESCROW_ADDRESS
-from .types import Eip712Payload
+from .constants import CHAIN_ID, FEE_ESCROW_ADDRESS, FEE_ESCROW_ADDRESS_V2
+from .types import Eip712Payload, ExchangeVersion
 
 # ── EIP-712 Types ──
+#
+# Both V1 and V2 FeeEscrow share the same FeeAuth struct typehash. They differ only in
+# the EIP-712 domain: V1 is ("PolyNodeFeeEscrow", "1", V1 contract); V2 is
+# ("PolyNodeFeeEscrowV2", "2", V2 contract). Signing against the wrong domain produces
+# a digest the contract won't accept — `pullFee` reverts with `InvalidSignature`.
 
 FEE_AUTH_DOMAIN = {
     "name": "PolyNodeFeeEscrow",
@@ -26,6 +31,13 @@ FEE_AUTH_DOMAIN = {
     "verifyingContract": FEE_ESCROW_ADDRESS,
 }
 
+FEE_AUTH_DOMAIN_V2 = {
+    "name": "PolyNodeFeeEscrowV2",
+    "version": "2",
+    "chainId": CHAIN_ID,
+    "verifyingContract": FEE_ESCROW_ADDRESS_V2,
+}
+
 FEE_AUTH_TYPES = {
     "FeeAuth": [
         {"name": "orderId", "type": "bytes32"},
@@ -40,6 +52,16 @@ FEE_AUTH_TYPES = {
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 
 
+def fee_auth_domain_for(version: ExchangeVersion) -> dict:
+    """Return the EIP-712 FeeAuth domain for a given exchange version."""
+    return FEE_AUTH_DOMAIN_V2 if version == ExchangeVersion.V2 else FEE_AUTH_DOMAIN
+
+
+def fee_escrow_address_for(version: ExchangeVersion) -> str:
+    """Return the FeeEscrow contract address for a given exchange version."""
+    return FEE_ESCROW_ADDRESS_V2 if version == ExchangeVersion.V2 else FEE_ESCROW_ADDRESS
+
+
 # ── Fee Calculation ──
 
 def calculate_fee(price: float, size: float, fee_bps: int) -> int:
@@ -67,8 +89,17 @@ def generate_escrow_order_id() -> str:
 
 # ── 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."""
+async def fetch_escrow_nonce(
+    rpc_url: str,
+    signer_address: str,
+    escrow_address: str = FEE_ESCROW_ADDRESS,
+) -> int:
+    """Fetch the current nonce for a signer from a FeeEscrow contract via eth_call.
+
+    Pass `fee_escrow_address_for(exchange_version)` for the `escrow_address` argument
+    when the caller's exchange version is known (V2 customers must read nonces from
+    the V2 contract — nonces on V1 and V2 are tracked independently).
+    """
     # getNonce(address) selector = 0x2d0335ab
     addr = signer_address.lower().replace("0x", "").zfill(64)
     data = "0x2d0335ab" + addr
@@ -80,7 +111,7 @@ async def fetch_escrow_nonce(rpc_url: str, signer_address: str) -> int:
                 "jsonrpc": "2.0",
                 "id": 1,
                 "method": "eth_call",
-                "params": [{"to": FEE_ESCROW_ADDRESS, "data": data}, "latest"],
+                "params": [{"to": escrow_address, "data": data}, "latest"],
             },
         )
         result = resp.json()
@@ -103,6 +134,9 @@ class FeeAuthRequest:
     signature: str
     affiliate: str
     affiliate_share_bps: int
+    # V2-routing hint for the cosigner. Set when exchange_version == V2 so the
+    # cosigner picks the V2 operator; absent for V1 (preserves backwards compat).
+    escrow_contract: str | None = None
 
 
 async def sign_fee_auth(
@@ -116,19 +150,22 @@ async def sign_fee_auth(
     nonce: int,
     affiliate: str | None = None,
     affiliate_share_bps: int | None = None,
+    exchange_version: ExchangeVersion = ExchangeVersion.V1,
 ) -> 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).
+        payer: Safe wallet address (where collateral is pulled from — USDC.e on V1, pUSD on V2).
         signer_address: EOA address (signs the message).
-        fee_amount: Fee in raw USDC (6 decimals).
+        fee_amount: Fee in raw collateral units (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.
+        exchange_version: V1 (default, USDC.e) or V2 (pUSD). Selects the EIP-712 domain
+            and the escrow contract address the cosigner should route to.
 
     Returns:
         FeeAuthRequest ready for the cosigner.
@@ -143,7 +180,7 @@ async def sign_fee_auth(
     }
 
     payload = Eip712Payload(
-        domain=FEE_AUTH_DOMAIN,
+        domain=fee_auth_domain_for(exchange_version),
         types=FEE_AUTH_TYPES,
         primary_type="FeeAuth",
         message=message,
@@ -153,6 +190,10 @@ async def sign_fee_auth(
     if not signature.startswith("0x"):
         signature = f"0x{signature}"
 
+    escrow_contract = (
+        FEE_ESCROW_ADDRESS_V2 if exchange_version == ExchangeVersion.V2 else None
+    )
+
     return FeeAuthRequest(
         escrow_order_id=escrow_order_id,
         payer=payer,
@@ -163,4 +204,5 @@ async def sign_fee_auth(
         signature=signature,
         affiliate=affiliate or ZERO_ADDRESS,
         affiliate_share_bps=affiliate_share_bps if affiliate_share_bps is not None else 10000,
+        escrow_contract=escrow_contract,
     )

polynode/trading/onboarding.py

@@ -29,6 +29,7 @@ from .constants import (
     USDC,
     V2_SPENDERS,
     FEE_ESCROW_ADDRESS,
+    FEE_ESCROW_ADDRESS_V2,
 )
 from .types import ApprovalStatus, BalanceInfo, ExchangeVersion, SignatureType
 
@@ -189,9 +190,16 @@ async def check_approvals(
         approved = ctf_contract.functions.isApprovedForAll(funder, spender_addr).call()
         ctf_status[name] = approved
 
-    # Fee Escrow USDC approval (always USDC.e regardless of exchange version)
-    usdc_contract = w3.eth.contract(address=Web3.to_checksum_address(USDC), abi=erc20_abi)
-    escrow_allowance = usdc_contract.functions.allowance(funder, Web3.to_checksum_address(FEE_ESCROW_ADDRESS)).call()
+    # Fee Escrow approval. V1 approves USDC.e for the V1 contract; V2 approves pUSD
+    # for the V2 contract. pullFee fails with `TransferFailed` if the approval is
+    # missing on the version the caller's orders are routed to.
+    if version == ExchangeVersion.V2:
+        escrow_token_contract = w3.eth.contract(address=Web3.to_checksum_address(POLY_USD), abi=erc20_abi)
+        escrow_addr = Web3.to_checksum_address(FEE_ESCROW_ADDRESS_V2)
+    else:
+        escrow_token_contract = w3.eth.contract(address=Web3.to_checksum_address(USDC), abi=erc20_abi)
+        escrow_addr = Web3.to_checksum_address(FEE_ESCROW_ADDRESS)
+    escrow_allowance = escrow_token_contract.functions.allowance(funder, escrow_addr).call()
     usdc_status["fee_escrow"] = escrow_allowance >= threshold
 
     all_approved = all(usdc_status.values()) and all(ctf_status.values())
@@ -273,9 +281,16 @@ async def set_approvals(
         tx_hashes.append(tx_hash.hex())
         nonce += 1
 
-    # Fee Escrow USDC approval (always USDC.e regardless of exchange version)
-    escrow_contract = w3.eth.contract(address=Web3.to_checksum_address(USDC), abi=erc20_abi)
-    tx = escrow_contract.functions.approve(Web3.to_checksum_address(FEE_ESCROW_ADDRESS), max_uint).build_transaction({
+    # Fee Escrow collateral approval — V1 approves USDC.e for V1 FeeEscrow;
+    # V2 approves pUSD for V2 FeeEscrow.
+    if version == ExchangeVersion.V2:
+        escrow_token = POLY_USD
+        escrow_target = FEE_ESCROW_ADDRESS_V2
+    else:
+        escrow_token = USDC
+        escrow_target = FEE_ESCROW_ADDRESS
+    escrow_token_contract = w3.eth.contract(address=Web3.to_checksum_address(escrow_token), abi=erc20_abi)
+    tx = escrow_token_contract.functions.approve(Web3.to_checksum_address(escrow_target), max_uint).build_transaction({
         "from": account.address,
         "nonce": nonce,
         "chainId": CHAIN_ID,

polynode/trading/relayer.py

@@ -0,0 +1,303 @@
+"""Polymarket builder-relayer client (Python port).
+
+Ports the minimum needed from @polymarket/builder-relayer-client +
+@polymarket/builder-signing-sdk to submit gasless Safe transactions.
+
+Flow:
+  1. GET  {relayer}/nonce?address={eoa}&type=SAFE           → next SafeTx nonce
+  2. Build multisend (if >1 tx) or single tx
+  3. EIP-712 hash SafeTx(domain={chainId, verifyingContract=safe}, types, msg)
+  4. EIP-191 personal_sign the hash with EOA private key
+  5. Pack r||s||v (v adjusted by +4 for Gnosis)
+  6. POST {relayer}/submit with builder HMAC headers
+  7. Poll {relayer}/transaction?id=... until STATE_MINED / STATE_CONFIRMED
+"""
+from __future__ import annotations
+
+import asyncio
+import base64
+import hashlib
+import hmac
+import json
+import time
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from .constants import CHAIN_ID, RELAYER_HOST, SAFE_FACTORY, SAFE_MULTISEND
+from .onboarding import derive_safe_address
+
+
+@dataclass
+class BuilderCreds:
+    key: str
+    secret: str
+    passphrase: str
+
+
+ZERO_ADDR = "0x" + "0" * 40
+
+
+# ── EIP-712 helpers ──
+
+def _keccak(data: bytes) -> bytes:
+    from eth_utils import keccak as _k
+    return _k(data)
+
+
+# Compute once on module load
+def _safe_tx_type_hash() -> bytes:
+    return _keccak(
+        b"SafeTx(address to,uint256 value,bytes data,uint8 operation,"
+        b"uint256 safeTxGas,uint256 baseGas,uint256 gasPrice,address gasToken,"
+        b"address refundReceiver,uint256 nonce)"
+    )
+
+
+def _domain_type_hash() -> bytes:
+    return _keccak(b"EIP712Domain(uint256 chainId,address verifyingContract)")
+
+
+def _pad32(h: bytes) -> bytes:
+    return h if len(h) == 32 else (b"\x00" * (32 - len(h))) + h
+
+
+def _encode_address(addr: str) -> bytes:
+    return _pad32(bytes.fromhex(addr.lower().removeprefix("0x")))
+
+
+def _encode_uint256(n: int) -> bytes:
+    return int(n).to_bytes(32, "big", signed=False)
+
+
+def _domain_separator(chain_id: int, verifying_contract: str) -> bytes:
+    return _keccak(
+        _domain_type_hash() + _encode_uint256(chain_id) + _encode_address(verifying_contract)
+    )
+
+
+def _safe_tx_struct_hash(
+    to: str, value: int, data: bytes, operation: int,
+    safe_tx_gas: int, base_gas: int, gas_price: int,
+    gas_token: str, refund_receiver: str, nonce: int,
+) -> bytes:
+    data_hash = _keccak(data)
+    encoded = (
+        _safe_tx_type_hash()
+        + _encode_address(to)
+        + _encode_uint256(value)
+        + data_hash
+        + _encode_uint256(operation)
+        + _encode_uint256(safe_tx_gas)
+        + _encode_uint256(base_gas)
+        + _encode_uint256(gas_price)
+        + _encode_address(gas_token)
+        + _encode_address(refund_receiver)
+        + _encode_uint256(nonce)
+    )
+    return _keccak(encoded)
+
+
+def _eip712_digest(chain_id: int, safe_addr: str, struct_hash: bytes) -> bytes:
+    domain_sep = _domain_separator(chain_id, safe_addr)
+    return _keccak(b"\x19\x01" + domain_sep + struct_hash)
+
+
+# ── Safe multisend encoding ──
+
+def _encode_multisend(txns: list[dict[str, Any]]) -> bytes:
+    """Encode txns into the multiSend bytes arg.
+    Each tx packed as: uint8 operation | address to | uint256 value | uint256 dataLen | bytes data
+    """
+    parts: list[bytes] = []
+    for tx in txns:
+        op = int(tx.get("operation", 0))
+        to = tx["to"]
+        value = int(tx.get("value", 0))
+        data = tx["data"]
+        if isinstance(data, str):
+            data_bytes = bytes.fromhex(data.removeprefix("0x"))
+        else:
+            data_bytes = data
+        parts.append(
+            op.to_bytes(1, "big")
+            + bytes.fromhex(to.lower().removeprefix("0x"))
+            + value.to_bytes(32, "big")
+            + len(data_bytes).to_bytes(32, "big")
+            + data_bytes
+        )
+    return b"".join(parts)
+
+
+def _encode_multisend_calldata(txns: list[dict[str, Any]]) -> str:
+    """Wrap encoded txns in multiSend(bytes) ABI call."""
+    # multiSend(bytes) selector = keccak256("multiSend(bytes)")[:4] = 0x8d80ff0a
+    inner = _encode_multisend(txns)
+    # ABI-encode single `bytes` arg: offset(32) + length(32) + data (padded to 32)
+    padded_len = ((len(inner) + 31) // 32) * 32
+    padded = inner + b"\x00" * (padded_len - len(inner))
+    encoded = (
+        bytes.fromhex("8d80ff0a")
+        + _encode_uint256(32)   # offset to bytes arg
+        + _encode_uint256(len(inner))
+        + padded
+    )
+    return "0x" + encoded.hex()
+
+
+# ── Builder HMAC ──
+
+def _build_hmac_headers(creds: BuilderCreds, method: str, path: str, body: str | None = None) -> dict[str, str]:
+    timestamp = str(int(time.time()))
+    message = timestamp + method + path + (body or "")
+    # Secret may be url-safe base64 (`-` / `_`); normalize before decoding.
+    secret_norm = creds.secret.replace("-", "+").replace("_", "/")
+    key_bytes = base64.b64decode(secret_norm)
+    mac = hmac.new(key_bytes, message.encode(), hashlib.sha256).digest()
+    sig = base64.b64encode(mac).decode().replace("+", "-").replace("/", "_")
+    return {
+        "POLY_BUILDER_API_KEY": creds.key,
+        "POLY_BUILDER_PASSPHRASE": creds.passphrase,
+        "POLY_BUILDER_SIGNATURE": sig,
+        "POLY_BUILDER_TIMESTAMP": timestamp,
+    }
+
+
+# ── Signature packing ──
+
+def _pack_sig(sig_hex: str) -> str:
+    """Split 65-byte sig into r||s||v with Gnosis v-adjustment (+4)."""
+    raw = bytes.fromhex(sig_hex.removeprefix("0x"))
+    assert len(raw) == 65, f"expected 65-byte sig, got {len(raw)}"
+    r, s, v = raw[:32], raw[32:64], raw[64]
+    # Adjust v: 0/1 → 31/32, 27/28 → 31/32 (eth_sign variant per Gnosis spec)
+    if v in (0, 1):
+        v += 31
+    elif v in (27, 28):
+        v += 4
+    else:
+        raise ValueError(f"invalid sig v byte: {v}")
+    return "0x" + (r + s + v.to_bytes(1, "big")).hex()
+
+
+# ── RelayClient ──
+
+class RelayClient:
+    """Minimal Polymarket relayer client for Safe transactions."""
+
+    def __init__(self, builder_creds: BuilderCreds, relayer_url: str = RELAYER_HOST, chain_id: int = CHAIN_ID):
+        self.relayer_url = relayer_url.rstrip("/")
+        self.chain_id = chain_id
+        self.builder_creds = builder_creds
+
+    async def execute_safe(
+        self,
+        signer_pk: str,
+        eoa_address: str,
+        txns: list[dict[str, Any]],
+    ) -> str:
+        """Build, sign, submit, and wait for a batch of Safe transactions.
+
+        Returns the on-chain transaction hash.
+        """
+        if not txns:
+            raise ValueError("no transactions to execute")
+
+        try:
+            from eth_account import Account
+            from eth_account.messages import encode_defunct
+        except ImportError:
+            raise ImportError("eth-account required for Safe relayer")
+
+        safe_addr = derive_safe_address(eoa_address)
+
+        # 1. Get nonce
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            r = await client.get(
+                f"{self.relayer_url}/nonce",
+                params={"address": eoa_address, "type": "SAFE"},
+            )
+            r.raise_for_status()
+            nonce_payload = r.json()
+            nonce = int(nonce_payload["nonce"])
+
+        # 2. Aggregate (single tx → direct, multi → multisend DelegateCall)
+        if len(txns) == 1:
+            tx = txns[0]
+            to_addr = tx["to"]
+            data = tx["data"]
+            operation = int(tx.get("operation", 0))
+        else:
+            to_addr = SAFE_MULTISEND
+            data = _encode_multisend_calldata(
+                [{**t, "operation": int(t.get("operation", 0))} for t in txns]
+            )
+            operation = 1  # DelegateCall
+
+        # 3. Compute EIP-712 digest
+        data_bytes = bytes.fromhex(data.removeprefix("0x")) if isinstance(data, str) else data
+        struct_hash = _safe_tx_struct_hash(
+            to=to_addr, value=0, data=data_bytes, operation=operation,
+            safe_tx_gas=0, base_gas=0, gas_price=0,
+            gas_token=ZERO_ADDR, refund_receiver=ZERO_ADDR,
+            nonce=nonce,
+        )
+        digest = _eip712_digest(self.chain_id, safe_addr, struct_hash)
+
+        # 4. EIP-191 personal_sign on the digest
+        account = Account.from_key(signer_pk if signer_pk.startswith("0x") else f"0x{signer_pk}")
+        signed = account.sign_message(encode_defunct(primitive=digest))
+        packed_sig = _pack_sig(signed.signature.hex())
+
+        # 5. Build submit payload
+        req = {
+            "from": eoa_address,
+            "to": to_addr,
+            "proxyWallet": safe_addr,
+            "data": data if isinstance(data, str) else "0x" + data.hex(),
+            "nonce": str(nonce),
+            "signature": packed_sig,
+            "signatureParams": {
+                "gasPrice": "0",
+                "operation": str(operation),
+                "safeTxnGas": "0",
+                "baseGas": "0",
+                "gasToken": ZERO_ADDR,
+                "refundReceiver": ZERO_ADDR,
+            },
+            "type": "SAFE",
+            "metadata": "",
+        }
+        body = json.dumps(req, separators=(",", ":"))
+
+        # 6. POST /submit with builder HMAC headers
+        headers = _build_hmac_headers(self.builder_creds, "POST", "/submit", body)
+        headers["Content-Type"] = "application/json"
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            r = await client.post(f"{self.relayer_url}/submit", content=body, headers=headers)
+            if not r.is_success:
+                raise RuntimeError(f"relayer /submit failed: {r.status_code} {r.text}")
+            resp = r.json()
+            tx_id = resp["transactionID"]
+
+        # 7. Poll /transaction until mined
+        for _ in range(30):  # up to 60s
+            await asyncio.sleep(2)
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                r = await client.get(
+                    f"{self.relayer_url}/transaction",
+                    params={"id": tx_id},
+                )
+                if not r.is_success:
+                    continue
+                rows = r.json()
+                if not rows:
+                    continue
+                row = rows[0] if isinstance(rows, list) else rows
+                state = row.get("state")
+                if state in ("STATE_MINED", "STATE_CONFIRMED"):
+                    return row["transactionHash"]
+                if state in ("STATE_FAILED", "STATE_REVERTED"):
+                    raise RuntimeError(f"tx {tx_id} failed on-chain: state={state} hash={row.get('transactionHash')}")
+        raise RuntimeError(f"tx {tx_id} timed out waiting for mined state")

polynode/trading/trader.py

@@ -26,7 +26,7 @@ from .constants import (
 )
 from .cosigner import build_l2_headers, send_via_cosigner
 from .eip712 import create_signed_order, create_signed_order_v2
-from .escrow import calculate_fee, generate_escrow_order_id, fetch_escrow_nonce, sign_fee_auth
+from .escrow import calculate_fee, fee_escrow_address_for, fetch_escrow_nonce, generate_escrow_order_id, sign_fee_auth
 from .onboarding import (
     check_approvals as check_approvals_onchain,
     check_balance as check_balance_onchain,
@@ -420,6 +420,9 @@ class PolyNodeTrader:
     async def wrap_to_polyusd(self, amount: int) -> str:
         """Wrap USDC.e into PolyUSD via the Collateral Onramp.
 
+        Routes through the Polymarket relayer (gasless) for Safe/Proxy wallets,
+        and sends directly for EOA wallets.
+
         Args:
             amount: Amount in raw units (6 decimals, e.g. 1_000_000 = $1).
 
@@ -428,7 +431,6 @@ class PolyNodeTrader:
         """
         try:
             from web3 import Web3
-            from eth_account import Account
         except ImportError:
             raise ImportError("web3 required. Install with: pip install polynode[trading]")
 
@@ -445,42 +447,55 @@ class PolyNodeTrader:
 
         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)
+        funder_addr = Web3.to_checksum_address(funder)
 
-        # 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)")
+        allowance = usdc_contract.functions.allowance(funder_addr, onramp_addr).call()
+
+        # Build calldata for both ops
+        approve_data = usdc_contract.encode_abi("approve", args=[onramp_addr, 2**256 - 1])
 
-        nonce = w3.eth.get_transaction_count(signer_addr)
+        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)
+        wrap_data = onramp_contract.encode_abi("wrap", args=[
+            Web3.to_checksum_address(USDC), funder_addr, int(amount)
+        ])
+
+        # Safe / Proxy wallets → route via relayer (gasless)
+        if creds.signature_type in (SignatureType.POLY_GNOSIS_SAFE, SignatureType.POLY_PROXY):
+            from .relayer import BuilderCreds, RelayClient
+            bc_raw = self._builder_credentials
+            if not bc_raw:
+                raise RuntimeError(
+                    "wrap_to_polyusd on a Safe/Proxy wallet requires builder_credentials "
+                    "in TraderConfig. Pass your Polymarket builder key/secret/passphrase."
+                )
+            bc = BuilderCreds(key=bc_raw.key, secret=bc_raw.secret, passphrase=bc_raw.passphrase)
+            rc = RelayClient(bc, rpc_url=self._rpc_url) if False else RelayClient(bc)  # default relayer
+            txns = []
+            if allowance < amount:
+                txns.append({"to": USDC, "data": approve_data, "value": 0})
+            txns.append({"to": COLLATERAL_ONRAMP, "data": wrap_data, "value": 0})
+            return await rc.execute_safe(signer._private_key or "", signer.address, txns)
+
+        # EOA path: direct send
+        if not signer._private_key:
+            raise RuntimeError("wrap_to_polyusd requires a private key signer for EOA wallets")
 
-        # Step 1: Check and set USDC.e allowance for Onramp
-        allowance = usdc_contract.functions.allowance(signer_addr, onramp_addr).call()
+        nonce = w3.eth.get_transaction_count(funder_addr)
         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,
+            tx = usdc_contract.functions.approve(onramp_addr, 2**256 - 1).build_transaction({
+                "from": funder_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,
+            Web3.to_checksum_address(USDC), funder_addr, int(amount),
         ).build_transaction({
-            "from": signer_addr,
-            "nonce": nonce,
-            "chainId": 137,
+            "from": funder_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)
@@ -489,6 +504,9 @@ class PolyNodeTrader:
     async def unwrap_from_polyusd(self, amount: int) -> str:
         """Unwrap PolyUSD back into USDC.e via the Collateral Offramp.
 
+        Routes through the Polymarket relayer (gasless) for Safe/Proxy wallets,
+        and sends directly for EOA wallets.
+
         Args:
             amount: Amount in raw units (6 decimals, e.g. 1_000_000 = $1).
 
@@ -506,46 +524,60 @@ class PolyNodeTrader:
 
         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)
+        funder_addr = Web3.to_checksum_address(funder)
         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)
+        allowance = polyusd_contract.functions.allowance(funder_addr, offramp_addr).call()
+
+        approve_data = polyusd_contract.encode_abi("approve", args=[offramp_addr, 2**256 - 1])
 
-        nonce = w3.eth.get_transaction_count(signer_addr)
+        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)
+        unwrap_data = offramp_contract.encode_abi("unwrap", args=[
+            Web3.to_checksum_address(USDC), funder_addr, int(amount)
+        ])
+
+        # Safe / Proxy wallets → route via relayer (gasless)
+        if creds.signature_type in (SignatureType.POLY_GNOSIS_SAFE, SignatureType.POLY_PROXY):
+            from .relayer import BuilderCreds, RelayClient
+            bc_raw = self._builder_credentials
+            if not bc_raw:
+                raise RuntimeError(
+                    "unwrap_from_polyusd on a Safe/Proxy wallet requires builder_credentials "
+                    "in TraderConfig. Pass your Polymarket builder key/secret/passphrase."
+                )
+            bc = BuilderCreds(key=bc_raw.key, secret=bc_raw.secret, passphrase=bc_raw.passphrase)
+            rc = RelayClient(bc)
+            txns = []
+            if allowance < amount:
+                txns.append({"to": POLY_USD, "data": approve_data, "value": 0})
+            txns.append({"to": COLLATERAL_OFFRAMP, "data": unwrap_data, "value": 0})
+            return await rc.execute_safe(signer._private_key or "", signer.address, txns)
+
+        # EOA path
+        if not signer._private_key:
+            raise RuntimeError("unwrap_from_polyusd requires a private key signer for EOA wallets")
 
-        allowance = polyusd_contract.functions.allowance(signer_addr, offramp_addr).call()
+        nonce = w3.eth.get_transaction_count(funder_addr)
         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,
+            tx = polyusd_contract.functions.approve(offramp_addr, 2**256 - 1).build_transaction({
+                "from": funder_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,
+            Web3.to_checksum_address(USDC), funder_addr, int(amount),
         ).build_transaction({
-            "from": signer_addr,
-            "nonce": nonce,
-            "chainId": 137,
+            "from": funder_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)
@@ -667,7 +699,8 @@ class PolyNodeTrader:
             fee_amount_raw = calculate_fee(params.price, params.size, fee_config.fee_bps)
             if fee_amount_raw > 0:
                 funder = creds.funder_address or creds.wallet_address
-                nonce = await fetch_escrow_nonce(self._rpc_url, signer.address)
+                escrow_address = fee_escrow_address_for(self._exchange_version)
+                nonce = await fetch_escrow_nonce(self._rpc_url, signer.address, escrow_address)
                 deadline = int(time.time()) + 300
                 escrow_oid = generate_escrow_order_id()
                 fee_auth = await sign_fee_auth(
@@ -680,6 +713,7 @@ class PolyNodeTrader:
                     nonce=nonce,
                     affiliate=fee_config.affiliate,
                     affiliate_share_bps=fee_config.affiliate_share_bps,
+                    exchange_version=self._exchange_version,
                 )
                 fee_auth_dict = {
                     "escrow_order_id": fee_auth.escrow_order_id,
@@ -692,6 +726,8 @@ class PolyNodeTrader:
                     "affiliate": fee_auth.affiliate,
                     "affiliate_share_bps": fee_auth.affiliate_share_bps,
                 }
+                if fee_auth.escrow_contract:
+                    fee_auth_dict["escrow_contract"] = fee_auth.escrow_contract
 
         request_data: dict[str, Any] = {"method": "POST", "path": "/order", "body": body_str, "headers": headers}
         if fee_auth_dict:

{polynode-0.9.0.dist-info → polynode-0.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polynode
-Version: 0.9.0
+Version: 0.9.2
 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.9.0.dist-info → polynode-0.9.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 polynode/__init__.py,sha256=ucqXzFPMdEcfGEAdbgOeJczREEiSCNBX1G3Il7y8-UI,1127
-polynode/_version.py,sha256=H9NWRZb7NbeRRPLP_V1fARmLNXranorVM-OOY-8_2ug,22
+polynode/_version.py,sha256=UwJXM8JY2T3tE2id0K2k_lEaVThbRTrGO1mNibyzIz8,22
 polynode/client.py,sha256=eSCKpuZFg2ssQC5tmsfRYF3cTqCk1Gdw4KPjbd5MFHQ,21831
 polynode/engine.py,sha256=DSXBmx3DXPh-PN0ihkXn7LSiyxeOoo0iY3z4YinQ3XI,6488
 polynode/errors.py,sha256=5qUCI7K76VKbF5R5G5UYhPzcnOPlGLCA8-sJnKbrK-4,925
@@ -14,16 +14,17 @@ polynode/cache/__init__.py,sha256=A9lXcIE3ISKKo1r0o3o-CkmQpBhLdKwdQfCR0eW5i9o,51
 polynode/trading/V2_ORDER_FLOW.md,sha256=Ppd7iwZjtmVwok-fP4Ofo4UBQ9pIAg0t57RJ-OzqRHs,10926
 polynode/trading/__init__.py,sha256=sPv30j9eyvqjnUBxGAYaKpAPQZ2jTw3UwA4DZXYZ21s,923
 polynode/trading/clob_api.py,sha256=Sfb8XLN9MMzVE6jARNqEQxiD608OC_6Xjc7uiJbDQEc,7274
-polynode/trading/constants.py,sha256=aW8F9Q2W0TRNVX0JNh39k0qxbb03ijUAGbWjrJFjf_o,2513
+polynode/trading/constants.py,sha256=IEdrwC4bPjo4MoVlDKYqXphlmIKsoxO4f_s_pyZ3x08,2702
 polynode/trading/cosigner.py,sha256=Fww9OgaKdHQAHd8Kom1AJBtmMGC8FbNZxdFaFALNBY8,3058
 polynode/trading/eip712.py,sha256=PKLfMt58Diy419jiQXysnX1kSlU_QcWDRofGEb3u_JI,9744
-polynode/trading/escrow.py,sha256=bU_ohyOlx2r6KjBYxUNdjROvrmunWV1Ey99AuSOt9Z8,4590
-polynode/trading/onboarding.py,sha256=oXtFz1HF1vGvMnb5o44SwuADd2mdU5ws1v7n30rk6fg,15066
+polynode/trading/escrow.py,sha256=T2v5bv3wIyQTcFoxcHXlDBlzyeWDYbxRIqQamqlhaog,6513
+polynode/trading/onboarding.py,sha256=GdQh1aM9F0LuCL3uqNTguXX5Sxe1_0hSVdHR7kksKZ0,15777
 polynode/trading/position_management.py,sha256=z2pYls4ErhyRE6thQdOs45BF4llKvKNNruQgcMEFT_U,3827
 polynode/trading/privy.py,sha256=iiUQZsBqjj29C7oUiFFktoT2muZY06bcMzABKstFKqE,4523
+polynode/trading/relayer.py,sha256=adTo-aclWnaqrFtfWEOQ2Ye859CZMc9q_fsd3DePDGA,10542
 polynode/trading/signer.py,sha256=piifRquwnwFwrKLL24jsRQYMh_cdkz8wNz99Vx8_KTY,3413
 polynode/trading/sqlite_backend.py,sha256=zfo4WevuunWV-7i6Z3gQi_e7Tonw-7m1TsEd88O5I4w,9486
-polynode/trading/trader.py,sha256=VpOwZ0TEwkOSRSLSAZ1LxjEJfxPkH3RO-XFrH6RG5Ys,34845
+polynode/trading/trader.py,sha256=EEwF_U2DXVPRnENY5azk8FgzSx_zXns27apQQj9isus,37188
 polynode/trading/types.py,sha256=mo5zJRlfQLWuXwrkS9AaGqKWrt7FMf6bPGRE-0T62J0,5698
 polynode/types/__init__.py,sha256=0v_CByqG-zT1xucbT2So_77YDmsPj9u956at94nyrLM,280
 polynode/types/enums.py,sha256=2cx9l10A-LUeDNBJZn7l0XBTka2YfxRQcXW0s7s3_4k,1082
@@ -32,6 +33,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.9.0.dist-info/METADATA,sha256=mzGKeGUGX-EvRNytrdz2FS7uq-N4-m944fpaW2GujoU,3777
-polynode-0.9.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-polynode-0.9.0.dist-info/RECORD,,
+polynode-0.9.2.dist-info/METADATA,sha256=-FqTxtI_g04JQ7AxM9kzp9RxfnF6dGNADA3CmfXORK8,3777
+polynode-0.9.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+polynode-0.9.2.dist-info/RECORD,,