polynode 0.10.6__tar.gz → 0.10.8__tar.gz

{polynode-0.10.6 → polynode-0.10.8}/.gitignore

@@ -37,6 +37,8 @@ docs/
 ob/ob
 ob/ob.bak
 wallet-resolver/wallets.db
+wallet-resolver/wallets.db-shm
+wallet-resolver/wallets.db-wal
 __pycache__/
 
 # Manual file backups (e.g. server.ts.bak.x-search-1777174461)

{polynode-0.10.6 → polynode-0.10.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polynode
-Version: 0.10.6
+Version: 0.10.8
 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
@@ -35,6 +35,10 @@ Description-Content-Type: text/markdown
 
 Python SDK for the [PolyNode](https://polynode.dev) real-time prediction market data platform.
 
+**New in v0.10.8:** POLY_1271 V2 order signatures now normalize the ERC-7739 `TypedDataSign` recovery byte to Ethereum `v=27/28` for on-chain ERC-1271 validation.
+
+**In v0.10.7:** Polymarket V2 deposit-wallet trading fixes. `ensure_ready()` detects deployed `POLY_1271` wallets correctly, V2 type-3 orders use the deposit wallet as both maker and signer, and existing local credentials can be repaired by rerunning `ensure_ready()`.
+
 ## Install
 
 ```bash

{polynode-0.10.6 → polynode-0.10.8}/README.md

@@ -2,6 +2,10 @@
 
 Python SDK for the [PolyNode](https://polynode.dev) real-time prediction market data platform.
 
+**New in v0.10.8:** POLY_1271 V2 order signatures now normalize the ERC-7739 `TypedDataSign` recovery byte to Ethereum `v=27/28` for on-chain ERC-1271 validation.
+
+**In v0.10.7:** Polymarket V2 deposit-wallet trading fixes. `ensure_ready()` detects deployed `POLY_1271` wallets correctly, V2 type-3 orders use the deposit wallet as both maker and signer, and existing local credentials can be repaired by rerunning `ensure_ready()`.
+
 ## Install
 
 ```bash

polynode-0.10.8/polynode/_version.py

@@ -0,0 +1 @@
+__version__ = "0.10.8"

{polynode-0.10.6 → polynode-0.10.8}/polynode/trading/eip712.py

@@ -96,6 +96,20 @@ TYPED_DATA_SIGN_TYPES = {
 }
 
 
+def _poly1271_inner_signature(signature: str) -> bytes:
+    """Return a 65-byte POLY_1271 inner signature with Ethereum v=27/28."""
+    if not signature.startswith("0x"):
+        signature = f"0x{signature}"
+    sig_bytes = bytearray(bytes.fromhex(signature[2:]))
+    if len(sig_bytes) != 65:
+        raise ValueError(f"POLY_1271 inner signature must be 65 bytes, got {len(sig_bytes)}")
+    if sig_bytes[-1] in (0, 1):
+        sig_bytes[-1] += 27
+    elif sig_bytes[-1] not in (27, 28):
+        raise ValueError(f"invalid POLY_1271 inner signature v: {sig_bytes[-1]}")
+    return bytes(sig_bytes)
+
+
 def compute_amounts(
     price: float,
     size: float,
@@ -305,10 +319,11 @@ async def create_signed_order_v2(
     - timestamp is a string in the payload
     """
     maker_amount, taker_amount = compute_amounts(price, size, side, tick_size)
+    order_signer = funder_address if signature_type == SignatureType.POLY_1271 else signer_address
 
     payload = build_order_payload_v2(
         maker=funder_address,
-        signer=signer_address,
+        signer=order_signer,
         token_id=token_id,
         maker_amount=maker_amount,
         taker_amount=taker_amount,
@@ -337,11 +352,7 @@ async def create_signed_order_v2(
             },
         )
         inner_sig = await sign_typed_data(tds_payload)
-        if not inner_sig.startswith("0x"):
-            inner_sig = f"0x{inner_sig}"
-        inner_bytes = bytearray(bytes.fromhex(inner_sig[2:]))
-        if len(inner_bytes) == 65 and inner_bytes[-1] >= 27:
-            inner_bytes[-1] -= 27
+        inner_bytes = _poly1271_inner_signature(inner_sig)
 
         # Compute app domain separator and contents hash for wrapping
         from eth_utils import keccak
@@ -388,7 +399,7 @@ async def create_signed_order_v2(
     return {
         "salt": payload.message["salt"],  # number
         "maker": funder_address,
-        "signer": signer_address,
+        "signer": order_signer,
         "taker": "0x0000000000000000000000000000000000000000",
         "tokenId": token_id,
         "makerAmount": str(maker_amount),

{polynode-0.10.6 → polynode-0.10.8}/polynode/trading/onboarding.py

@@ -124,6 +124,7 @@ async def detect_wallet_type(eoa: str) -> dict:
     """Auto-detect if a Safe, Proxy, or deposit wallet is deployed for this EOA."""
     safe_addr = derive_safe_address(eoa)
     proxy_addr = derive_proxy_address(eoa)
+    deposit_wallet_addr = derive_deposit_wallet_address(eoa)
 
     async with httpx.AsyncClient(timeout=10.0) as http:
         # Check Safe first (most common for existing users)
@@ -152,13 +153,13 @@ async def detect_wallet_type(eoa: str) -> dict:
         except Exception:
             pass
 
-    # Check deposit wallet (newer accounts)
+    # Check deposit wallet (newer accounts). Polymarket's relayer defaults
+    # /deployed to SAFE, so deposit wallets must be checked with type=WALLET.
     try:
-        dw_addr = derive_deposit_wallet_address(eoa)
-        if await is_safe_deployed(dw_addr):
+        if await is_deposit_wallet_deployed(deposit_wallet_addr):
             return {
                 "signature_type": SignatureType.POLY_1271,
-                "funder_address": dw_addr,
+                "funder_address": deposit_wallet_addr,
             }
     except Exception:
         pass
@@ -182,6 +183,18 @@ async def is_safe_deployed(funder_address: str) -> bool:
     return False
 
 
+async def is_deposit_wallet_deployed(funder_address: str) -> bool:
+    """Check if a deposit wallet is deployed at the given address."""
+    async with httpx.AsyncClient(timeout=10.0) as http:
+        try:
+            resp = await http.get(f"{RELAYER_HOST}/deployed?address={funder_address}&type=WALLET")
+            if resp.is_success:
+                return resp.json().get("deployed", False)
+        except Exception:
+            pass
+    return False
+
+
 async def check_approvals(
     funder_address: str,
     rpc_url: str,

{polynode-0.10.6 → polynode-0.10.8}/polynode/trading/trader.py

@@ -33,6 +33,7 @@ from .onboarding import (
     create_clob_credentials,
     derive_funder_address,
     detect_wallet_type,
+    is_deposit_wallet_deployed,
     is_safe_deployed,
     set_approvals as set_approvals_onchain,
 )
@@ -103,14 +104,19 @@ class PolyNodeTrader:
         signer: str | RouterSigner,
         *,
         type: SignatureType | None = None,
+        funder_address: str | None = None,
     ) -> ReadyStatus:
         """One-call onboarding: detect wallet type, deploy Safe, set approvals, create CLOB creds."""
+        if funder_address is not None and type is None:
+            raise ValueError("funder_address requires type so the wallet identity is unambiguous")
+
         temp = await normalize_signer(signer, type or SignatureType.POLY_GNOSIS_SAFE)
         actions: list[str] = []
 
         if type is not None:
             sig_type = type
-            funder = temp.funder_address or await derive_funder_address(temp.address, sig_type)
+            funder = funder_address or temp.funder_address or await derive_funder_address(temp.address, sig_type)
+            actions.append(f"explicit_type_{int(sig_type)}")
         else:
             detected = await detect_wallet_type(temp.address)
             sig_type = detected["signature_type"]
@@ -135,6 +141,14 @@ class PolyNodeTrader:
             else:
                 actions.append("safe_deploy_needed")
 
+        if sig_type == SignatureType.POLY_1271 and not safe_deployed:
+            deployed = await is_deposit_wallet_deployed(funder)
+            if deployed:
+                safe_deployed = True
+                actions.append("deposit_wallet_already_deployed")
+            else:
+                actions.append("deposit_wallet_deploy_needed")
+
         # Check approvals
         if sig_type in (SignatureType.POLY_GNOSIS_SAFE, SignatureType.EOA) and not approvals_set:
             try:
@@ -165,6 +179,8 @@ class PolyNodeTrader:
             db.upsert_credentials(stored)
             actions.append("credentials_created")
         else:
+            stored.funder_address = funder
+            stored.signature_type = sig_type
             stored.safe_deployed = safe_deployed
             stored.approvals_set = approvals_set
             stored.updated_at = time.time()
@@ -214,11 +230,15 @@ class PolyNodeTrader:
         signer: str | RouterSigner,
         *,
         type: SignatureType | None = None,
+        funder_address: str | None = None,
     ) -> LinkResult:
         """Link a wallet manually (derive credentials, store locally)."""
+        if funder_address is not None and type is None:
+            raise ValueError("funder_address requires type so the wallet identity is unambiguous")
+
         sig_type = type or self._default_sig_type
         normalized = await normalize_signer(signer, sig_type)
-        funder = normalized.funder_address or await derive_funder_address(normalized.address, sig_type)
+        funder = funder_address or normalized.funder_address or await derive_funder_address(normalized.address, sig_type)
 
         db = self._get_db()
         existing = db.get_credentials(normalized.address)

{polynode-0.10.6 → polynode-0.10.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polynode"
-version = "0.10.6"
+version = "0.10.8"
 description = "Python SDK for the PolyNode real-time prediction market data platform"
 readme = "README.md"
 requires-python = ">=3.10"

{polynode-0.10.6 → polynode-0.10.8}/tests/test_trading.py

@@ -1,11 +1,13 @@
 """Tests for trading module — EIP-712 signing, HMAC headers, V1 and V2."""
 
 import base64
+import asyncio
 
 from polynode.trading.cosigner import build_l2_headers
 from polynode.trading.eip712 import (
     build_order_payload,
     build_order_payload_v2,
+    create_signed_order_v2,
     compute_amounts,
     EXCHANGE_DOMAIN,
     EXCHANGE_DOMAIN_V2,
@@ -76,6 +78,147 @@ def test_safe_address_derivation():
         pass  # Skip if trading deps not installed
 
 
+def test_detect_wallet_type_uses_deposit_wallet_check(monkeypatch):
+    """Regression: deposit wallets must be checked as WALLET, not SAFE."""
+    from polynode.trading import onboarding
+
+    eoa = "0x7b3099fe73372D900a9F0F62CdcA261755f7EA60"
+    deposit_wallet = "0x58b8048C8f09C2FCc4914258587a8E7E0cc21D76"
+
+    async def safe_not_deployed(_address: str) -> bool:
+        return False
+
+    async def deposit_wallet_deployed(address: str) -> bool:
+        return address == deposit_wallet
+
+    monkeypatch.setattr(onboarding, "is_safe_deployed", safe_not_deployed)
+    monkeypatch.setattr(onboarding, "is_deposit_wallet_deployed", deposit_wallet_deployed)
+
+    detected = asyncio.run(onboarding.detect_wallet_type(eoa))
+
+    assert detected["signature_type"] == SignatureType.POLY_1271
+    assert detected["funder_address"] == deposit_wallet
+
+
+def test_v2_poly1271_order_uses_deposit_wallet_as_signer():
+    """POLY_1271 V2 orders need maker and signer set to the deposit wallet."""
+    signer_address = "0x7b3099fe73372D900a9F0F62CdcA261755f7EA60"
+    deposit_wallet = "0x58b8048C8f09C2FCc4914258587a8E7E0cc21D76"
+    signed_payload = {}
+
+    async def fake_sign(payload):
+        signed_payload.update(payload.message["contents"])
+        return "0x" + "11" * 64 + "01"
+
+    order = asyncio.run(create_signed_order_v2(
+        fake_sign,
+        signer_address=signer_address,
+        funder_address=deposit_wallet,
+        token_id="12345",
+        price=0.5,
+        size=1,
+        side="BUY",
+        signature_type=SignatureType.POLY_1271,
+        timestamp_ms=1712345678000,
+    ))
+
+    assert signed_payload["maker"] == deposit_wallet
+    assert signed_payload["signer"] == deposit_wallet
+    assert order["maker"] == deposit_wallet
+    assert order["signer"] == deposit_wallet
+    assert order["signatureType"] == 3
+
+
+def test_v2_poly1271_inner_signature_normalizes_recovery_id():
+    """POLY_1271 TypedDataSign inner signatures need Ethereum v=27/28."""
+    async def fake_sign(_payload):
+        return "0x" + "11" * 64 + "01"
+
+    order = asyncio.run(create_signed_order_v2(
+        fake_sign,
+        signer_address="0x7b3099fe73372D900a9F0F62CdcA261755f7EA60",
+        funder_address="0x58b8048C8f09C2FCc4914258587a8E7E0cc21D76",
+        token_id="12345",
+        price=0.5,
+        size=1,
+        side="BUY",
+        signature_type=SignatureType.POLY_1271,
+        timestamp_ms=1712345678000,
+    ))
+
+    wrapped = bytes.fromhex(order["signature"][2:])
+    assert len(wrapped) > 65
+    assert wrapped[64] == 28
+
+
+def test_ensure_ready_allows_explicit_poly1271_funder(monkeypatch, tmp_path):
+    """Existing deposit-wallet users can force type 3 plus a known funder."""
+    from polynode.trading import trader as trader_mod
+    from polynode.trading.trader import PolyNodeTrader
+    from polynode.trading.types import ExchangeVersion, TraderConfig
+
+    private_key = "0x" + "01" * 32
+    deposit_wallet = "0x58b8048C8f09C2FCc4914258587a8E7E0cc21D76"
+
+    async def deposit_wallet_deployed(address: str) -> bool:
+        return address == deposit_wallet
+
+    async def fake_create_clob_credentials(*_args, **_kwargs):
+        return {
+            "apiKey": "key",
+            "apiSecret": base64.b64encode(b"secret").decode(),
+            "apiPassphrase": "pass",
+        }
+
+    monkeypatch.setattr(trader_mod, "is_deposit_wallet_deployed", deposit_wallet_deployed)
+    monkeypatch.setattr(trader_mod, "create_clob_credentials", fake_create_clob_credentials)
+
+    trader = PolyNodeTrader(TraderConfig(
+        db_path=str(tmp_path / "trading.db"),
+        exchange_version=ExchangeVersion.V2,
+    ))
+
+    status = asyncio.run(trader.ensure_ready(
+        private_key,
+        type=SignatureType.POLY_1271,
+        funder_address=deposit_wallet,
+    ))
+
+    assert status.signature_type == SignatureType.POLY_1271
+    assert status.funder_address == deposit_wallet
+    assert status.safe_deployed is True
+    assert "explicit_type_3" in status.actions
+    assert "deposit_wallet_already_deployed" in status.actions
+
+    try:
+        from eth_account import Account
+    except ImportError:
+        return
+
+    wallet = Account.from_key(private_key).address
+    wrong_safe = "0xb8f9248a67962c9FE37E70e7a6E38e100b7613f1"
+    trader.link_credentials(
+        wallet=wallet,
+        api_key="key",
+        api_secret=base64.b64encode(b"secret").decode(),
+        api_passphrase="pass",
+        signature_type=SignatureType.POLY_GNOSIS_SAFE,
+        funder_address=wrong_safe,
+    )
+
+    status = asyncio.run(trader.ensure_ready(
+        private_key,
+        type=SignatureType.POLY_1271,
+        funder_address=deposit_wallet,
+    ))
+    exported = trader.export_wallet(wallet)
+
+    assert status.signature_type == SignatureType.POLY_1271
+    assert exported is not None
+    assert exported.signature_type == SignatureType.POLY_1271
+    assert exported.funder_address == deposit_wallet
+
+
 # ── V2 constants ──
 
 

polynode-0.10.6/polynode/_version.py

@@ -1 +0,0 @@
-__version__ = "0.10.6"