hyperquant 1.21__tar.gz → 1.25__tar.gz

{hyperquant-1.21 → hyperquant-1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.21
+Version: 1.25
 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
@@ -16,14 +16,12 @@ Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.10.4
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: cryptography>=44.0.2
-Requires-Dist: curl-cffi>=0.13.0
 Requires-Dist: duckdb>=1.2.2
 Requires-Dist: lighter-sdk
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pybotters>=1.9.1
 Requires-Dist: pyecharts>=2.0.8
-Requires-Dist: rnet==3.0.0rc10
 Description-Content-Type: text/markdown
 
 # minquant

{hyperquant-1.21 → hyperquant-1.25}/apis.json

@@ -27,5 +27,10 @@
     "eyJoZWFkZXIiOnsidHlwIjoiQml0TWFydCIsImFsZyI6IkJNQVBJU0lYIn0sInBheWxvYWQiOnsiamlkIjoiMjk4Mjk1NWMzZTBlNDA5YmFjODYyZGNlOWY0MTFhNDkiLCJ2ZXJzaW9uIjoiMjAyNTExMDEiLCJleHBpcmVzQXQiOjE3NjIwNTE3MzI0NTMsImJtIjoiRVhFbjk2UzV2dGRISmtKZ0hYejlPcTA0a0ZTdFdHTWtRWG5yVHpDZktYdW1OOHFIVTh0WExUeXlTaEMzVFJDMlZHOVhuMWxkcVkzdVdlOHluWlBrTGhqQWNIT0VjK2VoeEhlc3VJVUh3U3ArRVFnMEFtY0JIWW53OVRuelRkb2Fob25jakxBNTdtRDVEK2tPSHNWUXdDdElXRGNsTWdpd1d3V3NlY0d5Y1hNdjJJd1pvUVAwZzRlZUtudTgwNDlpZ1RPdERkN0JLenlFN0tONy85ZWpBL1hHQmg4SzBROW9hTmN6aWwwMmxVUnBGNm9wUUJHVTY1eHhBTkMwR0Zyb2RZMmFNalRtQVN2Si9vdmJMNEQxZGtUcUp6azIxdVlhamllRm9OTmREdlZqMXlzOGdTTGJBc3FWMDlsd2x0M3lTWER2L093a0hyclhJMlAyZVZqU2JuK1hPODhKRTlFYWRpTkcwRU9EOWhLRy9YRFhoU0dVT1N5YnJrNWdLdjNoIn0sInNpZ25hdHVyZSI6InQ3SmRFZ3VhTzNrUU9RSlNBcVRqMDVQRCsrcGR6UjlLVDVZTGhNdmNQRDlvc0tWcjRYMEM0VjkwaStYTm0rMFBxNlhuZGo5SjFSeXFtZVBuVG5QUmRBPT0ifQ==",
     "4OamVUwuSznwyStlmRIfc9o0y5tCYdMOh",
     "1c0886dd192a1dd0f23f71f7ab577a45"
+  ],
+  "bitmart_api":[
+    "21c0e5173835d02805b99641c807375866c41275",
+    "c82fbdb564f194362278b69370c47116db00165fc6a7f5ef770158fcb73a2c70",
+    "api"
   ]
 }

{hyperquant-1.21 → hyperquant-1.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.21"
+version = "1.25"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }
@@ -14,8 +14,6 @@ dependencies = [
     "numpy>=1.21.0", # Added numpy as a new dependency
     "duckdb>=1.2.2",
     "pybotters>=1.9.1",
-    "curl-cffi>=0.13.0",
-    "rnet==3.0.0rc10",
     "lighter-sdk",
 ]
 readme = "README.md"

{hyperquant-1.21 → hyperquant-1.25}/src/hyperquant/broker/auth.py

@@ -249,6 +249,102 @@ class Auth:
 
         return args
 
