hyperquant 1.53__tar.gz → 1.55__tar.gz

{hyperquant-1.53 → hyperquant-1.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.53
+Version: 1.55
 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.53 → hyperquant-1.55}/pyproject.toml

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

{hyperquant-1.53 → hyperquant-1.55}/src/hyperquant/broker/polymarket.py

@@ -7,7 +7,8 @@ from datetime import UTC, datetime, timedelta
 from functools import lru_cache
 import os
 import time
-from typing import Any, Iterable, Iterator, Literal, Mapping, Sequence
+from typing import Any, Awaitable, Callable, Iterable, Iterator, Literal, Mapping, Sequence
+from urllib.parse import urlsplit, urlunsplit
 
 import json
 
@@ -108,7 +109,10 @@ CONDITIONAL_TOKENS_SPLIT_ABI = [
     },
 ]
 DEFAULT_POLYGON_RPCS = (
-    # "https://polygon.llamarpc.com",
+    "https://1rpc.io/matic",
+    "https://polygon-bor-rpc.publicnode.com",
+    "https://polygon.drpc.org",
+    # Keep historical endpoints as fallback for users with API access.
     "https://polygon-rpc.com",
     "https://rpc.ankr.com/polygon",
 )
@@ -256,6 +260,8 @@ class Polymarket:
         self._ws_personal: pybotters.ws.WebSocketApp | None = None
         self.auth = False
         self._tick_size_cache: dict[str, tuple[str, float]] = {}
+        self._forward_orders_cfg: dict[str, Any] | None = None
+        self._forward_ws: dict[str, Any] | None = None
 
         self._ensure_session_entry(private_key=private_key, funder=funder, chain_id=chain_id)
 
@@ -273,6 +279,7 @@ class Polymarket:
                 await self._ws_public.current_ws.close()
             self._ws_public = None
             self._ws_public_ready.clear()
