polynode 0.10.5__tar.gz → 0.10.7__tar.gz

{polynode-0.10.5 → polynode-0.10.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polynode
-Version: 0.10.5
+Version: 0.10.7
 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,8 @@ Description-Content-Type: text/markdown
 
 Python SDK for the [PolyNode](https://polynode.dev) real-time prediction market data platform.
 
+**New 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.5 → polynode-0.10.7}/README.md

@@ -2,6 +2,8 @@
 
 Python SDK for the [PolyNode](https://polynode.dev) real-time prediction market data platform.
 
+**New 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.7/polynode/_version.py

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

{polynode-0.10.5 → polynode-0.10.7}/polynode/orderbook.py

@@ -28,7 +28,7 @@ class OrderbookWS:
 
     def __init__(self, api_key: str, ob_url: str, *, compress: bool = True, auto_reconnect: bool = True,
                  max_reconnect_attempts: int = 0, reconnect_base_delay: float = 1.0,
-                 reconnect_max_delay: float = 30.0) -> None:
+                 reconnect_max_delay: float = 30.0, subscribe_timeout: float = 30.0) -> None:
         self._api_key = api_key
         self._ob_url = ob_url
         self._compress = compress
@@ -36,12 +36,14 @@ class OrderbookWS:
         self._max_reconnect = max_reconnect_attempts
         self._base_delay = reconnect_base_delay
         self._max_delay = reconnect_max_delay
+        self._subscribe_timeout = subscribe_timeout
 
         self._socket: Any = None
         self._connected = False
         self._intentional_close = False
         self._reconnect_attempts = 0
         self._token_ids: list[str] = []
+        self._pending_subscribe: asyncio.Future | None = None
         self._recv_task: asyncio.Task | None = None
 
         self._handlers: dict[str, list[Callable]] = {
@@ -92,14 +94,20 @@ class OrderbookWS:
         return self
 
     async def subscribe(self, token_ids: list[str]) -> None:
-        self._token_ids = token_ids
+        self._token_ids = list(token_ids)
         await self._ensure_connected()
-        await self._send(json.dumps({"action": "subscribe", "markets": token_ids}))
-
-    def unsubscribe(self) -> None:
-        self._token_ids = []
+        await self._send_subscribe(self._token_ids)
+
+    def unsubscribe(self, token_ids: list[str] | None = None) -> None:
+        if token_ids is None:
+            self._token_ids = []
+            msg = {"action": "unsubscribe"}
+        else:
+            remove = set(token_ids)
+            self._token_ids = [token_id for token_id in self._token_ids if token_id not in remove]
+            msg = {"action": "unsubscribe", "markets": token_ids}
         if self._connected and self._socket:
-            asyncio.ensure_future(self._send(json.dumps({"action": "unsubscribe"})))
+            asyncio.ensure_future(self._send(json.dumps(msg)))
 
     async def connect(self) -> None:
         if self._connected and self._socket:
@@ -157,6 +165,9 @@ class OrderbookWS:
             return
         finally:
             self._connected = False
+            self._reject_pending_subscribe(
+                WsError("WebSocket connection closed before orderbook subscription was acknowledged")
+            )
             reason = "closed" if self._intentional_close else "lost"
             for h in self._on_disconnect:
                 h(reason)
@@ -167,11 +178,44 @@ class OrderbookWS:
         if self._socket and self._connected:
             await self._socket.send(data)
 
+    async def _send_subscribe(self, token_ids: list[str]) -> None:
+        if self._pending_subscribe and not self._pending_subscribe.done():
+            raise WsError("Subscribe already pending")
+
+        fut: asyncio.Future[None] = asyncio.get_running_loop().create_future()
+        self._pending_subscribe = fut
+        await self._send(json.dumps({"action": "subscribe", "markets": token_ids}))
+
+        try:
+            await asyncio.wait_for(fut, timeout=self._subscribe_timeout)
+        except asyncio.TimeoutError:
+            if self._pending_subscribe is fut:
+                self._pending_subscribe = None
+            raise WsError(f"Subscribe timed out after {self._subscribe_timeout:g} seconds")
+
+    def _resolve_pending_subscribe(self) -> None:
+        fut = self._pending_subscribe
+        self._pending_subscribe = None
+        if fut and not fut.done():
+            fut.set_result(None)
+
+    def _reject_pending_subscribe(self, err: WsError) -> None:
+        fut = self._pending_subscribe
+        self._pending_subscribe = None
+        if fut and not fut.done():
+            fut.set_exception(err)
+
     def _handle_message(self, text: str) -> None:
         msg = json.loads(text)
 
-        if msg.get("error"):
-            err_msg = ObErrorMessage.model_validate(msg)
+        if msg.get("error") or msg.get("type") == "error":
+            err_msg = ObErrorMessage(
+                error=str(msg.get("error") or msg.get("code") or "error"),
+                message=str(msg.get("message") or msg.get("error") or "Unknown orderbook error"),
+                max=msg.get("max"),
+                requested=msg.get("requested"),
+            )
+            self._reject_pending_subscribe(WsError(err_msg.message, err_msg.error))
             for h in self._handlers["error"]:
                 h(err_msg)
             return
@@ -180,6 +224,7 @@ class OrderbookWS:
 
         if msg_type == "subscribed":
             sub_msg = SubscribedMessage(markets=msg.get("markets", 0))
+            self._resolve_pending_subscribe()
             for h in self._handlers["subscribed"]:
                 h(sub_msg)
 
@@ -238,6 +283,6 @@ class OrderbookWS:
             for h in self._on_reconnect:
                 h(self._reconnect_attempts)
             if self._token_ids:
-                await self._send(json.dumps({"action": "subscribe", "markets": self._token_ids}))
+                await self._send_subscribe(self._token_ids)
         except Exception:
             pass

{polynode-0.10.5 → polynode-0.10.7}/polynode/subscription.py

@@ -12,6 +12,8 @@ from .types.ws import SubscriptionFilters
 if TYPE_CHECKING:
     from .ws import PolyNodeWS
 
+PRE_ACK_REPLAY_LIMIT = 1000
+
 
 class SubscriptionBuilder:
     """Fluent builder for WebSocket subscriptions."""
@@ -79,6 +81,7 @@ class Subscription:
         self._id: str | None = None
         self._handlers: dict[str, set[Callable]] = {}
         self._queue: asyncio.Queue[PolyNodeEvent | None] = asyncio.Queue()
+        self._pre_ack_replay: list[PolyNodeEvent] = []
         self._closed = False
 
     @property
@@ -92,6 +95,10 @@ class Subscription:
         if type not in self._handlers:
             self._handlers[type] = set()
         self._handlers[type].add(handler)
+        for event in self._pre_ack_replay:
+            event_type = event.event_type  # type: ignore[union-attr]
+            if type == "*" or type == event_type:
+                handler(event)
         return self
 
     def off(self, type: str, handler: Callable) -> Subscription:
@@ -114,6 +121,12 @@ class Subscription:
         # Async iterator queue
         self._queue.put_nowait(event)
 
+    def _emit_pre_ack(self, event: PolyNodeEvent) -> None:
+        self._pre_ack_replay.append(event)
+        if len(self._pre_ack_replay) > PRE_ACK_REPLAY_LIMIT:
+            self._pre_ack_replay = self._pre_ack_replay[-PRE_ACK_REPLAY_LIMIT:]
+        self._emit(event)
+
     def unsubscribe(self) -> None:
         self._closed = True
         self._queue.put_nowait(None)

{polynode-0.10.5 → polynode-0.10.7}/polynode/trading/eip712.py

@@ -305,10 +305,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,
@@ -388,7 +389,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.5 → polynode-0.10.7}/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.5 → polynode-0.10.7}/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.5 → polynode-0.10.7}/polynode/types/ws.py