+    @staticmethod
+    def bitmart_api(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+        """Bitmart OpenAPI (futures v2) signing for api-cloud-v2.bitmart.com.
+
+        Spec per docs:
+        X-BM-SIGN = hex_lower(HMAC_SHA256(secret, timestamp + '#' + memo + '#' + payload_string))
+        - For POST: payload_string is the JSON body string
+        - For GET: payload_string is the query string (if any), otherwise empty
+        Headers required: X-BM-KEY, X-BM-TIMESTAMP, X-BM-SIGN
+        """
+        method: str = args[0]
+        url: URL = args[1]
+        headers: CIMultiDict = kwargs["headers"]
+
+        session = kwargs["session"]
+        try:
+            api_name = pybotters.auth.Hosts.items[url.host].name
+        except (KeyError, AttributeError):
+            api_name = url.host
+
+        creds = session.__dict__.get("_apis", {}).get(api_name)
+        if not creds or len(creds) < 3:
+            raise RuntimeError("Bitmart API credentials (access_key, secret, memo) are required")
+
+        access_key = creds[0]
+        secret = creds[1]
+        memo = creds[2]
+        if isinstance(secret, str):
+            secret_bytes = secret.encode("utf-8")
+        else:
+            secret_bytes = secret
+        if isinstance(memo, bytes):
+            memo = memo.decode("utf-8")
+
+        timestamp = str(int(time.time() * 1000))
+        method_upper = method.upper()
+
+        # Build query string
+        params = kwargs.get("params")
+        if isinstance(params, dict) and params:
+            query_items = [f"{k}={v}" for k, v in params.items() if v is not None]
+            query_string = "&".join(query_items)
+        else:
+            query_string = url.query_string
+
+        # Build body string for signing and ensure sending matches signature
+        body = None
+        body_str = ""
+        if method_upper == "GET":
+            body_str = query_string or ""
+        else:
+            # Prefer original JSON object if present for deterministic signing
+            if kwargs.get("json") is not None:
+                body = kwargs.get("json")
+            else:
+                body = kwargs.get("data")
+
+            # If upstream already turned JSON into JsonPayload, extract its value
+            if isinstance(body, JsonPayload):
+                body_value = getattr(body, "_value", None)
+            else:
+                body_value = body
+
+            if isinstance(body_value, (dict, list)):
+                # Compact JSON to avoid whitespace discrepancies and sign exact bytes we send
+                body_str = pyjson.dumps(body_value, separators=(",", ":"), ensure_ascii=False)
+                kwargs["data"] = body_str
+                kwargs.pop("json", None)
+            elif isinstance(body_value, (str, bytes)):
+                # Sign and send exactly this string/bytes
+                body_str = body_value.decode("utf-8") if isinstance(body_value, bytes) else body_value
+                kwargs["data"] = body_str
+                kwargs.pop("json", None)
+            elif body_value is None:
+                body_str = ""
+            else:
+                # Fallback: string conversion (should still be JSON-like)
+                body_str = str(body_value)
+                kwargs["data"] = body_str
+                kwargs.pop("json", None)
+
+        # Prehash format: timestamp#memo#payload
+        message = f"{timestamp}#{memo}#{body_str}"
+        signature_hex = hmac.new(secret_bytes, message.encode("utf-8"), hashlib.sha256).hexdigest()
+
+        headers.update(
+            {
+                "X-BM-KEY": access_key,
+                "X-BM-TIMESTAMP": timestamp,
+                "X-BM-SIGN": signature_hex,
+                "Content-Type": "application/json; charset=UTF-8",
+            }
+        )
+
+        return args
+
     @staticmethod
     def coinw(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
         method: str = args[0]
@@ -348,4 +444,8 @@ pybotters.auth.Hosts.items["api.coinw.com"] = pybotters.auth.Item(
 
 pybotters.auth.Hosts.items["derivatives.bitmart.com"] = pybotters.auth.Item(
     "bitmart", Auth.bitmart
-)
+)
+
+pybotters.auth.Hosts.items["api-cloud-v2.bitmart.com"] = pybotters.auth.Item(
+    "bitmart_api", Auth.bitmart_api
+)

{hyperquant-1.21 → hyperquant-1.25}/src/hyperquant/broker/bitmart.py

@@ -10,6 +10,41 @@ import pybotters
 
 from .models.bitmart import BitmartDataStore
 
+
+class Book():
+    def __init__(self):
+        self.limit: int | None = None
+        self.store = {}
+    
+    def on_message(self, msg: dict[str, Any], ws=None) -> None:
+        data = msg.get("data")
+        if not isinstance(data, dict):
+            return
+        symbol = data.get("symbol")
+        self.store[symbol] = data
+    
+    def find(self, query: dict[str, Any]) -> dict[str, Any] | None:
+        s = query.get("s")
+        S = query.get("S")
+        item = self.store.get(s)
+        if item:
+            if S == "a":
+                return [{"s": s, "S": "a", "p": item["asks"][0]['price'], "q": item["asks"][0]['vol']}]
+            elif S == "b":
+                return [{"s": s, "S": "b", "p": item["bids"][0]['price'], "q": item["bids"][0]['vol']}]
+        else:
+            return []
+            
+class BitmartDataStore2(BitmartDataStore):
+    def _init(self):
+        self.bk = Book()
+        return super()._init()
+
+    @property
+    def book(self) -> Book:
+        return self.bk
+
+
 class Bitmart:
     """Bitmart 合约交易（REST + WebSocket）。"""
 
@@ -24,17 +59,18 @@ class Bitmart:
         apis: str = None
     ) -> None:
         self.client = client
-        self.store = BitmartDataStore()
+        self.store = BitmartDataStore2()
 
         self.public_api = public_api or "https://contract-v2.bitmart.com"
         self.private_api = "https://derivatives.bitmart.com"
         self.forward_api = f'{self.private_api}/gw-api/contract-tiger/forward'
         self.ws_url = ws_url or "wss://contract-ws-v2.bitmart.com/v1/ifcontract/realTime"
         self.api_ws_url = "wss://openapi-ws-v2.bitmart.com/api?protocol=1.1"
-
+        self.api_url = "https://api-cloud-v2.bitmart.com"
         self.account_index = account_index
         self.apis = apis
         self.symbol_to_contract_id: dict[str, str] = {}
+        self.book = Book()
 
     async def __aenter__(self) -> "Bitmart":
         await self.update("detail")
@@ -244,7 +280,6 @@ class Bitmart:
                 symbol = entry.get("name") or entry.get("display_name")
                 if contract_id is None or symbol is None:
                     continue
-                self.store.book.id_to_symbol[str(contract_id)] = str(symbol)
 
         if "orders" in results:
             resp = results["orders"]
@@ -280,69 +315,41 @@ class Bitmart:
         self,
         symbols: Sequence[str] | str,
         *,
-        depth: str = "Depth",
         depth_limit: int | None = None,
-        use_api_ws: bool = True,
     ) -> pybotters.ws.WebSocketApp:
         """Subscribe order book channel(s)."""
 
         if isinstance(symbols, str):
             symbols = [symbols]
+        
 
         if not symbols:
             raise ValueError("symbols must not be empty")
         if depth_limit is not None:
             self.store.book.limit = depth_limit
-        if not use_api_ws:
-            missing = [sym for sym in symbols if self.get_contract_id(sym) is None]
-            if missing:
-                await self.update("detail")
-                still_missing = [sym for sym in missing if self.get_contract_id(sym) is None]
-                if still_missing:
-                    raise ValueError(f"Unknown symbols: {', '.join(still_missing)}")
-
-
-
-            channels: list[str] = []
-            for symbol in symbols:
-                contract_id = self.get_contract_id(symbol)
-                if contract_id is None:
-                    continue
-                self.store.book.id_to_symbol[str(contract_id)] = symbol
-                channels.append(f"{depth}:{contract_id}")
-
-            if not channels:
-                raise ValueError("No channels resolved for subscription")
-
-            payload = {"action": "subscribe", "args": channels}
-            # print(payload)
+        
+        hdlr_json = self.store.book.on_message
 
-            ws_app = self.client.ws_connect(
-                self.api_ws_url,
-                send_json=payload,
-                hdlr_json=self.store.onmessage,
-            )
-        else:
-            channels: list[str] = []
-            for symbol in symbols:
-                channels.append(f"futures/depthAll5:{symbol}@100ms")
+        channels: list[str] = []
+        for symbol in symbols:
+            channels.append(f"futures/depthAll5:{symbol}@100ms")
 
-            if not channels:
-                raise ValueError("No channels resolved for subscription")
+        if not channels:
+            raise ValueError("No channels resolved for subscription")
 
-            payload = {"action": "subscribe", "args": channels}
-            # print(payload)
+        payload = {"action": "subscribe", "args": channels}
 
-            ws_app = self.client.ws_connect(
-                self.api_ws_url,
-                send_json=payload,
-                hdlr_json=self.store.onmessage,
-                autoping=False,
-            )
+        ws_app = self.client.ws_connect(
+            self.api_ws_url,
+            send_json=payload,
+            hdlr_json=hdlr_json,
+            autoping=False,
+        )
 
         await ws_app._event.wait()
         return ws_app
   
+
     def gen_order_id(self):
         ts = int(time.time() * 1000)  # 13位毫秒时间戳
         rand = random.randint(100000, 999999)  # 6位随机数
@@ -364,6 +371,7 @@ class Bitmart:
         trigger_price: float | None = None,
         custom_id: int | str | None = None,
         extra_params: dict[str, Any] | None = None,
