polysimulator 0.4.1__tar.gz → 0.4.3__tar.gz

{polysimulator-0.4.1 → polysimulator-0.4.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: polysimulator
-Version: 0.4.1
-Summary: Python SDK for the PolySimulator paper-trading API, with py-clob-client v1 drop-in parity (not py-clob-client-v2) and a polysim_polymarket paper-mode mirror of Polymarket's unified py-sdk (polymarket-client 0.1.0b8).
+Version: 0.4.3
+Summary: Python SDK for the PolySimulator paper-trading API, with py-clob-client v1 drop-in parity (not py-clob-client-v2) and a polysim_polymarket paper-mode mirror of Polymarket's unified py-sdk (polymarket-client 0.1.0b13).
 Project-URL: Homepage, https://polysimulator.com
 Project-URL: Documentation, https://docs.polysimulator.com
 Project-URL: API Reference, https://api.polysimulator.com/docs
@@ -21,11 +21,12 @@ Classifier: Topic :: Office/Business :: Financial
 Requires-Python: >=3.10
 Requires-Dist: httpx<1,>=0.27
 Requires-Dist: pydantic<3,>=2
+Requires-Dist: typing-extensions>=4
 Requires-Dist: websockets<17,>=12
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == 'dev'
 Requires-Dist: mypy>=1.10; extra == 'dev'
-Requires-Dist: polymarket-client==0.1.0b8; extra == 'dev'
+Requires-Dist: polymarket-client==0.1.0b13; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=8; extra == 'dev'
 Requires-Dist: respx>=0.21; extra == 'dev'
@@ -39,9 +40,9 @@ Description-Content-Type: text/markdown
 [![Python versions](https://img.shields.io/pypi/pyversions/polysimulator.svg)](https://pypi.org/project/polysimulator/)
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
 [![py-clob-client compat](https://img.shields.io/badge/py--clob--client-v1%20drop--in-blue.svg)](https://github.com/Polymarket/py-clob-client)
-[![py-sdk mirror](https://img.shields.io/badge/polymarket--client-0.1.0b8%20mirror-blueviolet.svg)](https://pypi.org/project/polymarket-client/)
+[![py-sdk mirror](https://img.shields.io/badge/polymarket--client-0.1.0b13%20mirror-blueviolet.svg)](https://pypi.org/project/polymarket-client/)
 
-> **Mirrors Polymarket's unified py-sdk** — `polysim_polymarket` is a paper-mode mirror of [`polymarket-client`](https://pypi.org/project/polymarket-client/) **`0.1.0b8`**: sync + async PublicClient/SecureClient, trading, and core streams. Swap the import prefix + host + auth and your py-sdk bot runs on paper. [Compat matrix ↓](#compat-matrix)
+> **Mirrors Polymarket's unified py-sdk** — `polysim_polymarket` is a paper-mode mirror of [`polymarket-client`](https://pypi.org/project/polymarket-client/) **`0.1.0b13`**: sync + async PublicClient/SecureClient, trading, and core streams. Swap the import prefix + host + auth and your py-sdk bot runs on paper. [Compat matrix ↓](#compat-matrix)
 
 The official Python client for the [PolySimulator](https://polysimulator.com)
 paper-trading API. **One package, three import surfaces:**
@@ -295,7 +296,7 @@ paper-mode-native and not tied to any `py-clob-client` generation.
 |---|---|
 | `py-clob-client` v1 (`< 2.0`; latest `0.34.6`) | ✅ Drop-in via `polysim_clob_client` |
 | `py-clob-client-v2` (`1.0.x`) | ❌ Not supported — use `polysim_sdk`, or pin `py-clob-client<2` |
-| unified **py-sdk** (`polymarket-client`, import `polymarket`; `0.1.0b8`) | 🔶 **Paper-mode mirror** via `polysim_polymarket` — sync + async `PublicClient` / `SecureClient` (reads, account/auth, trading) + core streams; on-chain are paper no-ops and Gamma/Data reads are deferred. See [below](#polymarket-py-sdk-v2-mirror) and the [compat matrix](#compat-matrix) |
+| unified **py-sdk** (`polymarket-client`, import `polymarket`; `0.1.0b13`) | 🔶 **Paper-mode mirror** via `polysim_polymarket` — sync + async `PublicClient` / `SecureClient` (reads, account/auth, trading) + core streams; on-chain are paper no-ops and Gamma/Data reads are deferred. See [below](#polymarket-py-sdk-v2-mirror) and the [compat matrix](#compat-matrix) |
 
 The v2-only concepts — EIP-712 v2 signing, pUSD collateral, protocol-side fees,
 builder codes — have no analog in paper trading, so there is nothing to port:
@@ -334,7 +335,7 @@ The port is the same mechanical swap as v1 — change the import **prefix**, the
 - from polymarket import SecureClient
 + from polysim_polymarket import SecureClient
 
-- client = SecureClient(private_key="0x…")       # real Polymarket wallet + EIP-712 signing
+- client = SecureClient.create(private_key="0x…")  # real Polymarket wallet + EIP-712 signing
 + client = SecureClient(host="https://api.polysimulator.com", api_key="ps_live_…")
 
   # unchanged from here on — same method names, same keyword-only call shapes,
@@ -397,8 +398,13 @@ they're getting before they rely on a surface area:
   happens entirely in PolySimulator's paper matching engine.
 - **Collateral / balances are PAPER.** Your balance is PolySimulator's paper
   balance (the `balance` from `me()` on the native client), not an on-chain USDC
-  balance. `get_balance_allowance` reports the paper account's collateral; there
-  is no real USDC, no allowance/approval transaction, no funder wallet.
+  balance. `get_balance_allowance(asset_type="COLLATERAL")` reports the paper
+  account's cash collateral; `get_balance_allowance(asset_type="CONDITIONAL",
+  token_id=…)` reports the **conditional-token** balance — the open position's
+  share count for that token, in base units (matching real py-sdk, where a
+  CONDITIONAL read returns the held conditional token, not collateral; a flat
+  position is `0`). There is no real USDC, no allowance/approval transaction, no
+  funder wallet — so `allowances` is always empty.
 - **A settled trade carries the per-fill fee RATE, not a fee amount.**
   PolySimulator's matching engine charges and records a real (paper) fee on each
   fill. What it surfaces over the typed read surface is the fee *rate*: a settled
@@ -475,7 +481,7 @@ mirrored surface and respected the seams above.
 
 ### Compat matrix
 
-> Pinned to **`polymarket-client==0.1.0b8`** — parity is re-locked against this exact pin by the full-surface parity gate; when the pin bumps, this matrix + the badge bump with it.
+> Pinned to **`polymarket-client==0.1.0b13`** — parity is re-locked against this exact pin by the full-surface parity gate; when the pin bumps, this matrix + the badge bump with it.
 
 Support level for every py-sdk surface area, cross-checked against what's
 actually implemented in `polysim_polymarket`:

{polysimulator-0.4.1 → polysimulator-0.4.3}/README.md

@@ -4,9 +4,9 @@
 [![Python versions](https://img.shields.io/pypi/pyversions/polysimulator.svg)](https://pypi.org/project/polysimulator/)
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
 [![py-clob-client compat](https://img.shields.io/badge/py--clob--client-v1%20drop--in-blue.svg)](https://github.com/Polymarket/py-clob-client)
-[![py-sdk mirror](https://img.shields.io/badge/polymarket--client-0.1.0b8%20mirror-blueviolet.svg)](https://pypi.org/project/polymarket-client/)
+[![py-sdk mirror](https://img.shields.io/badge/polymarket--client-0.1.0b13%20mirror-blueviolet.svg)](https://pypi.org/project/polymarket-client/)
 
-> **Mirrors Polymarket's unified py-sdk** — `polysim_polymarket` is a paper-mode mirror of [`polymarket-client`](https://pypi.org/project/polymarket-client/) **`0.1.0b8`**: sync + async PublicClient/SecureClient, trading, and core streams. Swap the import prefix + host + auth and your py-sdk bot runs on paper. [Compat matrix ↓](#compat-matrix)
+> **Mirrors Polymarket's unified py-sdk** — `polysim_polymarket` is a paper-mode mirror of [`polymarket-client`](https://pypi.org/project/polymarket-client/) **`0.1.0b13`**: sync + async PublicClient/SecureClient, trading, and core streams. Swap the import prefix + host + auth and your py-sdk bot runs on paper. [Compat matrix ↓](#compat-matrix)
 
 The official Python client for the [PolySimulator](https://polysimulator.com)
 paper-trading API. **One package, three import surfaces:**
@@ -260,7 +260,7 @@ paper-mode-native and not tied to any `py-clob-client` generation.
 |---|---|
 | `py-clob-client` v1 (`< 2.0`; latest `0.34.6`) | ✅ Drop-in via `polysim_clob_client` |
 | `py-clob-client-v2` (`1.0.x`) | ❌ Not supported — use `polysim_sdk`, or pin `py-clob-client<2` |
-| unified **py-sdk** (`polymarket-client`, import `polymarket`; `0.1.0b8`) | 🔶 **Paper-mode mirror** via `polysim_polymarket` — sync + async `PublicClient` / `SecureClient` (reads, account/auth, trading) + core streams; on-chain are paper no-ops and Gamma/Data reads are deferred. See [below](#polymarket-py-sdk-v2-mirror) and the [compat matrix](#compat-matrix) |
+| unified **py-sdk** (`polymarket-client`, import `polymarket`; `0.1.0b13`) | 🔶 **Paper-mode mirror** via `polysim_polymarket` — sync + async `PublicClient` / `SecureClient` (reads, account/auth, trading) + core streams; on-chain are paper no-ops and Gamma/Data reads are deferred. See [below](#polymarket-py-sdk-v2-mirror) and the [compat matrix](#compat-matrix) |
 
 The v2-only concepts — EIP-712 v2 signing, pUSD collateral, protocol-side fees,
 builder codes — have no analog in paper trading, so there is nothing to port:
@@ -299,7 +299,7 @@ The port is the same mechanical swap as v1 — change the import **prefix**, the
 - from polymarket import SecureClient
 + from polysim_polymarket import SecureClient
 
-- client = SecureClient(private_key="0x…")       # real Polymarket wallet + EIP-712 signing
+- client = SecureClient.create(private_key="0x…")  # real Polymarket wallet + EIP-712 signing
 + client = SecureClient(host="https://api.polysimulator.com", api_key="ps_live_…")
 
   # unchanged from here on — same method names, same keyword-only call shapes,
@@ -362,8 +362,13 @@ they're getting before they rely on a surface area:
   happens entirely in PolySimulator's paper matching engine.
 - **Collateral / balances are PAPER.** Your balance is PolySimulator's paper
   balance (the `balance` from `me()` on the native client), not an on-chain USDC
-  balance. `get_balance_allowance` reports the paper account's collateral; there
-  is no real USDC, no allowance/approval transaction, no funder wallet.
+  balance. `get_balance_allowance(asset_type="COLLATERAL")` reports the paper
+  account's cash collateral; `get_balance_allowance(asset_type="CONDITIONAL",
+  token_id=…)` reports the **conditional-token** balance — the open position's
+  share count for that token, in base units (matching real py-sdk, where a
+  CONDITIONAL read returns the held conditional token, not collateral; a flat
+  position is `0`). There is no real USDC, no allowance/approval transaction, no
+  funder wallet — so `allowances` is always empty.
 - **A settled trade carries the per-fill fee RATE, not a fee amount.**
   PolySimulator's matching engine charges and records a real (paper) fee on each
   fill. What it surfaces over the typed read surface is the fee *rate*: a settled
@@ -440,7 +445,7 @@ mirrored surface and respected the seams above.
 
 ### Compat matrix
 
-> Pinned to **`polymarket-client==0.1.0b8`** — parity is re-locked against this exact pin by the full-surface parity gate; when the pin bumps, this matrix + the badge bump with it.
+> Pinned to **`polymarket-client==0.1.0b13`** — parity is re-locked against this exact pin by the full-surface parity gate; when the pin bumps, this matrix + the badge bump with it.
 
 Support level for every py-sdk surface area, cross-checked against what's
 actually implemented in `polysim_polymarket`:

{polysimulator-0.4.1 → polysimulator-0.4.3}/polysim_clob_client/__init__.py

@@ -30,9 +30,11 @@ from polysim_clob_client.constants import (
     ZERO_ADDRESS,
 )
 from polysim_clob_client.exceptions import PolyApiException, PolyException
+from polysim_sdk import __version__
 
 __all__ = [
     "ClobClient",
+    "__version__",
     "ApiCreds",
     "AssetType",
     "BalanceAllowanceParams",

{polysimulator-0.4.1 → polysimulator-0.4.3}/polysim_clob_client/client.py

@@ -664,7 +664,8 @@ class ClobClient:
         order_type: OrderType | str | None,
         post_only: bool = False,
     ) -> dict[str, Any]:
-        tif = order.get("time_in_force", "GTC")
+        embedded_tif = str(order.get("time_in_force", "GTC"))
+        tif = embedded_tif
         if order_type is not None:
             tif = order_type.value if hasattr(order_type, "value") else str(order_type)
         # An embedded expiration means GTD was intended (e.g. a `create_order`
@@ -674,6 +675,17 @@ class ClobClient:
         # Never downgrade an expiring order to GTC.
         if order.get("expiration") and tif.upper() == "GTC":
             tif = "GTD"
+        # A MARKET order is a marketable-limit FOK/FAK; `create_market_order`
+        # embeds that tif. `post_order` defaults `orderType` to GTC, which would
+        # otherwise ship the contradictory `order_type=market, time_in_force=GTC`
+        # shape. When the caller left `orderType` at the GTC default, preserve the
+        # embedded FOK/FAK; an EXPLICIT FOK/FAK/GTD (anything but GTC) still wins.
+        if (
+            order.get("order_type") == "market"
+            and tif.upper() == "GTC"
+            and embedded_tif.upper() in ("FOK", "FAK")
+        ):
+            tif = embedded_tif
         return self._client.place_order(
             market_id=order["market_id"],
             side=order["side"],
@@ -713,7 +725,24 @@ class ClobClient:
         bodies: list[dict[str, Any]] = []
         for a in args:
             order = dict(a.order)
+            embedded_tif = str(order.get("time_in_force", "GTC"))
             tif = a.orderType.value if hasattr(a.orderType, "value") else str(a.orderType)
+            # Mirror _submit's GTD guard: an embedded expiration means GTD was
+            # intended (a `create_order(expiration=...)` order). `PostOrdersArgs`
+            # defaults `orderType` to GTC, which would otherwise downgrade the
+            # order to a contradictory GTC+expiration shape. Never downgrade an
+            # expiring order to GTC (an explicit non-GTC orderType still wins —
+            # exactly as `_submit` orders the two guards).
+            if order.get("expiration") and tif.upper() == "GTC":
+                tif = "GTD"
+            # Mirror _submit: a market order's embedded FOK/FAK must survive the
+            # GTC default of PostOrdersArgs.orderType (an explicit non-GTC wins).
+            if (
+                order.get("order_type") == "market"
+                and tif.upper() == "GTC"
+                and embedded_tif.upper() in ("FOK", "FAK")
+            ):
+                tif = embedded_tif
             order["time_in_force"] = tif
             if getattr(a, "postOnly", False):
                 order["post_only"] = True
@@ -751,12 +780,21 @@ class ClobClient:
         return self._client.cancel_all()
 
     def cancel_market_orders(self, market: str = "", asset_id: str = "") -> dict[str, Any]:
-        """adapt — cancel all orders in a market (``DELETE /v1/cancel-market-orders``)."""
+        """adapt — cancel all orders in a market (``DELETE /v1/cancel-market-orders``).
+
+        When only ``asset_id`` is given it is resolved to its market id via
+        :meth:`_resolve_token` (NOT the local-only ``_split_token``): a real
+        Polymarket CLOB outcome-token id (a long all-digit string) is
+        reverse-resolved through ``GET /v1/markets-by-token`` so the cancel scopes
+        the right condition id — a local split would treat the whole digit string
+        as the market and cancel the wrong (or no) market. The colon form and
+        short/non-numeric ids still resolve locally with no network call.
+        """
         market_id = market or asset_id
         if not market_id:
             raise PolyApiException(400, "cancel_market_orders requires market or asset_id.")
         if asset_id and not market:
-            market_id, _ = self._split_token(asset_id)
+            market_id, _ = self._resolve_token(asset_id)
         return self._client.cancel_market_orders(market_id)
 
     # ── order / trade reads ────────────────────────────────────────────────

{polysimulator-0.4.1 → polysimulator-0.4.3}/polysim_polymarket/__init__.py

@@ -23,7 +23,7 @@ This ships the full mirrored surface: sync + async ``PublicClient`` /
 ``SecureClient`` covering CLOB market-data reads, account/auth, and the trading
 write surface, plus on-chain paper no-ops, rewards/builder/RFQ stubs, and the
 core realtime streams (``market`` / ``user`` / ``crypto_prices``) — a paper-mode
-mirror of ``polymarket-client`` ``0.1.0b8``, returning typed pydantic models.
+mirror of ``polymarket-client`` ``0.1.0b13``, returning typed pydantic models.
 """
 
 from __future__ import annotations
@@ -111,7 +111,9 @@ from polysim_polymarket.rfq import (
     RfqRequestorPublicId,
     RfqSession,
     RfqSide,
+    RfqTradeEvent,
 )
+from polysim_sdk import __version__
 
 # py-sdk exports ``SyncTransactionHandle`` (a ``TypeAlias`` for the
 # gasless|EOA sync-handle union) off its root; a ported bot type-hints
@@ -151,6 +153,7 @@ from polysim_polymarket.rfq import (
 # Each is verified present on py-sdk's root by the re-export subset test.
 __all__ = [
     "PRODUCTION",
+    "__version__",
     "AcceptedOrder",
     "ApiKeyCreds",
     "AssetType",
@@ -219,6 +222,7 @@ __all__ = [
     "RfqRequestorPublicId",
     "RfqSession",
     "RfqSide",
+    "RfqTradeEvent",
     "SecureClient",
     "SignedOrder",
     "SyncTransactionHandle",

{polysimulator-0.4.1 → polysimulator-0.4.3}/polysim_polymarket/clients/_account.py

@@ -17,6 +17,7 @@ authenticated-surface logic the public client has no analog for.
 from __future__ import annotations
 
 from collections.abc import Sequence
+from decimal import Decimal, InvalidOperation
 from typing import Any
 
 from polysim_polymarket.errors import UnexpectedResponseError, UserInputError
@@ -69,8 +70,13 @@ def validate_asset_type(asset_type: object) -> None:
     Mirrors py-sdk's ``account._validate_asset_type`` (case-SENSITIVE — there is
     no ``.upper()``): anything else raises ``UserInputError`` with py-sdk's exact
     message, before any read.
+
+    The ``isinstance(asset_type, str)`` guard runs FIRST so an unhashable arg (a
+    ``list`` / ``dict`` a bot might pass by mistake) raises ``UserInputError``
+    rather than letting a ``TypeError`` escape the ``in`` membership test against
+    the frozenset.
     """
-    if asset_type not in VALID_ASSET_TYPES:
+    if not isinstance(asset_type, str) or asset_type not in VALID_ASSET_TYPES:
         raise UserInputError(
             f"asset_type must be 'COLLATERAL' or 'CONDITIONAL', got {asset_type!r}."
         )
@@ -118,6 +124,11 @@ def adapt_balance_allowance(payload: Any) -> BalanceAllowance:
     nearest base unit. Paper trading has no on-chain allowance, so ``allowances``
     is empty.
 
+    The scaling goes through :class:`~decimal.Decimal` (``Decimal(str(raw))``),
+    not ``float``, so a monetary value with binary-float drift (e.g. a value
+    whose ``float * 1e6`` would round to the wrong base-unit count) converts
+    exactly — money never rides a binary float through this adapter.
+
     A malformed payload (not a dict, or no numeric balance field) raises
     ``UnexpectedResponseError`` rather than silently reporting zero — a porting
     author should see the shape mismatch, not a wrong $0 balance.
@@ -132,12 +143,51 @@ def adapt_balance_allowance(payload: Any) -> BalanceAllowance:
     if raw is None:
         raise UnexpectedResponseError("balance response did not match expected shape")
     try:
-        usd = float(raw)
-    except (TypeError, ValueError) as error:
+        # ``Decimal(str(raw))`` keeps full decimal precision (str() avoids the
+        # binary-float artefacts of Decimal(<float>)); round half-even to the
+        # nearest integer base unit.
+        usd = Decimal(str(raw))
+    except (TypeError, ValueError, InvalidOperation) as error:
         raise UnexpectedResponseError(
             f"balance response 'balance' was not numeric: {raw!r}"
         ) from error
-    base_units = round(usd * USDC_BASE_UNITS_PER_USD)
+    base_units = int(round(usd * USDC_BASE_UNITS_PER_USD))
+    return BalanceAllowance(balance=base_units, allowances={})
+
+
+def adapt_conditional_balance(
+    positions: Any, market_id: str, outcome: str
+) -> BalanceAllowance:
+    """Adapt the open-positions list onto a CONDITIONAL ``BalanceAllowance``.
+
+    Resolution of the CodeRabbit/Codex disagreement: the real py-sdk's
+    ``get_balance_allowance`` for ``asset_type='CONDITIONAL'`` returns the
+    **conditional TOKEN** balance the server holds for that ``token_id`` (the
+    position's share count), NOT collateral cash. PolySimulator is paper trading
+    with no on-chain CTF balance, so the faithful analog is the open position's
+    share count for the resolved ``(market_id, outcome)`` — the conditional token
+    Polymarket would settle. Both the conditional token and USDC carry 6 decimals,
+    so the share count scales by :data:`USDC_BASE_UNITS_PER_USD`; a flat / absent
+    position is a genuine 0 conditional balance (not an error). Outcome matching
+    is case-insensitive (positions store ``"Yes"`` / ``"No"``; the token resolver
+    returns ``"YES"`` / ``"NO"`` / ``"UP"`` / ``"DOWN"``). Paper trading has no
+    on-chain allowance, so ``allowances`` is empty.
+    """
+    rows = positions if isinstance(positions, list) else []
+    target_outcome = outcome.upper()
+    shares = Decimal("0")
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        if str(row.get("market_id")) != str(market_id):
+            continue
+        if str(row.get("outcome", "")).upper() != target_outcome:
+            continue
+        try:
+            shares += Decimal(str(row.get("quantity", "0")))
+        except (TypeError, ValueError, InvalidOperation):
+            continue
+    base_units = int(round(shares * USDC_BASE_UNITS_PER_USD))
     return BalanceAllowance(balance=base_units, allowances={})
 
 

{polysimulator-0.4.1 → polysimulator-0.4.3}/polysim_polymarket/clients/_common.py

@@ -571,3 +571,20 @@ def list_markets_forward(
     if ascending is not None:
         forward["ascending"] = ascending
     return forward
+
+
+def resolve_page_size(page_size: int) -> int:
+    """Validate + clamp a ``list_markets`` page size to the effective request limit.
+
+    Mirrors py-sdk's ``paginate_offset`` guard — a ``page_size < 1`` raises
+    ``UserInputError("page_size must be a positive integer.")`` (a non-int /
+    bool is also rejected). PolySimulator's ``/v1/markets`` hard-caps a page at
+    :data:`PAGE_LIMIT` (100) rows, so a larger ``page_size`` is clamped down to
+    that ceiling — the returned value is the effective ``limit`` the fetch +
+    cursor boundary use, so ``page_size`` is honoured rather than ignored.
+    """
+    if not isinstance(page_size, int) or isinstance(page_size, bool):
+        raise UserInputError("page_size must be a positive integer.")
+    if page_size < 1:
+        raise UserInputError("page_size must be a positive integer.")
+    return min(page_size, PAGE_LIMIT)

{polysimulator-0.4.1 → polysimulator-0.4.3}/polysim_polymarket/clients/_trade.py

@@ -58,10 +58,11 @@ DEFAULT_SELL_WORST_PRICE = Decimal("0.01")
 _VALID_MARKET_ORDER_TYPES = frozenset({"FAK", "FOK"})
 
 # py-sdk requires a GTD ``expiration`` to be an ABSOLUTE Unix timestamp at least
-# this many seconds in the future (``limit._MIN_EXPIRATION_BUFFER_S``); a sub-60s
-# or past timestamp is rejected before any request. We mirror the constant + rule
-# + message so a ported bot's bad-expiration call raises identically.
-_MIN_EXPIRATION_BUFFER_S = 60
+# this many seconds in the future (``limit._MIN_EXPIRATION_BUFFER_S``); a sub-180s
+# or past timestamp is rejected before any request. py-sdk b13 raised this floor
+# from 60s to 180s (3-minute minimum GTD). We mirror the constant + rule + message
+# so a ported bot's bad-expiration call raises identically.
+_MIN_EXPIRATION_BUFFER_S = 180
 
 # A long all-digit token id is a real Polymarket CLOB outcome-token id (not a
 # PolySim condition id); it needs reverse-resolution via the network. Matches the
@@ -138,6 +139,27 @@ _ACCEPTED_STATUS_MAP: dict[str, str] = {
     "queued": "delayed",
 }
 
+# Coarse backend rejection statuses with no finer py-sdk error code. ``/v1/orders``
+# (and the per-row ``/v1/orders/batch`` entries) can return HTTP 200 with a row
+# whose status is ``REJECTED`` / ``ERROR`` / ``FAILED`` / ``CANCELLED``. These map
+# to a RejectedOrder with the "unknown" catch-all code (the more specific statuses
+# in ``_STATUS_TO_ERROR_CODE`` keep their codes). Kept for naming clarity even
+# though acceptance is now decided by the allowlist below, not this denylist —
+# any status outside the accepted set is rejected regardless.
+_REJECTED_STATUSES: frozenset[str] = frozenset(
+    {"rejected", "error", "failed", "cancelled", "canceled"}
+)
+
+# Acceptance ALLOWLIST — mirrors py-sdk's ``order_response._is_accepted``. The real
+# py-sdk accepts a row ONLY when ``status in {live, matched, delayed}`` AND
+# ``success`` is truthy AND ``order_id != ''`` AND ``error_msg == ''``. We project
+# the paper backend's wider status vocabulary onto those three post-statuses via
+# ``_ACCEPTED_STATUS_MAP``, so the mirror's accepted set is exactly the keys of
+# that map. An UNKNOWN / unexpected status is therefore NOT accepted (it falls
+# through to RejectedOrder), matching py-sdk's strict allowlist rather than the
+# previous denylist (which mistook an unrecognised status for ``matched``).
+_ACCEPTED_STATUSES: frozenset[str] = frozenset(_ACCEPTED_STATUS_MAP)
+
 
 # ── numeric / side validation ────────────────────────────────────────────────
 # ``coerce_positive_decimal`` + ``validate_side`` are NOT re-implemented here:
@@ -149,7 +171,14 @@ _ACCEPTED_STATUS_MAP: dict[str, str] = {
 # not import ``_trade``.
 
 
-def _validate_token_id(token_id: object) -> str:
+def validate_token_id(token_id: object) -> str:
+    """Reject a non-string / empty ``token_id`` like py-sdk's token guard.
+
+    A non-``str`` raises ``"token_id must be a string, got <type>."`` and an
+    empty string raises ``"token_id is required"``. Public so the secure client
+    can validate a token UP FRONT — before any reverse-resolution network call —
+    rather than only inside ``build_*_order`` after resolution.
+    """
     if not isinstance(token_id, str):
         raise UserInputError(f"token_id must be a string, got {type(token_id).__name__}.")
     if not token_id:
@@ -210,7 +239,7 @@ def build_limit_order(
     Returns a ``SignedOrder`` carrying the trading-semantic fields + the unsigned
     paper body; signing fields stay empty placeholders.
     """
-    _validate_token_id(token_id)
+    validate_token_id(token_id)
     validated_price = coerce_positive_decimal("price", price)
     validated_size = coerce_positive_decimal("size", size)
     validate_side(side)
@@ -221,8 +250,8 @@ def build_limit_order(
             raise UserInputError("expiration must be a non-negative integer.")
         if expiration < 0:
             raise UserInputError("expiration must be a non-negative integer.")
-        # py-sdk: an ABSOLUTE Unix ts must be ≥ now + 60s. Layered AFTER the
-        # non-negative check, exactly as py-sdk orders the two guards.
+        # py-sdk: an ABSOLUTE Unix ts must be ≥ now + 180s (b13's 3-min floor).
+        # Layered AFTER the non-negative check, exactly as py-sdk orders the two guards.
         minimum = int(time.time()) + _MIN_EXPIRATION_BUFFER_S
         if expiration < minimum:
             raise UserInputError(
@@ -232,14 +261,18 @@ def build_limit_order(
 
     gtd_expiration = expiration if expiration is not None and expiration > 0 else 0
     order_type = "GTD" if gtd_expiration > 0 else "GTC"
+    # Serialize the monetary/size fields as decimal STRINGS, not floats: the
+    # backend's order body is a string-decimal contract, and a float would let
+    # binary-float drift (e.g. 0.1) ride onto the wire. ``str(Decimal(...))``
+    # carries the exact decimal the caller gave.
     body: dict[str, Any] = {
         "market_id": market_id,
         "outcome": outcome,
         "side": side,
-        "price": float(validated_price),
+        "price": str(validated_price),
         "order_type": "limit",
         "time_in_force": order_type,
-        "quantity": float(validated_size),
+        "quantity": str(validated_size),
     }
     if post_only:
         body["post_only"] = True
@@ -288,7 +321,7 @@ def build_market_order(
     when given, else the :data:`DEFAULT_BUY_WORST_PRICE` /
     :data:`DEFAULT_SELL_WORST_PRICE` default — so the FOK/FAK is never uncapped.
     """
-    _validate_token_id(token_id)
+    validate_token_id(token_id)
     validate_side(side)
     if order_type not in _VALID_MARKET_ORDER_TYPES:
         raise UserInputError(f"order_type must be 'FAK' or 'FOK', got {order_type!r}.")
@@ -319,9 +352,10 @@ def build_market_order(
             if max_price is not None
             else DEFAULT_BUY_WORST_PRICE
         )
-        # USD notional for a market BUY -> sent as ``amount`` (server derives shares).
-        body["amount"] = float(validated_amount)
-        body["price"] = float(cap)
+        # USD notional for a market BUY -> sent as ``amount`` (server derives
+        # shares). Serialized as a decimal string (string-decimal contract).
+        body["amount"] = str(validated_amount)
+        body["price"] = str(cap)
     else:  # SELL
         if shares is None:
             raise UserInputError("shares is required for SELL market orders.")
@@ -337,9 +371,9 @@ def build_market_order(
             if min_price is not None
             else DEFAULT_SELL_WORST_PRICE
         )
-        # Share count for a market SELL -> sent as ``quantity``.
-        body["quantity"] = float(validated_shares)
-        body["price"] = float(cap)
+        # Share count for a market SELL -> sent as ``quantity`` (decimal string).
+        body["quantity"] = str(validated_shares)
+        body["price"] = str(cap)
 
     return _make_signed_order(
         token_id=token_id,
@@ -414,11 +448,16 @@ def adapt_order_response(raw: Any) -> OrderResponse:
     """Adapt a PolySim ``POST /v1/orders`` reply onto py-sdk's ``OrderResponse``.
 
     A malformed reply (not a dict) raises ``UnexpectedResponseError``. Otherwise
-    we read the order id + status and decide accepted vs rejected: an explicit
-    ``success: false`` (or a recognised error status) yields a
-    :class:`RejectedOrder` with a mapped :data:`OrderResponseErrorCode`; anything
-    else is an :class:`AcceptedOrder`. Field names track py-sdk so a ported bot's
-    ``resp.ok`` / ``resp.order_id`` / ``resp.status`` read identically.
+    we decide accepted vs rejected with py-sdk's strict ALLOWLIST
+    (``order_response._is_accepted``): a row is an :class:`AcceptedOrder` ONLY when
+    its status is a recognised accepted post-status AND ``success`` is not
+    explicitly false AND it carries a non-empty ``order_id`` AND no error message —
+    exactly py-sdk's ``status in {live, matched, delayed} AND success AND
+    order_id != '' AND error_msg == ''``. ANYTHING else (including an UNKNOWN /
+    unexpected status the backend never documented) is a :class:`RejectedOrder`
+    with a mapped :data:`OrderResponseErrorCode` (specific codes for the known
+    rejection statuses, ``"unknown"`` otherwise). Field names track py-sdk so a
+    ported bot's ``resp.ok`` / ``resp.order_id`` / ``resp.status`` read identically.
     """
     if not isinstance(raw, dict):
         raise UnexpectedResponseError("order response did not match expected shape")
@@ -427,13 +466,23 @@ def adapt_order_response(raw: Any) -> OrderResponse:
     status_key = status_raw.lower()
     success = raw.get("success")
     order_id = str(raw.get("order_id", "") or raw.get("id", "") or "")
+    error_message = str(
+        raw.get("error") or raw.get("message") or raw.get("detail") or ""
+    )
 
-    rejected = success is False or status_key in _STATUS_TO_ERROR_CODE
-    if rejected:
+    # py-sdk allowlist: accepted requires ALL four — a recognised accepted status,
+    # success not explicitly false, a non-empty order id, and no error message.
+    # (The paper backend omits ``success`` on accepted rows, so absence is truthy;
+    # only an explicit ``success: false`` rejects on that axis.)
+    accepted = (
+        status_key in _ACCEPTED_STATUSES
+        and success is not False
+        and order_id != ""
+        and error_message == ""
+    )
+    if not accepted:
         code = _STATUS_TO_ERROR_CODE.get(status_key, "unknown")
-        message = str(
-            raw.get("error") or raw.get("message") or raw.get("detail") or status_raw or "rejected"
-        )
+        message = error_message or status_raw or "rejected"
         return RejectedOrder(code=code, message=message)
 
     return AcceptedOrder(
@@ -517,4 +566,5 @@ __all__ = [
     "paper_order_kwargs",
     "split_token_local",
     "validate_cancel_order_ids",
+    "validate_token_id",
 ]

{polysimulator-0.4.1 → polysimulator-0.4.3}/polysim_polymarket/clients/async_public.py

@@ -433,18 +433,15 @@ class AsyncPublicClient:
         parity and ignored.
         """
         forward = _common.list_markets_forward(closed=closed, order=order, ascending=ascending)
+        limit = _common.resolve_page_size(page_size)
 
         async def fetch(cursor: str | None) -> Page[Market]:
             offset = _decode_cursor(cursor)
             if offset < 0:
                 return Page(items=(), has_more=False)
-            rows = await self._client.list_markets(
-                limit=_common.PAGE_LIMIT, offset=offset, **forward
-            )
+            rows = await self._client.list_markets(limit=limit, offset=offset, **forward)
             items = tuple(_common.adapt_market(row) for row in rows)
-            next_cur = _next_cursor(offset, len(rows), _common.PAGE_LIMIT)
-            return Page(
-                items=items, has_more=len(rows) >= _common.PAGE_LIMIT, next_cursor=next_cur
-            )
+            next_cur = _next_cursor(offset, len(rows), limit)
+            return Page(items=items, has_more=len(rows) >= limit, next_cursor=next_cur)
 
         return AsyncPaginator(fetch=fetch)