hyperquant 1.21__py3-none-any.whl → 1.24__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/lighter.py

@@ -9,6 +9,7 @@ import pybotters
 
 from lighter.api.account_api import AccountApi
 from lighter.api.order_api import OrderApi
+from lighter.api.candlestick_api import CandlestickApi
 from lighter.api_client import ApiClient
 from lighter.configuration import Configuration
 from lighter.signer_client import SignerClient
@@ -31,6 +32,7 @@ class Lighter:
         api_key_index: int = 3,
         api_client: ApiClient | None = None,
         order_api: OrderApi | None = None,
+        candlestick_api: CandlestickApi | None = None,
         account_api: AccountApi | None = None,
         ws_url: str | None = None,
     ) -> None:
@@ -46,6 +48,7 @@ class Lighter:
         self._owns_api_client = api_client is None
 
         self.order_api = order_api or OrderApi(self._api_client)
+        self.candlestick_api = candlestick_api or CandlestickApi(self._api_client)
         self.account_api = account_api or AccountApi(self._api_client)
         self.signer: SignerClient = None
 
@@ -150,7 +153,9 @@ class Lighter:
 
 
         if include_detail:
-            tasks.append(("detail", self.order_api.order_books()))
+            # Use raw HTTP to avoid strict SDK model validation issues (e.g., status 'inactive').
+            url = f"{self.configuration.host.rstrip('/')}/api/v1/orderBooks"
+            tasks.append(("detail", self.client.get(url)))
 
         if include_orders:
             if account_index is None or symbol is None:
@@ -206,7 +211,12 @@ class Lighter:
         results: dict[str, Any] = {}
         for key, coroutine in tasks:
             try:
-                results[key] = await coroutine
+                resp = await coroutine
+                if key == "detail":
+                    # Parse JSON body for detail endpoint
+                    results[key] = await resp.json()
+                else:
+                    results[key] = resp
             except Exception:
                 logger.exception("Lighter REST request %s failed", key)
                 raise
@@ -300,6 +310,71 @@ class Lighter:
 
         return await self.sub_orderbook(market_ids=[], account_ids=account_ids)
 
+    async def sub_kline(
+        self,
+        symbols: Sequence[str] | str,
+        *,
+        resolutions: Sequence[str] | str,
+    ) -> pybotters.ws.WebSocketApp:
+        """Subscribe to trade streams and aggregate into klines in the store.
+
+        - symbols: list of symbols (e.g., ["BTC-USD"]) or a single symbol; may also be numeric market_ids.
+        - resolutions: list like ["1m", "5m"] or a single resolution; added to kline store for aggregation.
+        """
+
+        # Normalize inputs
+        symbol_list = [symbols] if isinstance(symbols, str) else list(symbols)
+        res_list = [resolutions] if isinstance(resolutions, str) else list(resolutions)
+
+        if not symbol_list:
+            raise ValueError("At least one symbol must be provided")
+        if not res_list:
+            raise ValueError("At least one resolution must be provided")
+
+        # Ensure market metadata for symbol->market_id resolution
+        needs_detail = any(self.get_contract_id(sym) is None and not str(sym).isdigit() for sym in symbol_list)
+        if needs_detail:
+            try:
+                await self.update("detail")
+            except Exception:
+                logger.exception("Failed to refresh Lighter market metadata for kline subscription")
+                raise
+
+        # Resolve market ids and populate id->symbol mapping for klines store
+        trade_market_ids: list[str] = []
+        for sym in symbol_list:
+            market_id = self.get_contract_id(sym)
+            if market_id is None:
+                if str(sym).isdigit():
+                    market_id = str(sym)
+                    symbol_for_map = str(sym)
+                else:
+                    raise ValueError(f"Unknown symbol: {sym}")
+            else:
+                symbol_for_map = sym
+            market_id_str = str(market_id)
+            trade_market_ids.append(market_id_str)
+            # ensure klines store can resolve symbol from market id
+            self.store.klines.id_to_symbol[market_id_str] = symbol_for_map
+
+        # Register resolutions into kline store aggregation list
+        for r in res_list:
+            if r not in self.store.klines._res_list:
+                self.store.klines._res_list.append(r)
+
+        # Build subscribe payload for trade channels
+        channels = [f"trade/{mid}" for mid in trade_market_ids]
+        send_payload = [{"type": "subscribe", "channel": ch} for ch in channels]
+
+        ws_app = self.client.ws_connect(
+            self.ws_url,
+            send_json=send_payload,
+            hdlr_json=self.store.onmessage,
+        )
+
+        await ws_app._event.wait()
+        return ws_app
+
     async def place_order(
         self,
         symbol: str,
@@ -468,3 +543,60 @@ class Lighter:
             "request": request_payload,
             "response": response_payload,
         }
+
+    async def update_kline(
+        self,
+        symbol: str,
+        *,
+        resolution: str,
+        start_timestamp: int,
+        end_timestamp: int,
+        count_back: int,
+        set_timestamp_to_end: bool | None = None,
+    ) -> list[dict[str, Any]]:
+        """Fetch candlesticks and update the Kline store.
+
+        Parameters
+        - symbol: market symbol, e.g. "BTC-USD".
+        - resolution: e.g. "1m", "5m", "1h".
+        - start_timestamp: epoch milliseconds.
+        - end_timestamp: epoch milliseconds.
+        - count_back: number of bars to fetch.
+        - set_timestamp_to_end: if True, API sets last bar timestamp to the end.
+        """
+
+        market_id = self.get_contract_id(symbol)
+        if market_id is None:
+            # try to refresh metadata once
+            await self.update("detail")
+            market_id = self.get_contract_id(symbol)
+        if market_id is None:
+            raise ValueError(f"Unknown symbol: {symbol}")
+
+        resp = await self.candlestick_api.candlesticks(
+            market_id=int(market_id),
+            resolution=resolution,
+            start_timestamp=int(start_timestamp),
+            end_timestamp=int(end_timestamp),
+            count_back=int(count_back),
+            set_timestamp_to_end=bool(set_timestamp_to_end) if set_timestamp_to_end is not None else None,
+        )
+
+        # Update store
+        self.store.klines._onresponse(resp, symbol=symbol, resolution=resolution)
+
+        payload = _maybe_to_dict(resp) or {}
+        items = payload.get("candlesticks") or []
+        # attach symbol/resolution to return
+        out: list[dict[str, Any]] = []
+        for it in items:
+            if hasattr(it, "to_dict"):
+                d = it.to_dict()
+            elif hasattr(it, "model_dump"):
+                d = it.model_dump()
+            else:
+                d = dict(it) if isinstance(it, dict) else {"value": it}
+            d["symbol"] = symbol
+            d["resolution"] = resolution
+            out.append(d)
+        return out