+        await self._close_forward_ws()
 
     async def prewarm_connections(
         self,
@@ -293,6 +300,109 @@ class Polymarket:
             except Exception:
                 continue
 
+    async def mount_forward_orders(
+        self,
+        *,
+        mode: Literal["rest", "ws"],
+        url: str,
+        region: str = "afr",
+        session: str = "orders",
+        ws_timeout: float = 30.0,
+        batch_mode: Literal["step", "batch"] = "step",
+        concurrency: int = 5,
+        callback: Callable[[dict[str, Any]], Awaitable[None] | None] | None = None,
+    ) -> None:
+        """Mount forward execution for place_orders/cancel_orders."""
+        cfg = {
+            "mode": mode,
+            "url": url,
+            "region": region,
+            "session": session,
+            "ws_timeout": float(ws_timeout),
+            "batch_mode": batch_mode,
+            "concurrency": int(concurrency),
+            "callback": callback,
+        }
+        if mode == "rest":
+            cfg["url"] = self._normalize_forward_batch_url(url)
+            await self._close_forward_ws()
+        else:
+            cfg["url"] = self._normalize_forward_ws_url(url)
+            await self._ensure_forward_ws_connected(cfg)
+        self._forward_orders_cfg = cfg
+
+    async def unmount_forward_orders(self) -> None:
+        """Disable forward execution and fallback to direct CLOB calls."""
+        await self._close_forward_ws()
+        self._forward_orders_cfg = None
+
+    async def _close_forward_ws(self) -> None:
+        state = self._forward_ws
+        self._forward_ws = None
+        if not state:
+            return
+        task: asyncio.Task | None = state.get("listener")
+        ws: aiohttp.ClientWebSocketResponse | None = state.get("ws")
+        if task:
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
+        if ws and not ws.closed:
+            with suppress(Exception):
+                await ws.close()
+
+    async def _forward_ws_listener(self, ws: aiohttp.ClientWebSocketResponse, cfg: Mapping[str, Any]) -> None:
+        callback = cfg.get("callback")
+        while True:
+            msg = await ws.receive()
+            if msg.type == aiohttp.WSMsgType.TEXT:
+                try:
+                    data = json.loads(msg.data)
+                except Exception:
+                    continue
+                if callback:
+                    try:
+                        ret = callback(data)
+                        if asyncio.iscoroutine(ret):
+                            await ret
+                    except Exception as exc:
+                        self.logger.warning("forward ws callback error: %s", exc)
+                continue
+            if msg.type in {aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.CLOSED}:
+                break
+            if msg.type == aiohttp.WSMsgType.ERROR:
+                break
+
+    async def _ensure_forward_ws_connected(self, cfg: Mapping[str, Any] | None = None) -> None:
+        current = cfg or self._forward_orders_cfg
+        if not current or current.get("mode") != "ws":
+            return
+        state = self._forward_ws
+        if state:
+            ws: aiohttp.ClientWebSocketResponse | None = state.get("ws")
+            task: asyncio.Task | None = state.get("listener")
+            if ws and not ws.closed and task and not task.done():
+                return
+            await self._close_forward_ws()
+
+        session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+        if session is None:
+            raise RuntimeError("pybotters client session missing")
+
+        ws_url = current["url"]
+        sep = "&" if ("?" in ws_url) else "?"
+        ws_url = f"{ws_url}{sep}region={current.get('region', 'afr')}&session={current.get('session', 'orders')}"
+        ws = await session.ws_connect(ws_url, heartbeat=30)
+        # Consume hello once to align message stream.
+        with suppress(Exception):
+            await asyncio.wait_for(ws.receive(), timeout=float(current.get("ws_timeout", 30.0)))
+        listener = asyncio.create_task(self._forward_ws_listener(ws, current))
+        self._forward_ws = {"ws": ws, "listener": listener}
+
     # ------------------------------------------------------------------
     # Store helpers
 
@@ -1355,6 +1465,101 @@ class Polymarket:
             except Exception:
                 return await resp.text()
 
+    def _normalize_forward_batch_url(self, forward_url: str) -> str:
+        parts = urlsplit(forward_url)
+        if not parts.scheme or not parts.netloc:
+            raise ValueError("forward_url must be a valid absolute URL")
+        path = (parts.path or "").rstrip("/")
+        if path.endswith("/forward-batch") or path.endswith("/forward-batch-step"):
+            target_path = path
+        elif path.endswith("/forward"):
+            target_path = f"{path[:-len('/forward')]}/forward-batch-step"
+        else:
+            target_path = f"{path}/forward-batch-step" if path else "/forward-batch-step"
+        return urlunsplit((parts.scheme, parts.netloc, target_path, parts.query, parts.fragment))
+
+    def _normalize_forward_ws_url(self, forward_url: str) -> str:
+        parts = urlsplit(forward_url)
+        if parts.scheme not in {"ws", "wss"} or not parts.netloc:
+            raise ValueError("forward ws url must be a valid ws:// or wss:// URL")
+        path = (parts.path or "").rstrip("/")
+        if not path.endswith("/ws-forward"):
+            path = f"{path}/ws-forward" if path else "/ws-forward"
+        return urlunsplit((parts.scheme, parts.netloc, path, parts.query, parts.fragment))
+
+    def _build_l2_signed_headers(
+        self,
+        *,
+        signer_addr: str,
+        api_key: str,
+        api_secret: str,
+        api_passphrase: str,
+        method: str,
+        path: str,
+        payload: Any,
+    ) -> dict[str, str]:
+        import base64
+        import hashlib
+        import hmac
+
+        ts = int(time.time())
+        serialized = json.dumps(payload, separators=(",", ":"), ensure_ascii=False)
+        msg = f"{ts}{method.upper()}{path}{serialized}"
+        secret_bytes = base64.urlsafe_b64decode(api_secret)
+        sig = hmac.new(secret_bytes, msg.encode("utf-8"), hashlib.sha256).digest()
+        sign_b64 = base64.urlsafe_b64encode(sig).decode("utf-8")
+        return {
+            "POLY_ADDRESS": signer_addr,
+            "POLY_SIGNATURE": sign_b64,
+            "POLY_TIMESTAMP": str(ts),
+            "POLY_API_KEY": api_key,
+            "POLY_PASSPHRASE": api_passphrase,
+            "Content-Type": "application/json",
+        }
+
+    async def _submit_forward_requests(self, requests_payload: Sequence[Mapping[str, Any]]) -> Any:
+        cfg = self._forward_orders_cfg
+        if not cfg:
+            raise RuntimeError("forward is not mounted")
+        session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+        if session is None:
+            raise RuntimeError("pybotters client session missing")
+
+        if cfg["mode"] == "rest":
+            endpoint = cfg["url"]
+            async with session.post(endpoint, json={"requests": list(requests_payload)}) as resp:
+                if resp.status >= 400:
+                    text = await resp.text()
+                    raise RuntimeError(f"Forward batch failed: {resp.status} {text}")
+                try:
+                    return await resp.json()
+                except Exception:
+                    return await resp.text()
+
+        await self._ensure_forward_ws_connected(cfg)
+        state = self._forward_ws
+        ws: aiohttp.ClientWebSocketResponse | None = state.get("ws") if state else None
+        if ws is None or ws.closed:
+            raise RuntimeError("forward ws not connected")
+
+        req_id = f"hq-{int(time.time() * 1000)}"
+        msg_type = "batch" if cfg.get("batch_mode") == "batch" else "batch-step"
+        payload: dict[str, Any] = {
+            "type": msg_type,
+            "id": req_id,
+            "requests": list(requests_payload),
+        }
+        if msg_type == "batch":
+            payload["concurrency"] = int(cfg.get("concurrency", 5))
+        await ws.send_json(payload)
+        return {
+            "mode": "ws",
+            "queued": True,
+            "request_id": req_id,
+            "batch_mode": msg_type,
+            "count": len(requests_payload),
+        }
+
     async def post_orders(
         self,
         orders: Iterable[tuple[Mapping[str, Any], str]],
@@ -1444,6 +1649,41 @@ class Polymarket:
                 }
             )
 
+        if self._forward_orders_cfg:
+            session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+            if session is None:
+                raise RuntimeError("pybotters client session missing")
+            creds = getattr(session, "_polymarket_api_creds", None)
+            if not creds:
+                raise RuntimeError("Polymarket API creds missing; call create_or_derive_api_creds")
+            api_key = creds.get("api_key")
+            api_secret = creds.get("api_secret")
+            api_passphrase = creds.get("api_passphrase")
+            if not (api_key and api_secret and api_passphrase):
+                raise RuntimeError("Polymarket API creds incomplete")
+
+            target_url = f"{self.rest_api.rstrip('/')}/order"
+            requests_payload: list[dict[str, Any]] = []
+            for payload in result_body:
+                headers = self._build_l2_signed_headers(
+                    signer_addr=signer_addr,
+                    api_key=api_key,
+                    api_secret=api_secret,
+                    api_passphrase=api_passphrase,
+                    method="POST",
+                    path="/order",
+                    payload=payload,
+                )
+                requests_payload.append(
+                    {
+                        "method": "POST",
+                        "url": target_url,
+                        "headers": headers,
+                        "body": payload,
+                    }
+                )
+            return await self._submit_forward_requests(requests_payload)
+
         return await self._signed_request_via_session("POST", "/orders", result_body)
 
     async def cancel(self, order_id: str) -> Any:
@@ -1452,11 +1692,48 @@ class Polymarket:
         """
         return await self._signed_request_via_session("DELETE", "/order", {"orderID": order_id})
 
-    async def cancel_orders(self, order_ids: Sequence[str]) -> Any:
+    async def cancel_orders(
+        self,
+        order_ids: Sequence[str],
+    ) -> Any:
         """
         {'not_canceled': {}, 'canceled': ['0xb3507e9fda9541c3e038afcb4f24b96efcfa667d46cf5e9e52c41620711818df', '0x4b9c3ee4dee8653f15f716653e8ac83f0a086a38597e6ec4b72be2389c79b8b4']}
         """
-        return await self._signed_request_via_session("DELETE", "/orders", list(order_ids))
+        payload = list(order_ids)
+        if self._forward_orders_cfg:
+            session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+            if session is None:
+                raise RuntimeError("pybotters client session missing")
+            creds = getattr(session, "_polymarket_api_creds", None)
+            if not creds:
+                raise RuntimeError("Polymarket API creds missing; call create_or_derive_api_creds")
+            api_key = creds.get("api_key")
+            api_secret = creds.get("api_secret")
+            api_passphrase = creds.get("api_passphrase")
+            if not (api_key and api_secret and api_passphrase):
+                raise RuntimeError("Polymarket API creds incomplete")
+
+            _, _, signer_addr = self._get_signing_context()
+            headers = self._build_l2_signed_headers(
+                signer_addr=signer_addr,
+                api_key=api_key,
+                api_secret=api_secret,
+                api_passphrase=api_passphrase,
+                method="DELETE",
+                path="/orders",
+                payload=payload,
+            )
+            requests_payload = [
+                {
+                    "method": "DELETE",
+                    "url": f"{self.rest_api.rstrip('/')}/orders",
+                    "headers": headers,
+                    "body": payload,
+                }
+            ]
+            return await self._submit_forward_requests(requests_payload)
+
+        return await self._signed_request_via_session("DELETE", "/orders", payload)
 
     async def cancel_all(self) -> Any:
         """
@@ -1846,14 +2123,22 @@ class Polymarket:
             if dry_run:
                 results.append({**item, "tx": None, "dry_run": True})
                 continue