@@ -36,3 +36,4 @@ class WsOptions:
     max_reconnect_attempts: int = 0  # 0 = infinite
     reconnect_base_delay: float = 1.0
     reconnect_max_delay: float = 30.0
+    subscribe_timeout: float = 30.0

{polynode-0.10.5 → polynode-0.10.7}/polynode/ws.py

@@ -29,6 +29,32 @@ def _parse_event(data: dict) -> PolyNodeEvent | None:
         return None
 
 
+def _subscription_accepts_event(sub_type: SubscriptionType, event_type: str) -> bool:
+    if sub_type in ("global", "markets"):
+        return True
+    if sub_type == "settlements":
+        return event_type in {"settlement", "status_update"}
+    if sub_type in ("trades", "large_trades"):
+        return event_type == "trade"
+    if sub_type in ("prices", "chainlink"):
+        return event_type == "price_feed"
+    if sub_type == "blocks":
+        return event_type == "block"
+    if sub_type == "wallets":
+        return event_type in {
+            "settlement",
+            "trade",
+            "status_update",
+            "position_change",
+            "deposit",
+            "position_split",
+            "position_merge",
+        }
+    if sub_type == "oracle":
+        return event_type == "oracle"
+    return True
+
+
 class PolyNodeWS:
     """Async WebSocket client with auto-reconnect and subscription management."""
 