+        use_api: bool = False,
     ) -> int:
         """Submit an order via ``submitOrder``.
         返回值: order_id (int)
@@ -462,42 +470,124 @@ class Bitmart:
             "open_type",
         )
 
-        payload: dict[str, Any] = {
-            "place_all_order": False,
-            "contract_id": contract_id_int,
-            "category": category,
-            "price": price_fmt,
-            "vol": contracts_int,
-            "way": way_value,
-            "mode": mode_value,
-            "open_type": open_type_value,
-            "leverage": leverage,
-            "reverse_vol": reverse_vol,
-        }
+        if use_api:
+            # Official API path
+            order_type_str = "limit" if category == 1 else "market"
+            open_type_str = "cross" if open_type_value == 1 else "isolated"
+            client_oid = str(custom_id or self.gen_order_id())
+            api_payload: dict[str, Any] = {
+                "symbol": symbol,
+                "client_order_id": client_oid,
+                "side": way_value,
+                "type": order_type_str,
+                "mode": mode_value,
+                "leverage": str(leverage),
+                "open_type": open_type_str,
+                "size": int(contracts_int),
+            }
+            if order_type_str == "limit":
+                api_payload["price"] = price_fmt
+            if extra_params:
+                api_payload.update(extra_params)
+            # Ensure leverage is synchronized via official API before placing order
+            try:
+                lev_payload = {
+                    "symbol": symbol,
+                    "leverage": str(leverage),
+                    "open_type": open_type_str,
+                }
+                res_lev = await self.client.post(
+                    f"{self.api_url}/contract/private/submit-leverage",
+                    json=lev_payload,
+                )
+                txt_lev = await res_lev.text()
+                try:
+                    resp_lev = json.loads(txt_lev)
+                    if resp_lev.get("code") != 1000:
+                        # ignore and proceed; order may still pass
+                        pass
+                except json.JSONDecodeError:
+                    pass
+                await asyncio.sleep(0.05)
+            except Exception:
+                pass
+
+            res = await self.client.post(
+                f"{self.api_url}/contract/private/submit-order",
+                json=api_payload,
+            )
+            # Parse response (some errors may return text/plain containing JSON)
+            text = await res.text()
+            try:
+                resp = json.loads(text)
+            except json.JSONDecodeError:
+                raise ValueError(f"Bitmart API submit-order non-json response: {text[:200]}")
+            if resp.get("code") != 1000:
+                # Auto-sync leverage once if required, then retry once
+                if resp.get("code") in (40012,):
+                    try:
+                        # Retry leverage sync via official API then retry the order
+                        lev_payload = {
+                            "symbol": symbol,
+                            "leverage": str(leverage),
+                            "open_type": open_type_str,
+                        }
+                        await self.client.post(
+                            f"{self.api_url}/contract/private/submit-leverage",
+                            json=lev_payload,
+                        )
+                        await asyncio.sleep(0.05)
+                        res2 = await self.client.post(
+                            f"{self.api_url}/contract/private/submit-order",
+                            json=api_payload,
+                        )
+                        text2 = await res2.text()
+                        try:
+                            resp2 = json.loads(text2)
+                        except json.JSONDecodeError:
+                            raise ValueError(
+                                f"Bitmart API submit-order non-json response: {text2[:200]}"
+                            )
+                        if resp2.get("code") == 1000:
+                            return resp2.get("data", {}).get("order_id")
+                        else:
+                            raise ValueError(f"Bitmart API submit-order error: {resp2}")
+                    except Exception:
+                        # Fall through to raise original error if sync failed
+                        pass
+                raise ValueError(f"Bitmart API submit-order error: {resp}")
+            return resp.get("data", {}).get("order_id")
+        else:
+            payload: dict[str, Any] = {
+                "place_all_order": False,
+                "contract_id": contract_id_int,
+                "category": category,
+                "price": price_fmt,
+                "vol": contracts_int,
+                "way": way_value,
+                "mode": mode_value,
+                "open_type": open_type_value,
+                "leverage": leverage,
+                "reverse_vol": reverse_vol,
+            }
 
-        if trigger_price is not None:
-            payload["trigger_price"] = trigger_price
+            if trigger_price is not None:
+                payload["trigger_price"] = trigger_price
 
-        payload["custom_id"] = custom_id or self.gen_order_id()
+            payload["custom_id"] = custom_id or self.gen_order_id()
             
-        if extra_params:
-            payload.update(extra_params)
-        
-        # print(payload)
-        # exit()
-        
-        res = await self.client.post(
-            f"{self.forward_api}/v1/ifcontract/submitOrder",
-            json=payload,
-        )
-        resp = await res.json()
-        
-        if resp.get("success") is False or resp.get("errno") not in (None, "OK"):
-            raise ValueError(f"Bitmart submitOrder error: {resp}")
-        
-        # {"errno":"OK","message":"Success","data":{"order_id":3000236525013551},"success":true}
-        # 直接取order_id返回
-        return resp.get("data", {}).get("order_id")
+            if extra_params:
+                payload.update(extra_params)
+            
+            res = await self.client.post(
+                f"{self.forward_api}/v1/ifcontract/submitOrder",
+                json=payload,
+            )
+            resp = await res.json()
+            
+            if resp.get("success") is False or resp.get("errno") not in (None, "OK"):
+                raise ValueError(f"Bitmart submitOrder error: {resp}")
+            return resp.get("data", {}).get("order_id")
 
     async def cancel_order(
         self,