-            tx_hash = await asyncio.to_thread(
-                self._claim_via_safe_sync,
-                candidates,
-                item["condition_id"],
-                item["index_sets"],
-                gas,
-                verbose,
-            )
+            try:
+                tx_hash = await asyncio.to_thread(
+                    self._claim_via_safe_sync,
+                    candidates,
+                    item["condition_id"],
+                    item["index_sets"],
+                    gas,
+                    verbose,
+                )
+            except Exception as exc:
+                raise RuntimeError(
+                    "claim_positions failed for "
+                    f"condition_id={item.get('condition_id')} "
+                    f"index_sets={item.get('index_sets')} "
+                    f"size={item.get('size')}: {exc}"
+                ) from exc
             result_row = {**item, "tx": tx_hash, "dry_run": False}
             if include_receipt:
                 try:
@@ -1976,22 +2261,7 @@ class Polymarket:
         last_error: Exception | None = None
         w3 = None
         rpc_used = None
-        for url in candidates:
-            try:
-                w3 = Web3(Web3.HTTPProvider(url, request_kwargs={"timeout": 30}))
-                with suppress(Exception):
-                    from web3.middleware import geth_poa_middleware, ExtraDataToPOAMiddleware
-                    try:
-                        w3.middleware_onion.inject(geth_poa_middleware, layer=0)
-                    except Exception:
-                        w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
-                rpc_used = url
-                break
-            except Exception as exc:
-                last_error = exc
-                continue
-        if w3 is None:
-            raise RuntimeError(f"All RPC endpoints failed: {candidates}") from last_error
+        safe_nonce = None
 
         pk_env = os.getenv("PK")
         if pk_env:
@@ -2004,23 +2274,11 @@ class Polymarket:
             raise RuntimeError("Safe/proxy wallet address未知, 请在 apis['polymarket'][2] 或构造函数 funder 设置")
 
         ctf_addr = self._contracts(self.chain_id, False)["conditional_tokens"]
-        ctf = w3.eth.contract(address=w3.to_checksum_address(ctf_addr), abi=CONDITIONAL_TOKENS_ABI)
-        safe = w3.eth.contract(address=w3.to_checksum_address(safe_addr), abi=SAFE_ABI)
 
         cond_bytes = bytes.fromhex(condition_id.replace("0x", ""))
         if len(cond_bytes) != 32:
             raise ValueError("condition_id must be 32-byte hex string")
 
-        redeem_calldata = ctf.encode_abi(
-            "redeemPositions",
-            args=[
-                w3.to_checksum_address(USDC_CONTRACT),
-                bytes(32),
-                cond_bytes,
-                index_sets,
-            ],
-        )
-
         safe_tx_gas = 0
         base_gas = 0
         gas_price = 0
@@ -2029,13 +2287,55 @@ class Polymarket:
         value = 0
         operation = 0  # CALL
 
