hyperquant 1.33__tar.gz → 1.35__tar.gz

{hyperquant-1.33 → hyperquant-1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.33
+Version: 1.35
 Summary: A minimal yet hyper-efficient backtesting framework for quantitative trading
 Project-URL: Homepage, https://github.com/yourusername/hyperquant
 Project-URL: Issues, https://github.com/yourusername/hyperquant/issues

{hyperquant-1.33 → hyperquant-1.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.33"
+version = "1.35"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }

{hyperquant-1.33 → hyperquant-1.35}/src/hyperquant/broker/auth.py

@@ -499,9 +499,67 @@ class Auth:
         if not creds:
             return args
 
+        if isinstance(creds, tuple):
+            creds = list(creds)
+            session.__dict__["_apis"][api_name] = creds
+
         private_key = creds[0] if len(creds) > 0 and creds[0] else None
-        chain_id = session.__dict__.get("_polymarket_chain_id", 137)
-        api_meta = session.__dict__.get("_polymarket_api_creds", {})
+        if private_key:
+            pk_str = str(private_key)
+            if not pk_str.startswith("0x"):
+                pk_str = f"0x{pk_str}"
+                try:
+                    session.__dict__["_apis"][api_name][0] = pk_str
+                except Exception:
+                    pass
+            private_key = pk_str
+
+        packed_extra = creds[2] if len(creds) > 2 else None
+        packed_api_key = packed_api_secret = packed_passphrase = None
+        packed_chain_id = packed_wallet = None
+        if isinstance(packed_extra, (list, tuple)):
+            def _packed_value(idx: int):
+                if idx >= len(packed_extra):
+                    return None
+                value = packed_extra[idx]
+                if isinstance(value, str):
+                    value = value.strip()
+                return value or None
+
+            packed_api_key = _packed_value(0)
+            packed_api_secret = _packed_value(1)
+            packed_passphrase = _packed_value(2)
+            packed_chain_id = _packed_value(3)
+            packed_wallet = _packed_value(4)
+        elif isinstance(packed_extra, str):
+            packed_wallet = packed_extra or None
+
+        existing_chain_id = session.__dict__.get("_polymarket_chain_id")
+        if existing_chain_id is None:
+            chain_id = 137
+            if packed_chain_id is not None:
+                try:
+                    chain_id = int(packed_chain_id)
+                except (TypeError, ValueError):
+                    chain_id = 137
+            session.__dict__["_polymarket_chain_id"] = chain_id
+        else:
+            chain_id = existing_chain_id
+
+        api_meta = session.__dict__.get("_polymarket_api_creds") or {}
+        if (not api_meta.get("api_key") or not api_meta.get("api_secret") or not api_meta.get("api_passphrase")) and (
+            packed_api_key and packed_api_secret and packed_passphrase
+        ):
+            api_meta = {
+                "api_key": packed_api_key,
+                "api_secret": packed_api_secret,
+                "api_passphrase": packed_passphrase,
+            }
+            session.__dict__["_polymarket_api_creds"] = api_meta
+
+        if packed_wallet and len(creds) > 2 and isinstance(creds[2], (list, tuple)):
+            creds[2] = packed_wallet
+
         api_key = api_meta.get("api_key")
         api_secret = api_meta.get("api_secret")
         api_passphrase = api_meta.get("api_passphrase")

{hyperquant-1.33 → hyperquant-1.35}/src/hyperquant/broker/models/polymarket.py

@@ -18,6 +18,50 @@ class Position(DataStore):
     def _on_response(self, msg: Item) -> None:
         self._update(msg)
 
+    def on_trade(self, trade: Item) -> None:
+        status = str(trade.get("status") or "").upper()
+        if status not in {"MATCHED"}:
+            return
+
+        asset_id = trade.get("asset_id")
+        outcome = trade.get("outcome")
+        side = str(trade.get("side") or "").upper()
+        size_raw = trade.get("size")
+
+        if not asset_id or not outcome or side not in {"BUY", "SELL"}:
+            return
+
+        try:
+            size = float(size_raw)
+        except (TypeError, ValueError):
+            return
+
+        key = {"asset": asset_id, "outcome": outcome}
+        existing = self.get(key) or {}
+
+        cur_size = float(existing.get("size") or 0.0)
+        cur_total_bought = float(existing.get("totalBought") or 0.0)
+
+        if side == "BUY":
+            new_size = cur_size + size
+            total_bought = cur_total_bought + size
+        else:  # SELL
+            new_size = cur_size - size
+            total_bought = cur_total_bought
+
+        rec: dict[str, Any] = {
+            "asset": asset_id,
+            "outcome": outcome,
+            "side": side,
+            "size": new_size,
+            "totalBought": total_bought,
+        }
+
+        if existing:
+            self._update([rec])
+        else:
+            self._insert([rec])
+
 
 class Fill(DataStore):
     """Fill records keyed by maker order id."""
@@ -157,13 +201,17 @@ class MyTrade(DataStore):
 class Trade(DataStore):
     """User trades keyed by trade id."""
 
-    _KEYS = ["asset"]
+    _KEYS = ["asset_id"]
     _MAXLEN = 500
 
 
     def _on_message(self, msg: dict[str, Any]) -> None:
-        payload = msg.get("payload") or {}
+        payload = msg or {}
         if payload:
+            size = float(payload.get("size"))
+            price = float(payload.get("price"))
+            # share = size / price
+            # payload['shares'] = share
             self._insert([payload])
 
 class Book(DataStore):
@@ -364,10 +412,14 @@ class Detail(DataStore):
 
             for token in tokens:
                 normalized = self._normalize_entry(market, token)
+                slug: str = market.get("slug")
+                # 取最后一个'-'之前部分
+                base_slug = slug.rsplit("-", 1)[0] if slug else slug
                 # Add or update additional fields from market
                 normalized.update({
                     "condition_id": market.get("conditionId"),
                     "slug": market.get("slug"),
+                    "base_slug": base_slug,
                     "end_date": market.get("endDate"),
                     "start_date": market.get("startDate"),
                     "icon": market.get("icon"),
@@ -579,27 +631,35 @@ class PolymarketDataStore(DataStoreCollection):
     def trade(self) -> Trade:
         """
         _key asset
-
+        MATCHED进行快速捕捉
         .. code:: json
             {
-                "asset": "28343900911859986062638672238388649192722581036873866155064320792236495661418",
-                "bio": "",
-                "conditionId": "0x730a593d5b63a39d316139a7f4bc1dd9fd05d858f6d96f659629c371bc81cd4d",
-                "eventSlug": "btc-updown-15m-1762951500",
-                "icon": "https://polymarket-upload.s3.us-east-2.amazonaws.com/BTC+fullsize.png",
-                "name": "",
-                "outcome": "Down",
-                "outcomeIndex": 1,
-                "price": 0.11,
-                "profileImage": "",
-                "proxyWallet": "0x7459f51304037Da66c47CeA58F078D7f603fD011",
-                "pseudonym": "",
-                "side": "SELL",
-                "size": 84,
-                "slug": "btc-updown-15m-1762951500",
-                "timestamp": 1762952057,
-                "title": "Bitcoin Up or Down - November 12, 7:45AM-8:00AM ET",
-                "transactionHash": "0x6853cab8901779c494fe15f0eb3350aebfb182125347ca67b8bd9706babbddca"
+                "asset_id": "52114319501245915516055106046884209969926127482827954674443846427813813222426",
+                "event_type": "trade",
+                "id": "28c4d2eb-bbea-40e7-a9f0-b2fdb56b2c2e",
+                "last_update": "1672290701",
+                "maker_orders": [
+                    {
+                    "asset_id": "52114319501245915516055106046884209969926127482827954674443846427813813222426",
+                    "matched_amount": "10",
+                    "order_id": "0xff354cd7ca7539dfa9c28d90943ab5779a4eac34b9b37a757d7b32bdfb11790b",
+                    "outcome": "YES",
+                    "owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
+                    "price": "0.57"
+                    }
+                ],
+                "market": "0xbd31dc8a20211944f6b70f31557f1001557b59905b7738480ca09bd4532f84af",
+                "matchtime": "1672290701",
+                "outcome": "YES",
+                "owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
+                "price": "0.57",
+                "side": "BUY",
+                "size": "10",
+                "status": "MATCHED",
+                "taker_order_id": "0x06bc63e346ed4ceddce9efd6b3af37c8f8f440c92fe7da6b2d0f9e4ccbc50c42",
+                "timestamp": "1672290701",
+                "trade_owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
+                "type": "TRADE"
             }
         """
         return self._get("trade")
@@ -620,5 +680,6 @@ class PolymarketDataStore(DataStoreCollection):
             elif msg_type == "trade":
                 self.trade._on_message(m)
                 self.fill._on_trade(m)
+                self.position.on_trade(m)
             elif msg_type == 'orders_matched':
                 self.trade._on_message(m)

{hyperquant-1.33 → hyperquant-1.35}/src/hyperquant/broker/polymarket.py

@@ -4,6 +4,7 @@ import asyncio
 from contextlib import suppress
 from datetime import UTC, datetime
 from functools import lru_cache
+import os
 from typing import Any, Iterable, Iterator, Literal, Mapping, Sequence
 
 import json
@@ -38,6 +39,14 @@ DEFAULT_POLYGON_RPCS = (
     "https://rpc.ankr.com/polygon",
 )
 
+def parse_field(value):
+    """尝试将字符串 JSON 转为对象，否则原样返回"""
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+    return value
 
 def _iter_offsets(window: int) -> Iterator[int]:
     yield 0
@@ -94,7 +103,7 @@ class Polymarket:
         self._ws_personal: pybotters.ws.WebSocketApp | None = None
         self.auth = False
 
-        self._ensure_session_entry(private_key=private_key, funder=funder)
+        self._ensure_session_entry(private_key=private_key, funder=funder, chain_id=chain_id)
 
     async def __aenter__(self) -> "Polymarket":
         if self.auth:
@@ -266,6 +275,7 @@ class Polymarket:
         self._ws_personal = self.client.ws_connect(
             "wss://ws-subscriptions-clob.polymarket.com/ws/user",
             hdlr_json=effective_cb,
+            heartbeat=30,
             auth=None,
         )
         await self._ws_personal._event.wait()
@@ -298,7 +308,7 @@ class Polymarket:
         wsapp = self.client.ws_connect(
             RTS_DATA_ENDPOINT,
             hdlr_str=callback,
-            heartbeat=5
+            heartbeat=30
         )
         await wsapp._event.wait()
         await wsapp.current_ws.send_json(payload)
@@ -314,9 +324,12 @@ class Polymarket:
         return await self._rest("GET", f"/markets/{market_id}")
 
     async def get_market_by_slug(self, slug: str) -> Any:
-        """Fetch a market using its human-readable slug."""
-        # https://gamma-api.polymarket.com/markets/slug/{slug}
-        return await self._rest("GET", f"/slug/{slug}", host='https://gamma-api.polymarket.com/markets')
+        """Fetch a market using its human-readable slug.
+        https://docs.polymarket.com/api-reference/markets/get-market-by-slug
+        """
+        market:dict = await self._rest("GET", f"/slug/{slug}", host='https://gamma-api.polymarket.com/markets')
+        market = {k: parse_field(v) for k, v in market.items()}
+        return market
     
     async def get_order_book(self, token_id: str) -> Any:
         return await self._rest("GET", "/book", params={"token_id": token_id})
@@ -498,7 +511,7 @@ class Polymarket:
         side: str,
         price: float,
         size: float,
-        order_type: str = "GTC",
+        order_type: Literal["GTC", 'FOK'] = "GTC",
         tick_size: str | float | None = None,
         fee_rate_bps: int | None = None,
         expiration: int | None = None,
@@ -523,6 +536,9 @@ class Polymarket:
         - nonce: onchain nonce, default 0
         """
 
+        if price <= 0:
+            raise ValueError("price must be positive; use place_market_order for market orders")
+
         # Ensure L2 creds exist
         if not self._api_creds():
             raise RuntimeError("Polymarket API credentials missing; call create_or_derive_api_creds first")
@@ -552,6 +568,117 @@ class Polymarket:
         }
         return await self._signed_request_via_session("POST", "/order", payload)
 
+    async def place_market_order(
+        self,
+        *,
+        token_id: str,
+        side: str,
+        amount: float,
+        order_type: Literal["FOK", "GTC", "FAK", "GTD"] = "FOK",
+        price: float | None = None,
+        tick_size: str | float | None = None,
+        fee_rate_bps: int | None = None,
+        taker: str = ZERO_ADDRESS,
+        neg_risk: bool = False,
+        owner: str | None = None,
+        nonce: int | None = None,
+    ) -> Any:
+        """Create, sign and submit a market order similar to ``py_clob_client``.
+
+        BUY orders treat ``amount`` as collateral (USDC); SELL orders treat it as shares.
+        """
+
+        if amount <= 0:
+            raise ValueError("amount must be greater than 0 for market orders")
+
+        if not self._api_creds():
+            raise RuntimeError("Polymarket API credentials missing; call create_or_derive_api_creds first")
+
+        private_key, maker_addr, signer_addr = self._get_signing_context()
+        owner_key = self._owner_key(owner)
+        order_type_str = (order_type or "FOK").upper()
+
+        if price is None or price <= 0:
+            price = await self._calculate_market_price(
+                token_id=token_id,
+                side=side,
+                amount=amount,
+                order_type=order_type_str,
+            )
+
+        signed_dict = await self._build_signed_market_order(
+            private_key=private_key,
+            maker_addr=maker_addr,
+            signer_addr=signer_addr,
+            token_id=token_id,
+            side=side,
+            amount=amount,
+            price=price,
+            tick_size=tick_size,
+            fee_rate_bps=fee_rate_bps,
+            taker=taker,
+            neg_risk=neg_risk,
+            nonce=nonce,
+        )
+
+        payload = {
+            "order": signed_dict,
+            "owner": owner_key,
+            "orderType": order_type_str,
+        }
+        return await self._signed_request_via_session("POST", "/order", payload)
+
+    async def _calculate_market_price(
+        self,
+        *,
+        token_id: str,
+        side: str,
+        amount: float,
+        order_type: str,
+    ) -> float:
+        side_flag = side.upper()
+        if side_flag not in {"BUY", "SELL"}:
+            raise ValueError("side must be 'BUY' or 'SELL'")
+        if amount <= 0:
+            raise ValueError("amount must be greater than 0 for market pricing")
+
+        book = await self.get_order_book(token_id)
+        if not isinstance(book, Mapping):
+            raise RuntimeError("Polymarket order book unavailable for market order")
+
+        key = "asks" if side_flag == "BUY" else "bids"
+        raw_levels = book.get(key) or []
+        levels: list[tuple[float, float]] = []
+        for lvl in raw_levels:
+            try:
+                price = float(lvl.get("price"))
+                size = float(lvl.get("size"))
+            except (TypeError, ValueError):
+                continue
+            if price is None or size is None:
+                continue
+            levels.append((price, size))
+
+        if not levels:
+            raise RuntimeError(f"Polymarket market order has no {key} liquidity")
+
+        total = 0.0
+        if side_flag == "BUY":
+            for price, size in reversed(levels):
+                total += price * size
+                if total >= amount:
+                    return price
+        else:
+            for price, size in reversed(levels):
+                total += size
+                if total >= amount:
+                    return price
+
+        if (order_type or "FOK").upper() == "FOK":
+            raise RuntimeError("Polymarket market order exceeds available liquidity")
+
+        return levels[0][0]
+
     async def _signed_request_via_session(
         self, method: str, path: str, body: Mapping[str, Any] | list[Any] | None
     ) -> Any:
@@ -686,6 +813,76 @@ class Polymarket:
             },
         )
 
+    async def _build_signed_market_order(
+        self,
+        *,
+        private_key: str,
+        maker_addr: str,
+        signer_addr: str,
+        token_id: str,
+        side: str,
+        amount: float,
+        price: float,
+        tick_size: str | float | None,
+        fee_rate_bps: int | None,
+        taker: str,
+        neg_risk: bool,
+        nonce: int | None,
+    ) -> dict[str, Any]:
+        side = side.upper()
+        tick = await self._resolve_tick_size(token_id, tick_size)
+        fee_bps = await self._resolve_fee_rate(token_id, fee_rate_bps)
+
+        price_d, size_d, amt_d = self._rounding_for_tick(tick)
+        price = float(self._round_normal(price, price_d))
+        if price <= 0:
+            raise ValueError("market price must be positive")
+
+        amt = float(amount)
+        if amt <= 0:
+            raise ValueError("amount must be greater than 0")
+
+        maker_amt_raw = self._round_down(amt, size_d)
+        if maker_amt_raw <= 0:
+            raise ValueError("amount too small for current tick size")
+
+        if side == "BUY":
+            taker_amt_raw = maker_amt_raw / price
+        elif side == "SELL":
+            taker_amt_raw = maker_amt_raw * price
+        else:
+            raise ValueError("side must be 'BUY' or 'SELL'")
+
+        if self._decimal_places(taker_amt_raw) > amt_d:
+            tmp = self._round_up(taker_amt_raw, amt_d + 4)
+            taker_amt_raw = tmp if self._decimal_places(tmp) <= amt_d else self._round_down(tmp, amt_d)
+
+        maker_amount = self._to_token_decimals(maker_amt_raw)
+        taker_amount = self._to_token_decimals(taker_amt_raw)
+
+        contract = self._contracts(self.chain_id, neg_risk)
+        side_flag = 0 if side == "BUY" else 1
+        sig_type = int(self.signature_type)
+
+        return Auth.sign_polymarket_order(
+            private_key=private_key,
+            chain_id=self.chain_id,
+            exchange_address=contract["exchange"],
+            order={
+                "maker": maker_addr,
+                "signer": signer_addr,
+                "taker": taker or ZERO_ADDRESS,
+                "tokenId": str(token_id),
+                "makerAmount": int(maker_amount),
+                "takerAmount": int(taker_amount),
+                "expiration": 0,
+                "nonce": int(nonce or 0),
+                "feeRateBps": int(fee_bps or 0),
+                "side": side_flag,
+                "signatureType": sig_type,
+            },
+        )
+
     async def _resolve_tick_size(self, token_id: str, tick_size: str | float | None) -> str:
         if tick_size is not None:
             return str(tick_size)
@@ -878,6 +1075,7 @@ class Polymarket:
 
     async def get_trades(self, params: Mapping[str, Any] | None = None) -> list[Any]:
         return await self._paginate("/data/trades", params)
+    
 
     async def get_notifications(self, signature_type: int | None = None) -> Any:
         sig = signature_type if signature_type is not None else self.signature_type
@@ -889,12 +1087,30 @@ class Polymarket:
         return await self._rest("DELETE", "/notifications", params=params)
 
     async def get_balance_allowance(self, **params: Any) -> Any:
-        return await self._rest("GET", "/balance-allowance", params=params or None)
+        query = dict(params or {})
+        query.setdefault("signature_type", self.signature_type)
+        return await self._rest("GET", "/balance-allowance", params=query or None)
 
     async def update_balance_allowance(self, **params: Any) -> Any:
-        return await self._rest("POST", "/balance-allowance/update", json=params or None)
-
-    async def get_usdc(
+        body = dict(params or {})
+        body.setdefault("signature_type", self.signature_type)
+        return await self._rest("POST", "/balance-allowance/update", json=body or None)
+    
+    async def get_usdc(self):
+        data = await self.get_balance_allowance(asset_type='COLLATERAL')
+        balance = float(data.get('balance', 0.0))
+        if balance > 0:
+            balance = balance / 1e6
+        return balance
+    
+    async def get_position(self, token_id: str) -> Any:
+        data = await self.get_balance_allowance(asset_type='CONDITIONAL', token_id=token_id)
+        position = float(data.get('balance', 0.0))
+        if position > 0:
+            position = position / 1e6
+        return position
+
+    async def get_usdc_web3(
         self,
         wallet: str = None,
         rpc_urls: Sequence[str] | None = None,
@@ -966,14 +1182,7 @@ class Polymarket:
             if not event:
                 continue
 
-            def parse_field(value):
-                """尝试将字符串 JSON 转为对象，否则原样返回"""
-                if isinstance(value, str):
-                    try:
-                        return json.loads(value)
-                    except json.JSONDecodeError:
-                        return value
-                return value
+
             
             event = {k: parse_field(v) for k, v in event.items()}
 
@@ -1113,6 +1322,7 @@ class Polymarket:
         *,
         private_key: str | None,
         funder: str | None,
+        chain_id: int | None,
     ) -> None:
         session = getattr(self.client, "_session", None)
         if session is None:
@@ -1125,27 +1335,66 @@ class Polymarket:
         if not entry and not private_key:
             return
 
+        packed = entry[2] if len(entry) > 2 else None
+        if not isinstance(packed, (list, tuple)):
+            packed = None
+
+        def _packed_value(idx: int) -> Any | None:
+            if packed is None:
+                return None
+            if idx >= len(packed):
+                return None
+            value = packed[idx]
+            if isinstance(value, str):
+                value = value.strip()
+            return value or None
+
+        packed_api_key = _packed_value(0)
+        packed_api_secret = _packed_value(1)
+        packed_passphrase = _packed_value(2)
+        packed_chain_id = _packed_value(3)
+        packed_wallet = _packed_value(4)
+
         while len(entry) < 3:
             entry.append("")
 
-        existing_pk = entry[0]
+        existing_pk = entry[0] if entry else None
         normalized_pk: str | None = None
-        if private_key:
+        candidate_pk = private_key or existing_pk
+        if candidate_pk:
+            candidate_pk = str(candidate_pk)
             normalized_pk = (
-                private_key if private_key.startswith("0x") else f"0x{private_key}"
-            )
-        elif existing_pk:
-            normalized_pk = (
-                existing_pk if existing_pk.startswith("0x") else f"0x{existing_pk}"
+                candidate_pk if candidate_pk.startswith("0x") else f"0x{candidate_pk}"
             )
 
         if not normalized_pk:
             raise RuntimeError("Polymarket需要钱包私钥 (apis['polymarket'][0])")
 
         entry[0] = normalized_pk
-        if funder:
-            entry[2] = funder
-        self.funder = entry[2] or self.funder
+
+        existing_wallet = entry[2] if isinstance(entry[2], str) and entry[2] else None
+        effective_wallet = funder or packed_wallet or existing_wallet or self.funder
+        if effective_wallet:
+            entry[2] = effective_wallet
+            self.funder = effective_wallet
+        else:
+            entry[2] = ""
+
+        derived_chain_id: int | None = None
+        if packed_chain_id is not None:
+            try:
+                derived_chain_id = int(packed_chain_id)
+            except (TypeError, ValueError):
+                derived_chain_id = None
+        if chain_id is None and derived_chain_id is not None:
+            self.chain_id = derived_chain_id
+
+        if packed_api_key and packed_api_secret and packed_passphrase:
+            session.__dict__["_polymarket_api_creds"] = {
+                "api_key": packed_api_key,
+                "api_secret": packed_api_secret,
+                "api_passphrase": packed_passphrase,
+            }
 
         apis[API_NAME] = entry
         session.__dict__["_apis"] = apis
@@ -1153,6 +1402,19 @@ class Polymarket:
         session.__dict__["_polymarket_signature_type"] = self.signature_type
         self.auth = True
 
+    @staticmethod
+    def load_poly_api():
+        from dotenv import load_dotenv
+
+        load_dotenv()
+        pk = os.getenv("PK")
+        api_key = os.getenv("CLOB_API_KEY")
+        api_secret = os.getenv("CLOB_API_SECRET")
+        passphrase = os.getenv("CLOB_API_PASSPHRASE")
+        chain_id = os.getenv("CHAIN_ID") or 137
+        wallet_address = os.getenv("POLY_WALLET_ADDRESS")
+        return [pk, "", (api_key, api_secret, passphrase, chain_id, wallet_address)]
+
 @lru_cache(maxsize=8)
 def _get_web3(rpc_url: str):
     from web3 import Web3

{hyperquant-1.33 → hyperquant-1.35}/uv.lock

@@ -945,7 +945,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.32"
+version = "1.34"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },