hyperquant 1.4__tar.gz → 1.6__tar.gz

{hyperquant-1.4 → hyperquant-1.6}/.gitignore

@@ -28,6 +28,7 @@ wheels/
 env/
 venv/
 ENV/
+apis.json
 
 # IDE
 .idea/
@@ -38,3 +39,7 @@ ENV/
 # OS
 .DS_Store
 Thumbs.db
+
+# Local runtime artifacts
+*.log
+polymarket_orders.log

{hyperquant-1.4 → hyperquant-1.6}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.4"
+version = "1.6"
 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.4 → hyperquant-1.6}/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"]
@@ -679,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
     # --------------------------
@@ -792,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
 )