@@ -41,6 +67,7 @@ class PolyNodeWS:
         self._max_reconnect = opts.max_reconnect_attempts
         self._base_delay = opts.reconnect_base_delay
         self._max_delay = opts.reconnect_max_delay
+        self._subscribe_timeout = opts.subscribe_timeout
 
         self._socket: Any = None
         self._connected = False
@@ -105,11 +132,11 @@ class PolyNodeWS:
         await self._send(json.dumps(msg))
 
         try:
-            return await asyncio.wait_for(fut, timeout=10.0)
+            return await asyncio.wait_for(fut, timeout=self._subscribe_timeout)
         except asyncio.TimeoutError:
             # Remove from pending
             self._pending = [(s, f) for s, f in self._pending if f is not fut]
-            raise WsError("Subscribe timed out after 10 seconds")
+            raise WsError(f"Subscribe timed out after {self._subscribe_timeout:g} seconds")
 
     def _unsubscribe(self, subscription_id: str | None = None) -> None:
         if subscription_id:
@@ -182,6 +209,8 @@ class PolyNodeWS:
             return
         finally:
             self._connected = False
+            if self._pending:
+                self._reject_pending(WsError("WebSocket connection closed before subscription was acknowledged"))
             reason = "closed" if self._intentional_close else "lost"
             for h in self._on_disconnect:
                 h(reason)
@@ -250,6 +279,22 @@ class PolyNodeWS:
     def _route_event(self, event: PolyNodeEvent) -> None:
         for sub in self._subscriptions.values():
             sub._emit(event)
+        self._route_pending_event(event)
+
+    def _route_pending_event(self, event: PolyNodeEvent) -> None:
+        if not self._pending:
+            return
+        event_type = event.event_type  # type: ignore[union-attr]
+        for sub, _ in self._pending:
+            if _subscription_accepts_event(sub.type, event_type):
+                sub._emit_pre_ack(event)
+
+    def _reject_pending(self, err: WsError) -> None:
+        pending = self._pending
+        self._pending = []
+        for _, fut in pending:
+            if not fut.done():
+                fut.set_exception(err)
 
     async def _schedule_reconnect(self) -> None:
         if self._max_reconnect and self._reconnect_attempts >= self._max_reconnect:

{polynode-0.10.5 → polynode-0.10.7}/pyproject.toml

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

{polynode-0.10.5 → polynode-0.10.7}/tests/conftest.py

@@ -1,8 +1,10 @@
 """Shared test fixtures."""
 
+import os
+
 import pytest
 
-TEST_KEY = "pn_live_test_session_tracking_51eca107e9b347b589f5b0a04f98eb1d"
+TEST_KEY = os.getenv("POLYNODE_API_KEY")
 BASE_URL = "https://api.polynode.dev"
 WS_URL = "wss://ws.polynode.dev/ws"
 OB_URL = "wss://ob.polynode.dev/ws"
@@ -10,20 +12,22 @@ OB_URL = "wss://ob.polynode.dev/ws"
 
 @pytest.fixture
 def api_key():
+    if not TEST_KEY:
+        pytest.skip("POLYNODE_API_KEY is not set")
     return TEST_KEY
 
 
 @pytest.fixture
-def client():
+def client(api_key):
     from polynode import PolyNode
-    pn = PolyNode(api_key=TEST_KEY)
+    pn = PolyNode(api_key=api_key)
     yield pn
     pn.close()
 
 
 @pytest.fixture
-async def async_client():
+async def async_client(api_key):
     from polynode import AsyncPolyNode
-    pn = AsyncPolyNode(api_key=TEST_KEY)
+    pn = AsyncPolyNode(api_key=api_key)
     yield pn
     await pn.close()

{polynode-0.10.5 → polynode-0.10.7}/tests/test_client.py

@@ -1,14 +1,18 @@
 """Tests for the sync REST client."""
 
+import os
+
 import pytest
 from polynode import PolyNode
 from polynode.types.rest import StatusResponse, MarketsResponse, SettlementsResponse
 
-TEST_KEY = "pn_live_test_session_tracking_51eca107e9b347b589f5b0a04f98eb1d"
+TEST_KEY = os.getenv("POLYNODE_API_KEY")
 
 
 @pytest.fixture
 def pn():
+    if not TEST_KEY:
+        pytest.skip("POLYNODE_API_KEY is not set")
     client = PolyNode(api_key=TEST_KEY)
     yield client
     client.close()