-        try:
-            safe_nonce = safe.functions.nonce().call()
-        except Web3RPCError as exc:
-            # 速率限制等错误直接抛出，便于调用层切换 RPC
-            raise RuntimeError(f"获取 Safe nonce 失败 (rpc={rpc_used}): {exc}") from exc
-        except Exception as exc:
-            raise RuntimeError("无法获取 Safe nonce, 请确认 funder 地址为有效 Safe") from exc
+        ctf = None
+        safe = None
+        redeem_calldata = None
+        for url in candidates:
+            try:
+                w3_candidate = Web3(Web3.HTTPProvider(url, request_kwargs={"timeout": 30}))
+                with suppress(Exception):
+                    from web3.middleware import geth_poa_middleware, ExtraDataToPOAMiddleware
+                    try:
+                        w3_candidate.middleware_onion.inject(geth_poa_middleware, layer=0)
+                    except Exception:
+                        w3_candidate.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+
+                ctf_candidate = w3_candidate.eth.contract(
+                    address=w3_candidate.to_checksum_address(ctf_addr),
+                    abi=CONDITIONAL_TOKENS_ABI,
+                )
+                safe_candidate = w3_candidate.eth.contract(
+                    address=w3_candidate.to_checksum_address(safe_addr),
+                    abi=SAFE_ABI,
+                )
+                redeem_calldata_candidate = ctf_candidate.encode_abi(
+                    "redeemPositions",
+                    args=[
+                        w3_candidate.to_checksum_address(USDC_CONTRACT),
+                        bytes(32),
+                        cond_bytes,
+                        index_sets,
+                    ],
+                )
+                nonce_candidate = safe_candidate.functions.nonce().call()
+
+                w3 = w3_candidate
+                rpc_used = url
+                ctf = ctf_candidate
+                safe = safe_candidate
+                redeem_calldata = redeem_calldata_candidate
+                safe_nonce = nonce_candidate
+                break
+            except Exception as exc:
+                last_error = exc
+                if verbose:
+                    print(f"[claim] rpc nonce probe failed: {url} -> {exc}")
+                continue
+
+        if w3 is None or safe is None or ctf is None or redeem_calldata is None or safe_nonce is None:
+            raise RuntimeError(
+                f"无法获取 Safe nonce (tried rpc={candidates}); last_error={last_error}"
+            ) from last_error
 
         try:
             safe_tx_hash = safe.functions.getTransactionHash(
@@ -2065,43 +2365,71 @@ class Polymarket:
         try:
             acct = _A.from_key(private_key)
             sender = acct.address
-            # 使用 pending 避免重复使用已在 mempool 的 nonce 触发 replacement underpriced
-            nonce = w3.eth.get_transaction_count(sender)
-            gas_price_chain = w3.eth.gas_price
         except Exception as exc:
-            raise RuntimeError("获取 sender nonce/gas_price 失败") from exc
-
-        tx = safe.functions.execTransaction(
-            w3.to_checksum_address(ctf_addr),
-            value,
-            redeem_calldata,
-            operation,
-            safe_tx_gas,
-            base_gas,
-            gas_price,
-            w3.to_checksum_address(gas_token),
-            w3.to_checksum_address(refund_receiver),
-            sig_bytes,
-        ).build_transaction(
-            {
-                "from": sender,
-                "nonce": nonce,
-                "gas": gas,
-                "gasPrice": gas_price_chain,
-            }
-        )
+            raise RuntimeError("获取 sender 地址失败") from exc
 
-        signed_tx = w3.eth.account.sign_transaction(tx, private_key)
         send_errors: list[str] = []
         for attempt in range(3):
             try:
+                nonce = w3.eth.get_transaction_count(sender, "pending")
+                gas_price_chain = int(w3.eth.gas_price)
+                if attempt > 0:
+                    # retry 时小幅提价，减少卡在同价位的概率
+                    gas_price_chain = int(gas_price_chain * (1.0 + 0.10 * attempt))
+
+                exec_tx = safe.functions.execTransaction(
+                    w3.to_checksum_address(ctf_addr),
+                    value,
+                    redeem_calldata,
+                    operation,
+                    safe_tx_gas,
+                    base_gas,
+                    gas_price,
+                    w3.to_checksum_address(gas_token),
+                    w3.to_checksum_address(refund_receiver),
+                    sig_bytes,
+                )
+                try:
+                    simulated = exec_tx.call({"from": sender})
+                except Exception as sim_exc:
+                    simulated = None
+                    if verbose:
+                        print(f"[claim] preflight call error (continue): {sim_exc}")
+                if simulated is False:
+                    err = (
+                        f"Safe preflight failed (execTransaction call returned false): "
+                        f"safe_nonce={safe_nonce} sender_nonce={nonce}"
+                    )
+                    send_errors.append(err)
+                    if verbose:
+                        print(f"Safe redeem attempt {attempt+1} failed: {err}")
+                    break
+
+                tx = exec_tx.build_transaction(
+                    {
+                        "from": sender,
+                        "nonce": nonce,
+                        "gas": gas,
+                        "gasPrice": gas_price_chain,
+                    }
+                )
+
+                signed_tx = w3.eth.account.sign_transaction(tx, private_key)
                 raw_tx = getattr(signed_tx, "rawTransaction", None) or getattr(signed_tx, "raw_transaction", None)
                 if raw_tx is None:  # pragma: no cover
                     raise AttributeError("Signed transaction missing rawTransaction/raw_transaction")
                 tx_hash = w3.eth.send_raw_transaction(raw_tx)
                 receipt = w3.eth.wait_for_transaction_receipt(tx_hash, poll_latency=2, timeout=180)
                 if receipt.get("status") != 1:
-                    raise RuntimeError(f"Safe redeemPositions failed status!=1: {tx_hash.hex()}")
+                    err = (
+                        f"Safe redeemPositions reverted on-chain: tx={tx_hash.hex()} "
+                        f"safe_nonce={safe_nonce} sender_nonce={nonce}"
+                    )
+                    send_errors.append(err)
+                    if verbose:
+                        print(f"Safe redeem attempt {attempt+1} failed: {err}")
+                    # 已经上链并回执失败，继续重试通常只会制造 nonce 噪音
+                    break
                 if verbose:
                     print(
                         {

{hyperquant-1.53 → hyperquant-1.55}/uv.lock

@@ -694,7 +694,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.52"
+version = "1.54"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },