hyperquant 1.3__tar.gz → 1.5__tar.gz

{hyperquant-1.3 → hyperquant-1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.3
+Version: 1.5
 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
@@ -12,17 +12,16 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Office/Business :: Financial :: Investment
-Requires-Python: >=3.11
-Requires-Dist: aiohttp>=3.10.4
+Requires-Python: >=3.13
+Requires-Dist: aiohttp>=3.13
+Requires-Dist: coincurve>=21.0.0
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: cryptography>=44.0.2
 Requires-Dist: duckdb>=1.2.2
 Requires-Dist: eth-account>=0.10.0
-Requires-Dist: lighter-sdk
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=2.2.3
-Requires-Dist: py-clob-client>=0.28.0
-Requires-Dist: pybotters>=1.9.1
+Requires-Dist: pybotters>=1.10
 Requires-Dist: pyecharts>=2.0.8
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: web3>=7.14.0

{hyperquant-1.3 → hyperquant-1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.3"
+version = "1.5"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }
@@ -9,19 +9,18 @@ dependencies = [
     "pyecharts>=2.0.8",
     "pandas>=2.2.3",
     "colorama>=0.4.6",
-    "aiohttp>=3.10.4",
+    "aiohttp>=3.13",
     "cryptography>=44.0.2",
     "numpy>=1.21.0", # Added numpy as a new dependency
     "duckdb>=1.2.2",
-    "pybotters>=1.9.1",
-    "lighter-sdk",
+    "pybotters>=1.10",
     "eth-account>=0.10.0",
     "web3>=7.14.0",
     "python-dotenv>=1.2.1",
-    "py-clob-client>=0.28.0",
+    "coincurve>=21.0.0"
 ]
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.13"
 
 
 keywords = ["quant", "backtesting", "trading", "hyperquant"]

{hyperquant-1.3 → hyperquant-1.5}/src/hyperquant/broker/auth.py

@@ -3,6 +3,7 @@ import hmac
 import urllib.parse
 import time
 import hashlib
+from functools import lru_cache
 from typing import Any
 from aiohttp import ClientWebSocketResponse, FormData, JsonPayload
 from multidict import CIMultiDict
@@ -12,11 +13,18 @@ import json as pyjson
 from urllib.parse import urlencode
 from datetime import datetime, timezone
 from eth_account import Account
-from eth_account.messages import encode_typed_data
+try:
+    from eth_account.messages import encode_typed_data
+except ImportError:
+    from eth_account.messages import encode_structured_data as encode_typed_data
+from eth_utils import keccak, to_checksum_address
 import secrets
 from random import random
-from datetime import datetime, timezone
 
+try:
+    from coincurve import PrivateKey as _CoincurvePrivateKey
+except Exception:  # pragma: no cover - optional dependency
+    _CoincurvePrivateKey = None
 
 POLY_ADDRESS = "POLY_ADDRESS"
 POLY_SIGNATURE = "POLY_SIGNATURE"
@@ -27,6 +35,53 @@ POLY_PASSPHRASE = "POLY_PASSPHRASE"
 CLOB_AUTH_DOMAIN = {"name": "ClobAuthDomain", "version": "1"}
 CLOB_AUTH_MESSAGE = "This message attests that I control the given wallet"
 
+_PM_DOMAIN_TYPEHASH = keccak(b"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
+_PM_ORDER_TYPEHASH = keccak(
+    b"Order(uint256 salt,address maker,address signer,address taker,uint256 tokenId,uint256 makerAmount,uint256 takerAmount,uint256 expiration,uint256 nonce,uint256 feeRateBps,uint8 side,uint8 signatureType)"
+)
+_PM_DOMAIN_NAME_HASH = keccak(text="Polymarket CTF Exchange")
+_PM_DOMAIN_VERSION_HASH = keccak(text="1")
+
+
+def _int_to_32(val: int) -> bytes:
+    return int(val).to_bytes(32, "big", signed=False)
+
+
+def _addr_to_32(addr: str) -> bytes:
+    # Normalize to checksum to match eth signing behavior
+    normalized = to_checksum_address(addr)
+    return int(normalized, 16).to_bytes(32, "big", signed=False)
+
+
+@lru_cache(maxsize=32)
+def _pm_domain_separator(chain_id: int, verifying_contract: str) -> bytes:
+    return keccak(
+        _PM_DOMAIN_TYPEHASH
+        + _PM_DOMAIN_NAME_HASH
+        + _PM_DOMAIN_VERSION_HASH
+        + _int_to_32(chain_id)
+        + _addr_to_32(verifying_contract),
+    )
+
+
+def _pm_order_hash(message: dict[str, Any]) -> bytes:
+    """Manually hash the Polymarket Order struct for EIP-712."""
+    return keccak(
+        _PM_ORDER_TYPEHASH
+        + _int_to_32(message["salt"])
+        + _addr_to_32(message["maker"])
+        + _addr_to_32(message["signer"])
+        + _addr_to_32(message["taker"])
+        + _int_to_32(message["tokenId"])
+        + _int_to_32(message["makerAmount"])
+        + _int_to_32(message["takerAmount"])
+        + _int_to_32(message["expiration"])
+        + _int_to_32(message["nonce"])
+        + _int_to_32(message["feeRateBps"])
+        + _int_to_32(message["side"])
+        + _int_to_32(message["signatureType"]),
+    )
+
 
 def md5_hex(s: str) -> str:
     return hashlib.md5(s.encode("utf-8")).hexdigest()
@@ -484,7 +539,7 @@ class Auth:
         return args
 
     @staticmethod
-    def polymarket(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+    def polymarket_back(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
         method: str = args[0].upper()
         url: URL = args[1]
         headers: CIMultiDict = kwargs["headers"]
@@ -499,9 +554,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")
@@ -621,6 +734,11 @@ class Auth:
 
         return args
 
+    @staticmethod
+    def polymarket(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+        """Alias kept for backward compatibility with pybotters host registration."""
+        return Auth.polymarket_back(args, kwargs)
+
     # --------------------------
     # Polymarket order signing
     # --------------------------
@@ -734,6 +852,81 @@ class Auth:
         }
         return out
 
+    @staticmethod
+    def sign_polymarket_order2(
+        *,
+        private_key: str,
+        chain_id: int,
+        exchange_address: str,
+        order: dict[str, Any],
+    ) -> dict[str, Any]:
+        """
+        Fast EIP-712 signer using coincurve + manual hashing.
+
+        Avoids heavy typed-data helpers by caching type/domain hashes and
+        signing the final digest directly.
+        """
+        if _CoincurvePrivateKey is None:
+            raise RuntimeError("coincurve is required for sign_polymarket_order2")
+
+        try:
+            now_ts = datetime.now().replace(tzinfo=timezone.utc).timestamp()
+            generated_salt = round(now_ts * random())
+        except Exception:
+            generated_salt = int(time.time())
+
+        side = int(order.get("side", 0))
+        signature_type = int(order.get("signatureType", 1))
+        signer_addr = order.get("signer") or Account.from_key(private_key).address
+        taker_addr = order.get("taker") or "0x0000000000000000000000000000000000000000"
+
+        message = {
+            "salt": int(order.get("salt") or generated_salt),
+            "maker": order.get("maker"),
+            "signer": signer_addr,
+            "taker": taker_addr,
+            "tokenId": int(order["tokenId"]),
+            "makerAmount": int(order["makerAmount"]),
+            "takerAmount": int(order["takerAmount"]),
+            "expiration": int(order.get("expiration", 0)),
+            "nonce": int(order.get("nonce", 0)),
+            "feeRateBps": int(order.get("feeRateBps", 0)),
+            "side": side,
+            "signatureType": signature_type,
+        }
+
+        # Normalize addresses for hashing
+        exchange_addr = to_checksum_address(exchange_address)
+        message["maker"] = to_checksum_address(message["maker"])
+        message["signer"] = to_checksum_address(message["signer"])
+        message["taker"] = to_checksum_address(message["taker"])
+
+        domain_sep = _pm_domain_separator(int(chain_id), exchange_addr)
+        msg_hash = _pm_order_hash(message)
+        typed_hash = keccak(b"\x19\x01" + domain_sep + msg_hash)
+
+        pk_bytes = bytes.fromhex(private_key[2:] if private_key.startswith("0x") else private_key)
+        sig65 = _CoincurvePrivateKey(pk_bytes).sign_recoverable(typed_hash, hasher=None)
+        r, s, rec_id = sig65[:32], sig65[32:64], sig65[64]
+        v = rec_id + 27  # align with eth_account v
+        signature = "0x" + (r + s + bytes([v])).hex()
+
+        return {
+            "salt": int(message["salt"]),
+            "maker": message["maker"],
+            "signer": message["signer"],
+            "taker": message["taker"],
+            "tokenId": str(message["tokenId"]),
+            "makerAmount": str(message["makerAmount"]),
+            "takerAmount": str(message["takerAmount"]),
+            "expiration": str(message["expiration"]),
+            "nonce": str(message["nonce"]),
+            "feeRateBps": str(message["feeRateBps"]),
+            "side": "BUY" if side == 0 else "SELL",
+            "signatureType": int(signature_type),
+            "signature": signature,
+        }
+
 pybotters.auth.Hosts.items["futures.ourbit.com"] = pybotters.auth.Item(
     "ourbit", Auth.ourbit
 )