hyperquant 1.57__tar.gz → 1.58__tar.gz

{hyperquant-1.57 → hyperquant-1.58}/PKG-INFO

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

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

{hyperquant-1.57 → hyperquant-1.58}/src/hyperquant/broker/polymarket.py

@@ -8,7 +8,7 @@ from functools import lru_cache
 import os
 import time
 from typing import Any, Awaitable, Callable, Iterable, Iterator, Literal, Mapping, Sequence
-from urllib.parse import urlsplit, urlunsplit
+from urllib.parse import urlencode, urlsplit, urlunsplit
 
 import json
 
@@ -232,7 +232,8 @@ class Polymarket:
         private_key: str | None = None,
         chain_id: int | None = None,
         signature_type: int | None = None,
-        funder: str | None = None
+        funder: str | None = None,
+        forward_url: str | None = None, # geoblock转发
     ) -> None:
         # Logger (per-class, safe default)
         self.logger = logging.getLogger(f"{API_NAME}.{self.__class__.__name__}")
@@ -247,6 +248,7 @@ class Polymarket:
         self.client = client
         self.rest_api = (rest_api or DEFAULT_REST_ENDPOINT).rstrip("/")
         self.ws_public = ws_public or DEFAULT_WS_ENDPOINT
+        self.forward_url = forward_url
 
         self.chain_id = chain_id or 137
         # Default to POLY_GNOSIS_SAFE (2) to match common proxy flows used in examples/tests.
@@ -802,13 +804,19 @@ class Polymarket:
 
     async def create_api_key(self, nonce: int | None = None) -> dict[str, Any]:
         params = {"nonce": nonce} if nonce is not None else None
-        data = await self._rest("POST", "/auth/api-key", params=params)
+        if self.forward_url:
+            data = await self._forward_l1_auth_request("POST", "/auth/api-key", params=params)
+        else:
+            data = await self._rest("POST", "/auth/api-key", params=params)
         self._store_api_creds(data)
         return data
 
     async def derive_api_key(self, nonce: int | None = None) -> dict[str, Any]:
         params = {"nonce": nonce} if nonce is not None else None
-        data = await self._rest("GET", "/auth/derive-api-key", params=params)
+        if self.forward_url:
+            data = await self._forward_l1_auth_request("GET", "/auth/derive-api-key", params=params)
+        else:
+            data = await self._rest("GET", "/auth/derive-api-key", params=params)
         self._store_api_creds(data)
         return data
 
@@ -1506,6 +1514,135 @@ class Polymarket:
             "Content-Type": "application/json",
         }
 
+    def _build_l1_signed_headers(self, *, nonce: int = 0) -> dict[str, str]:
+        from eth_account import Account as _A
+        try:
+            from eth_account.messages import encode_typed_data as _enc
+        except ImportError:
+            from eth_account.messages import encode_structured_data as _enc
+
+        private_key, _, signer_addr = self._get_signing_context()
+        timestamp = int(time.time())
+        typed_data = {
+            "types": {
+                "EIP712Domain": [
+                    {"name": "name", "type": "string"},
+                    {"name": "version", "type": "string"},
+                    {"name": "chainId", "type": "uint256"},
+                ],
+                "ClobAuth": [
+                    {"name": "address", "type": "address"},
+                    {"name": "timestamp", "type": "string"},
+                    {"name": "nonce", "type": "uint256"},
+                    {"name": "message", "type": "string"},
+                ],
+            },
+            "domain": {
+                "name": "ClobAuthDomain",
+                "version": "1",
+                "chainId": int(self.chain_id),
+            },
+            "primaryType": "ClobAuth",
+            "message": {
+                "address": signer_addr,
+                "timestamp": str(timestamp),
+                "nonce": int(nonce),
+                "message": "This message attests that I control the given wallet",
+            },
+        }
+        encoded = _enc(full_message=typed_data)
+        signature = _A.sign_message(encoded, private_key).signature.hex()
+        if not signature.startswith("0x"):
+            signature = f"0x{signature}"
+        return {
+            "POLY_ADDRESS": signer_addr,
+            "POLY_SIGNATURE": signature,
+            "POLY_TIMESTAMP": str(timestamp),
+            "POLY_NONCE": str(int(nonce)),
+            "Content-Type": "application/json",
+        }
+
+    async def _forward_l1_auth_request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        session: aiohttp.ClientSession = getattr(self.client, "_session", None)
+        if session is None:
+            raise RuntimeError("pybotters client session missing")
+        if not self.forward_url:
+            raise RuntimeError("forward_url is required for forward auth request")
+
+        nonce = 0
+        if params and "nonce" in params:
+            try:
+                nonce = int(params["nonce"])
+            except (TypeError, ValueError):
+                nonce = 0
+
+        query = urlencode(dict(params), doseq=True) if params else ""
+        url = f"{self.rest_api.rstrip('/')}{path}"
+        if query:
+            url = f"{url}?{query}"
+        req = {
+            "method": method.upper(),
+            "url": url,
+            "headers": self._build_l1_signed_headers(nonce=nonce),
+            "body": None,
+        }
+
+        endpoint = self._normalize_forward_batch_url(self.forward_url)
+        async with session.post(endpoint, json={"requests": [req]}) as resp:
+            if resp.status >= 400:
+                text = await resp.text()
+                raise RuntimeError(f"Forward auth request failed: {resp.status} {text}")
+            payload = await resp.json(content_type=None)
+
+        first: Any
+        if isinstance(payload, list):
+            first = payload[0] if payload else {}
+        elif isinstance(payload, dict):
+            for key in ("responses", "results", "data"):
+                value = payload.get(key)
+                if isinstance(value, list):
+                    first = value[0] if value else {}
+                    break
+            else:
+                first = payload
+        else:
+            raise RuntimeError(f"Unexpected forward response: {payload!r}")
+
+        def _parse_maybe_json(data: Any) -> Any:
+            if isinstance(data, str):
+                text = data.strip()
+                try:
+                    return json.loads(text)
+                except Exception:
+                    return text
+            return data
+
+        if isinstance(first, dict):
+            # worker forwarder shape: { ok, status, bodyPreview }
+            if first.get("ok") is False or int(first.get("status", 200)) >= 400:
+                detail = _parse_maybe_json(first.get("bodyPreview") or first.get("body") or first)
+                raise RuntimeError(
+                    f"Forward upstream auth failed: status={first.get('status')} detail={detail!r}"
+                )
+
+            body = _parse_maybe_json(first.get("body"))
+            if isinstance(body, dict):
+                return body
+
+            preview = _parse_maybe_json(first.get("bodyPreview"))
+            if isinstance(preview, dict):
+                return preview
+
+            if all(k in first for k in ("apiKey", "secret", "passphrase")):
+                return first
+        raise RuntimeError(f"Forward response missing auth body: {payload!r}")
+
     async def _submit_forward_requests(self, requests_payload: Sequence[Mapping[str, Any]]) -> Any:
         cfg = self._forward_orders_cfg
         if not cfg:

{hyperquant-1.57 → hyperquant-1.58}/uv.lock

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