hyperquant 1.21__py3-none-any.whl → 1.22__py3-none-any.whl

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/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,

hyperquant/broker/models/bitmart.py

@@ -98,29 +98,11 @@ class Book(DataStore):
         self._last_update = ms_t
     
     def _on_message_api(self, msg: dict[str, Any]) -> None:
-        # {
-        #     "data": {
-        #         "symbol": "BTCUSDT",
-        #         "asks": [
-        #             {
-        #                 "price": "70294.4",
-        #                 "vol": "455"
-        #             }
-        #         ],
-        #         "bids": [
-        #             {
-        #                 "price": "70293.9",
-        #                 "vol": "1856"
-        #             }
-        #         ],
-        #         "ms_t": 1730399750402
-        #     },
-        #     "group": "futures/depthAll20:BTCUSDT@200ms"
-        # }
         data = msg.get("data")
         if not isinstance(data, dict):
             return
-        symbol = data.get("symbol")
+        # Some callers embed symbol at top-level; prefer msg["symbol"] when present
+        symbol = msg.get("symbol") or data.get("symbol")
         asks = data.get("asks") or []
         bids = data.get("bids") or []
         if self.limit:
@@ -128,12 +110,19 @@ class Book(DataStore):
             bids = bids[: self.limit]
             
         self._find_and_delete({'s': symbol})
+        # OpenAPI order book arrays are typically [price, size, timestamp]
+        def _normalize_level(level: Any) -> tuple[str, str]:
+            if isinstance(level, dict):
+                return str(level.get("price", "0")), str(level.get("vol", "0"))
+            if isinstance(level, (list, tuple)) and len(level) >= 2:
+                return str(level[0]), str(level[1])
+            return "0", "0"
+
         self._update([
             self._make_entry(
                 symbol,
                 "a",
-                entry.get("price", '0'),
-                entry.get("vol", '0'),
+                *_normalize_level(entry),
             )
             for entry in asks
         ])
@@ -141,11 +130,11 @@ class Book(DataStore):
             self._make_entry(
                 symbol,
                 "b",
-                entry.get("price", '0'),
-                entry.get("vol", '0'),
+                *_normalize_level(entry),
             )
             for entry in bids
         ])
+    
 
     def sorted(self, query: Item | None = None, limit: int | None = None) -> dict[str, list[Item]]:
         return self._sorted(
@@ -325,7 +314,7 @@ class BitmartDataStore(DataStoreCollection):
         self._create("positions", datastore_class=Positions)
         self._create("balances", datastore_class=Balances)
         self._create("ticker", datastore_class=Ticker)
-
+    
     def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
         if isinstance(msg, dict):
             group = msg.get("group")

{hyperquant-1.21.dist-info → hyperquant-1.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.21
+Version: 1.22
 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
@@ -19,6 +19,7 @@ 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: numba>=0.62.1
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pybotters>=1.9.1

{hyperquant-1.21.dist-info → hyperquant-1.22.dist-info}/RECORD

@@ -4,9 +4,9 @@ hyperquant/db.py,sha256=i2TjkCbmH4Uxo7UTDvOYBfy973gLcGexdzuT_YcSeIE,6678
 hyperquant/draw.py,sha256=up_lQ3pHeVLoNOyh9vPjgNwjD0M-6_IetSGviQUgjhY,54624
 hyperquant/logkit.py,sha256=nUo7nx5eONvK39GOhWwS41zNRL756P2J7-5xGzwXnTY,8462
 hyperquant/notikit.py,sha256=x5yAZ_tAvLQRXcRbcg-VabCaN45LUhvlTZnUqkIqfAA,3596
-hyperquant/broker/auth.py,sha256=C8B5-x8Qcaeafm4ZwPCVFR7GRURmHC3CE4_vdg00Qgw,12139
+hyperquant/broker/auth.py,sha256=3Ws_2iaF2NTCVIbkLzL_0ae3y7f4vgj9zmozvGaUXnk,16029
 hyperquant/broker/bitget.py,sha256=X_S0LKZ7FZAEb6oEMr1vdGP1fondzK74BhmNTpRDSEA,9488
-hyperquant/broker/bitmart.py,sha256=2Yd_Jzn0XYzl3rYN1rmNuwy7Wy74T3bBQ-ue7RvIbMU,22206
+hyperquant/broker/bitmart.py,sha256=7j_8TU3Dxjj5HCNX7CbSO3nPZcQH1t31A9UOv5tTbg0,25974
 hyperquant/broker/coinup.py,sha256=eOr8BTRXiTb5tCU2FDmvBdXXgqiwVmCbP5pdeA1ORJ8,20390
 hyperquant/broker/coinw.py,sha256=SnJU0vASh77rfcpMGWaIfTblQSjQk3vjlW_4juYdbcs,17214
 hyperquant/broker/edgex.py,sha256=TqUO2KRPLN_UaxvtLL6HnA9dAQXC1sGxOfqTHd6W5k8,18378
@@ -20,7 +20,7 @@ hyperquant/broker/lib/hpstore.py,sha256=LnLK2zmnwVvhEbLzYI-jz_SfYpO1Dv2u2cJaRAb8
 hyperquant/broker/lib/hyper_types.py,sha256=HqjjzjUekldjEeVn6hxiWA8nevAViC2xHADOzDz9qyw,991
 hyperquant/broker/lib/util.py,sha256=iMU1qF0CHj5zzlIMEQGwjz-qtEVosEe7slXOCuB7Rcw,566
 hyperquant/broker/models/bitget.py,sha256=0RwDY75KrJb-c-oYoMxbqxWfsILe-n_Npojz4UFUq7c,11389
-hyperquant/broker/models/bitmart.py,sha256=hPxSFLmsJif9wm4nTln5G_zCbsoRnM1BF9fnfciZIHo,22061
+hyperquant/broker/models/bitmart.py,sha256=O9RnU-XBeR9SzicG15jzuzK5oy2kMrRJAyZSqC8DXUw,21938
 hyperquant/broker/models/coinup.py,sha256=X_ngB2_sgTOdfAZqTyeWvCN03j-0_inZ6ugZKW6hR7k,11173
 hyperquant/broker/models/coinw.py,sha256=LvLMVP7i-qkkTK1ubw8eBkMK2RQmFoKPxdKqmC4IToY,22157
 hyperquant/broker/models/edgex.py,sha256=vPAkceal44cjTYKQ_0BoNAskOpmkno_Yo1KxgMLPc6Y,33954
@@ -32,6 +32,6 @@ hyperquant/datavison/_util.py,sha256=92qk4vO856RqycO0YqEIHJlEg-W9XKapDVqAMxe6rbw
 hyperquant/datavison/binance.py,sha256=3yNKTqvt_vUQcxzeX4ocMsI5k6Q6gLZrvgXxAEad6Kc,5001
 hyperquant/datavison/coinglass.py,sha256=PEjdjISP9QUKD_xzXNzhJ9WFDTlkBrRQlVL-5pxD5mo,10482
 hyperquant/datavison/okx.py,sha256=yg8WrdQ7wgWHNAInIgsWPM47N3Wkfr253169IPAycAY,6898
-hyperquant-1.21.dist-info/METADATA,sha256=1ZJFW9uGSQFzXQTBy74LLbaay4lUmc_pTOzSOugj_nU,4409
-hyperquant-1.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-1.21.dist-info/RECORD,,
+hyperquant-1.22.dist-info/METADATA,sha256=dH0APcdAjkH7pyeQiyPyTd3tl1E2tQVYxMd5YlbzjrE,4438
+hyperquant-1.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-1.22.dist-info/RECORD,,