polysimulator 0.4.0__tar.gz → 0.4.2__tar.gz

{polysimulator-0.4.0 → polysimulator-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polysimulator
-Version: 0.4.0
+Version: 0.4.2
 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).
 Project-URL: Homepage, https://polysimulator.com
 Project-URL: Documentation, https://docs.polysimulator.com
@@ -21,6 +21,7 @@ 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'
@@ -236,6 +237,39 @@ network, tolerant of missing fields): `seconds_to_expiry`, `is_window_open`,
 `INTERVALS` vocab tuples. For a **streaming** tap on the underlying, see
 [SSE: live underlying spot](#sse-live-underlying-spot) below.
 
+### New-market warm-up: retry order placement on a 404
+
+A **brand-new** market — especially the 5m Up/Down windows that roll every few
+minutes — has a short window after creation before it enters the
+order-validation catalog. An order placed in that window transiently fails with
+a `404` (`code="MARKET_NOT_FOUND"`). The window is short — on the order of ~30s,
+the Up/Down roll cadence — but it is a cadence, **not** a guarantee.
+
+The SDK does **not** auto-retry 404s (by design — a 404 is normally permanent),
+so a bot trading freshly-rolled markets should catch and retry that one signal
+with backoff. The native client ships a small opt-in helper that retries **only**
+the warm-up 404 and re-raises everything else (and the 404 itself once the budget
+is spent):
+
+```python
+from polysim_sdk import PolySimClient, retry_on_market_warmup
+
+with PolySimClient() as client:
+    fill = retry_on_market_warmup(
+        lambda: client.place_order(
+            market_id=cid, side="BUY", outcome="Up", amount="10", price="0.99",
+        ),
+        attempts=6, base_delay=2.0,   # ~2,4,8,16,30s capped backoff between tries
+    )
+```
+
+It wraps any zero-argument callable, so the same helper works with a
+`polysim_clob_client` drop-in call (e.g.
+`retry_on_market_warmup(lambda: clob.create_and_post_order(args))`); the drop-in
+surfaces the same condition as a `PolyApiException` with `status_code == 404`.
+See [Errors](#errors) for the standalone retry-on-404 pattern if you'd rather
+roll your own.
+
 ---
 
 ## Polymarket compatibility
@@ -301,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,
@@ -364,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
@@ -802,11 +841,14 @@ Every method maps by one of three strategies:
 `py-clob-client` addresses a single outcome token by `token_id`; PolySimulator
 addresses a **market plus an outcome**. The seam: a bare `token_id` is treated as
 the market id with outcome `YES`. Append `":NO"` or `":YES"` to target the other
-side explicitly.
+side explicitly. **Up/Down markets** carry `Up`/`Down` outcomes, so the same
+colon form also accepts `":UP"` / `":DOWN"` (case-insensitive); the backend
+matches the order outcome case-insensitively, so either case is accepted.
 
 ```python
 client.create_order(OrderArgs(token_id="0xMARKET",     ...))  # → market 0xMARKET, YES
 client.create_order(OrderArgs(token_id="0xMARKET:NO",  ...))  # → market 0xMARKET, NO
+client.create_order(OrderArgs(token_id="0xUPDOWN:UP",  ...))  # → Up/Down market, UP
 ```
 
 **Reads are true-token-parity; writes use the market+outcome model.** This is an
@@ -829,8 +871,9 @@ intentional asymmetry:
   order loudly — it never silently places a different one.
 
 If you only ever pass real outcome-token ids (the `py-clob-client` norm), reads
-"just work" with full parity. The `:YES`/`:NO` suffix exists for callers who
-prefer to address PolySimulator markets by condition id directly.
+"just work" with full parity. The `:YES`/`:NO` suffix (and `:UP`/`:DOWN` for
+Up/Down markets) exists for callers who prefer to address PolySimulator markets
+by condition id directly.
 
 ### Orders are never signed
 
@@ -947,6 +990,66 @@ The client paces itself (a 50 ms floor between requests) and backs off on
 `429`/`425`/`5xx` using `Retry-After`. Opt out with `floor_interval=0.0` and
 `max_retries=0` to handle pacing yourself.
 
+### New-market warm-up `404` (retry-on-404)
+
+The SDK auto-retries `429`/`5xx` but **never** a `404` — a 404 is normally
+permanent. The one benign exception is a **freshly-created market** (most often
+a 5m Up/Down window): for a short window after creation — on the order of ~30s,
+the Up/Down roll cadence, though not a guarantee — it is not yet in the
+order-validation catalog and order placement transiently fails with
+`ApiError(status_code=404, code="MARKET_NOT_FOUND")`. Retry **only** that signal,
+with backoff; re-raise any other error (including a 404 with a different `code`,
+which is a real "not found").
+
+Use the shipped helper (recommended) …
+
+```python
+from polysim_sdk import PolySimClient, retry_on_market_warmup
+
+with PolySimClient() as client:
+    fill = retry_on_market_warmup(
+        lambda: client.place_order(
+            market_id=cid, side="BUY", outcome="Up", amount="10", price="0.99",
+        ),
+        attempts=6, base_delay=2.0,
+    )
+```
+
+… or roll your own on the native `ApiError`:
+
+```python
+import time
+from polysim_sdk import ApiError
+
+for i in range(6):
+    try:
+        fill = client.place_order(market_id=cid, side="BUY", outcome="Up",
+                                  amount="10", price="0.99")
+        break
+    except ApiError as exc:
+        if exc.status_code == 404 and exc.code == "MARKET_NOT_FOUND" and i < 5:
+            time.sleep(min(2.0 * 2**i, 30.0))   # capped backoff, then retry
+            continue
+        raise   # any other error — and the final 404 — propagates
+```
+
+With the **`polysim_clob_client` drop-in**, the same condition surfaces as a
+`PolyApiException` with `status_code == 404`; catch it and retry the same way (or
+pass your drop-in call to `retry_on_market_warmup(lambda: clob.create_and_post_order(...))`,
+which works with any callable):
+
+```python
+from polysim_clob_client.exceptions import PolyApiException
+
+try:
+    resp = clob.create_and_post_order(order_args)
+except PolyApiException as exc:
+    if exc.status_code == 404 and getattr(exc, "code", None) == "MARKET_NOT_FOUND":
+        ...  # warm-up — retry with backoff
+    else:
+        raise   # any other error — including a 404 with a different code — propagates
+```
+
 ### Troubleshooting: `error code: 1010` / blocked User-Agent
 
 If a raw HTTP call returns **HTTP 403** with the body `error code: 1010`, the

{polysimulator-0.4.0 → polysimulator-0.4.2}/README.md

@@ -201,6 +201,39 @@ network, tolerant of missing fields): `seconds_to_expiry`, `is_window_open`,
 `INTERVALS` vocab tuples. For a **streaming** tap on the underlying, see
 [SSE: live underlying spot](#sse-live-underlying-spot) below.
 
+### New-market warm-up: retry order placement on a 404
+
+A **brand-new** market — especially the 5m Up/Down windows that roll every few
+minutes — has a short window after creation before it enters the
+order-validation catalog. An order placed in that window transiently fails with
+a `404` (`code="MARKET_NOT_FOUND"`). The window is short — on the order of ~30s,
+the Up/Down roll cadence — but it is a cadence, **not** a guarantee.
+
+The SDK does **not** auto-retry 404s (by design — a 404 is normally permanent),
+so a bot trading freshly-rolled markets should catch and retry that one signal
+with backoff. The native client ships a small opt-in helper that retries **only**
+the warm-up 404 and re-raises everything else (and the 404 itself once the budget
+is spent):
+
+```python
+from polysim_sdk import PolySimClient, retry_on_market_warmup
+
+with PolySimClient() as client:
+    fill = retry_on_market_warmup(
+        lambda: client.place_order(
+            market_id=cid, side="BUY", outcome="Up", amount="10", price="0.99",
+        ),
+        attempts=6, base_delay=2.0,   # ~2,4,8,16,30s capped backoff between tries
+    )
+```
+
+It wraps any zero-argument callable, so the same helper works with a
+`polysim_clob_client` drop-in call (e.g.
+`retry_on_market_warmup(lambda: clob.create_and_post_order(args))`); the drop-in
+surfaces the same condition as a `PolyApiException` with `status_code == 404`.
+See [Errors](#errors) for the standalone retry-on-404 pattern if you'd rather
+roll your own.
+
 ---
 
 ## Polymarket compatibility
@@ -266,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,
@@ -329,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
@@ -767,11 +805,14 @@ Every method maps by one of three strategies:
 `py-clob-client` addresses a single outcome token by `token_id`; PolySimulator
 addresses a **market plus an outcome**. The seam: a bare `token_id` is treated as
 the market id with outcome `YES`. Append `":NO"` or `":YES"` to target the other
-side explicitly.
+side explicitly. **Up/Down markets** carry `Up`/`Down` outcomes, so the same
+colon form also accepts `":UP"` / `":DOWN"` (case-insensitive); the backend
+matches the order outcome case-insensitively, so either case is accepted.
 
 ```python
 client.create_order(OrderArgs(token_id="0xMARKET",     ...))  # → market 0xMARKET, YES
 client.create_order(OrderArgs(token_id="0xMARKET:NO",  ...))  # → market 0xMARKET, NO
+client.create_order(OrderArgs(token_id="0xUPDOWN:UP",  ...))  # → Up/Down market, UP
 ```
 
 **Reads are true-token-parity; writes use the market+outcome model.** This is an
@@ -794,8 +835,9 @@ intentional asymmetry:
   order loudly — it never silently places a different one.
 
 If you only ever pass real outcome-token ids (the `py-clob-client` norm), reads
-"just work" with full parity. The `:YES`/`:NO` suffix exists for callers who
-prefer to address PolySimulator markets by condition id directly.
+"just work" with full parity. The `:YES`/`:NO` suffix (and `:UP`/`:DOWN` for
+Up/Down markets) exists for callers who prefer to address PolySimulator markets
+by condition id directly.
 
 ### Orders are never signed
 
@@ -912,6 +954,66 @@ The client paces itself (a 50 ms floor between requests) and backs off on
 `429`/`425`/`5xx` using `Retry-After`. Opt out with `floor_interval=0.0` and
 `max_retries=0` to handle pacing yourself.
 
+### New-market warm-up `404` (retry-on-404)
+
+The SDK auto-retries `429`/`5xx` but **never** a `404` — a 404 is normally
+permanent. The one benign exception is a **freshly-created market** (most often
+a 5m Up/Down window): for a short window after creation — on the order of ~30s,
+the Up/Down roll cadence, though not a guarantee — it is not yet in the
+order-validation catalog and order placement transiently fails with
+`ApiError(status_code=404, code="MARKET_NOT_FOUND")`. Retry **only** that signal,
+with backoff; re-raise any other error (including a 404 with a different `code`,
+which is a real "not found").
+
+Use the shipped helper (recommended) …
+
+```python
+from polysim_sdk import PolySimClient, retry_on_market_warmup
+
+with PolySimClient() as client:
+    fill = retry_on_market_warmup(
+        lambda: client.place_order(
+            market_id=cid, side="BUY", outcome="Up", amount="10", price="0.99",
+        ),
+        attempts=6, base_delay=2.0,
+    )
+```
+
+… or roll your own on the native `ApiError`:
+
+```python
+import time
+from polysim_sdk import ApiError
+
+for i in range(6):
+    try:
+        fill = client.place_order(market_id=cid, side="BUY", outcome="Up",
+                                  amount="10", price="0.99")
+        break
+    except ApiError as exc:
+        if exc.status_code == 404 and exc.code == "MARKET_NOT_FOUND" and i < 5:
+            time.sleep(min(2.0 * 2**i, 30.0))   # capped backoff, then retry
+            continue
+        raise   # any other error — and the final 404 — propagates
+```
+
+With the **`polysim_clob_client` drop-in**, the same condition surfaces as a
+`PolyApiException` with `status_code == 404`; catch it and retry the same way (or
+pass your drop-in call to `retry_on_market_warmup(lambda: clob.create_and_post_order(...))`,
+which works with any callable):
+
+```python
+from polysim_clob_client.exceptions import PolyApiException
+
+try:
+    resp = clob.create_and_post_order(order_args)
+except PolyApiException as exc:
+    if exc.status_code == 404 and getattr(exc, "code", None) == "MARKET_NOT_FOUND":
+        ...  # warm-up — retry with backoff
+    else:
+        raise   # any other error — including a 404 with a different code — propagates
+```
+
 ### Troubleshooting: `error code: 1010` / blocked User-Agent
 
 If a raw HTTP call returns **HTTP 403** with the body `error code: 1010`, the

{polysimulator-0.4.0 → polysimulator-0.4.2}/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.0 → polysimulator-0.4.2}/polysim_clob_client/client.py

@@ -149,7 +149,9 @@ class ClobClient:
 
         Thin wrapper over :func:`polysim_sdk._shared._split_token` (the shared
         parity seam): a bare ``token_id`` is the market id with outcome
-        ``YES``; ``":NO"`` / ``":YES"`` targets the other outcome explicitly.
+        ``YES``; ``":NO"`` / ``":YES"`` targets the other outcome explicitly,
+        and ``":UP"`` / ``":DOWN"`` targets an UpDown market's outcomes (the
+        backend matches the outcome case-insensitively).
         """
         return _split_token_shared(token_id)
 
@@ -161,9 +163,10 @@ class ClobClient:
         condition ids. For those it reverse-resolves via
         ``GET /v1/markets-by-token/{token_id}`` (result cached per token), so an
         order placed with a genuine Polymarket token id lands on the right
-        market + outcome. The ``condition_id:YES``/``:NO`` colon form and short
-        / non-numeric ids resolve **locally with no network call** via
-        :meth:`_split_token` (preserving the parity seam).
+        market + outcome. The ``condition_id:YES``/``:NO`` colon form (plus
+        ``:UP``/``:DOWN`` for UpDown markets) and short / non-numeric ids
+        resolve **locally with no network call** via :meth:`_split_token`
+        (preserving the parity seam).
         """
         tid = str(token_id)
         # Colon form is our own convenience extension — always resolve locally.
@@ -191,15 +194,16 @@ class ClobClient:
         ``GET /v1/book?token_id=...`` endpoint — this is what gives genuine
         parity with Polymarket's CLOB book reads, where py-clob-client always
         passes a real outcome-token id. The ``condition_id:YES`` / ``:NO``
-        **colon form** is our own convenience extension; it keeps condition-id
-        routing and threads the outcome through as a query param so ``:NO``
-        actually reads the NO book.
+        **colon form** (plus ``:UP`` / ``:DOWN`` for UpDown markets) is our own
+        convenience extension; it keeps condition-id routing and threads the
+        outcome through as a query param so e.g. ``:NO`` reads the NO book and
+        ``:UP`` reads the UP book.
         """
         tid = str(token_id)
         if ":" in tid:
             market_id, _, outcome = tid.rpartition(":")
             outcome = outcome.upper()
-            if outcome in ("YES", "NO") and market_id:
+            if outcome in ("YES", "NO", "UP", "DOWN") and market_id:
                 return self._client.get_book(market_id, outcome=outcome)
         return self._client.get_book_by_token(tid)
 
@@ -660,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`
@@ -670,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"],
@@ -709,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
@@ -747,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.0 → polysimulator-0.4.2}/polysim_polymarket/__init__.py

@@ -112,6 +112,7 @@ from polysim_polymarket.rfq import (
     RfqSession,
     RfqSide,
 )
+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 +152,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",

{polysimulator-0.4.0 → polysimulator-0.4.2}/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.0 → polysimulator-0.4.2}/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)