@@ -46,7 +50,7 @@ def test_search(pn):
 
 
 def test_search_online_builds_expected_path():
-    client = PolyNode(api_key=TEST_KEY)
+    client = PolyNode(api_key=TEST_KEY or "pn_test_local")
     calls = []
 
     def fake_fetch(path, **kwargs):
@@ -80,7 +84,7 @@ def test_search_online_builds_expected_path():
 
 
 def test_sports_methods_build_expected_paths():
-    client = PolyNode(api_key=TEST_KEY)
+    client = PolyNode(api_key=TEST_KEY or "pn_test_local")
     calls = []
 
     def fake_fetch(path, **kwargs):

polynode-0.10.7/tests/test_orderbook_protocol.py

@@ -0,0 +1,131 @@
+"""Protocol-level orderbook WebSocket regression tests."""
+
+import asyncio
+import json
+
+import pytest
+
+from polynode.errors import WsError
+from polynode.orderbook import OrderbookWS
+
+
+class FakeSocket:
+    def __init__(self) -> None:
+        self.sent: list[dict] = []
+
+    async def send(self, data: str) -> None:
+        self.sent.append(json.loads(data))
+
+
+def snapshot(asset_id: str = "token-1") -> dict:
+    return {
+        "type": "book_snapshot",
+        "asset_id": asset_id,
+        "market": "condition-1",
+        "bids": [{"price": "0.50", "size": "100"}],
+        "asks": [{"price": "0.55", "size": "200"}],
+    }
+
+
+def make_ws(timeout: float = 0.2) -> tuple[OrderbookWS, FakeSocket]:
+    socket = FakeSocket()
+    ws = OrderbookWS("key", "wss://example.test/ws", subscribe_timeout=timeout)
+    ws._socket = socket
+    ws._connected = True
+    return ws, socket
+
+
+def test_orderbook_subscribe_waits_for_ack_without_dropping_snapshots():
+    async def scenario() -> None:
+        ws, socket = make_ws()
+        snapshots = []
+        subscribed = []
+        ws.on("snapshot", snapshots.append)
+        ws.on("subscribed", subscribed.append)
+
+        task = asyncio.create_task(ws.subscribe(["token-1"]))
+        await asyncio.sleep(0)
+
+        assert socket.sent == [{"action": "subscribe", "markets": ["token-1"]}]
+        assert not task.done()
+
+        ws._handle_message(json.dumps({"type": "snapshot_batch", "snapshots": [snapshot()]}))
+        assert len(snapshots) == 1
+        assert not task.done()
+
+        ws._handle_message(json.dumps({"type": "subscribed", "markets": 1}))
+        await asyncio.wait_for(task, timeout=0.1)
+
+        assert subscribed[0].markets == 1
+        assert snapshots[0].asset_id == "token-1"
+
+    asyncio.run(scenario())
+
+
+def test_orderbook_subscribe_rejects_server_error_before_ack():
+    async def scenario() -> None:
+        ws, _ = make_ws()
+        errors = []
+        ws.on("error", errors.append)
+
+        task = asyncio.create_task(ws.subscribe(["token-1", "token-2"]))
+        await asyncio.sleep(0)
+        ws._handle_message(
+            json.dumps(
+                {
+                    "error": "too_many_markets",
+                    "message": "Too many markets",
+                    "max": 1,
+                    "requested": 2,
+                }
+            )
+        )
+
+        with pytest.raises(WsError, match="Too many markets"):
+            await task
+
+        assert errors[0].error == "too_many_markets"
+        assert errors[0].max == 1
+        assert errors[0].requested == 2
+
+    asyncio.run(scenario())
+
+
+def test_orderbook_subscribe_timeout_uses_configured_timeout():
+    async def scenario() -> None:
+        ws, socket = make_ws(timeout=0.01)
+
+        with pytest.raises(WsError, match="0.01 seconds"):
+            await ws.subscribe(["token-1"])
+
+        assert socket.sent == [{"action": "subscribe", "markets": ["token-1"]}]
+
+    asyncio.run(scenario())
+
+
+def test_orderbook_partial_unsubscribe_is_additive():
+    async def scenario() -> None:
+        ws, socket = make_ws()
+        ws._token_ids = ["token-1", "token-2", "token-3"]
+
+        ws.unsubscribe(["token-2"])
+        await asyncio.sleep(0)
+
+        assert ws._token_ids == ["token-1", "token-3"]
+        assert socket.sent == [{"action": "unsubscribe", "markets": ["token-2"]}]
+
+    asyncio.run(scenario())
+
+
+def test_orderbook_type_error_rejects_pending_subscribe():
+    async def scenario() -> None:
+        ws, _ = make_ws()
+        task = asyncio.create_task(ws.subscribe(["token-1"]))
+        await asyncio.sleep(0)
+
+        ws._handle_message(json.dumps({"type": "error", "code": "bad_request", "message": "Invalid token"}))
+
+        with pytest.raises(WsError, match="Invalid token"):
+            await task
+
+    asyncio.run(scenario())

{polynode-0.10.5 → polynode-0.10.7}/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,125 @@ 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" * 65
+
+    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_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.7/tests/test_ws_protocol.py

@@ -0,0 +1,107 @@
+"""Protocol-level WebSocket regression tests."""
+
+import asyncio
+import json
+
+import pytest
+
+from polynode.errors import WsError
+from polynode.subscription import Subscription
+from polynode.types.ws import SubscriptionFilters, WsOptions
+from polynode.ws import PolyNodeWS
+
+
+class FakeSocket:
+    def __init__(self) -> None:
+        self.sent: list[dict] = []
+
+    async def send(self, data: str) -> None:
+        self.sent.append(json.loads(data))
+
+
+def settlement_payload(tx_hash: str = "0xabc") -> dict:
+    return {
+        "event_type": "settlement",
+        "tx_hash": tx_hash,
+        "status": "pending",
+        "detected_at": 1234567890.0,
+        "taker_wallet": "0x123",
+        "taker_token": "0x456",
+        "taker_side": "BUY",
+        "taker_price": 0.55,
+        "taker_size": 100.0,
+        "trades": [],
+    }
+
+
+def test_snapshot_before_subscribed_is_replayed_to_late_handler():
+    async def scenario() -> None:
+        ws = PolyNodeWS("key", "wss://example.test/ws")
+        sub = Subscription(ws, "settlements", SubscriptionFilters())
+        fut = asyncio.get_running_loop().create_future()
+        ws._pending.append((sub, fut))
+
+        ws._handle_message(json.dumps({"type": "snapshot", "events": [{"data": settlement_payload()}]}))
+        assert not fut.done()
+
+        ws._handle_message(json.dumps({"type": "subscribed", "subscription_id": "sub-1"}))
+        returned = await asyncio.wait_for(fut, timeout=0.1)
+
+        replayed = []
+        returned.on("settlement", replayed.append)
+
+        queued = await asyncio.wait_for(returned.__anext__(), timeout=0.1)
+        assert returned.id == "sub-1"
+        assert queued.tx_hash == "0xabc"
+        assert [event.tx_hash for event in replayed] == ["0xabc"]
+
+    asyncio.run(scenario())
+
+
+def test_pre_ack_snapshot_only_routes_to_compatible_pending_subscription():
+    async def scenario() -> None:
+        ws = PolyNodeWS("key", "wss://example.test/ws")
+        sub = Subscription(ws, "trades", SubscriptionFilters())
+        fut = asyncio.get_running_loop().create_future()
+        ws._pending.append((sub, fut))
+
+        ws._handle_message(json.dumps({"type": "snapshot", "events": [{"data": settlement_payload()}]}))
+        ws._handle_message(json.dumps({"type": "subscribed", "subscription_id": "trade-sub"}))
+        await asyncio.wait_for(fut, timeout=0.1)
+
+        replayed = []
+        sub.on("*", replayed.append)
+        assert replayed == []
+        assert sub._queue.empty()
+
+    asyncio.run(scenario())
+
+
+def test_subscribe_timeout_uses_configured_timeout():
+    async def scenario() -> None:
+        ws = PolyNodeWS("key", "wss://example.test/ws", WsOptions(subscribe_timeout=0.01))
+        ws._socket = FakeSocket()
+        ws._connected = True
+
+        with pytest.raises(WsError, match="0.01 seconds"):
+            await ws.subscribe("settlements").send()
+
+        assert ws._socket.sent == [{"action": "subscribe", "type": "settlements"}]
+
+    asyncio.run(scenario())
+
+
+def test_disconnect_rejects_pending_subscriptions():
+    async def scenario() -> None:
+        ws = PolyNodeWS("key", "wss://example.test/ws")
+        sub = Subscription(ws, "settlements", SubscriptionFilters())
+        fut = asyncio.get_running_loop().create_future()
+        ws._pending.append((sub, fut))
+
+        ws._reject_pending(WsError("closed"))
+
+        with pytest.raises(WsError, match="closed"):
+            await fut
+        assert ws._pending == []
+
+    asyncio.run(scenario())

polynode-0.10.5/polynode/_version.py

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