hyperquant 0.92__py3-none-any.whl → 0.94__py3-none-any.whl

hyperquant/broker/auth.py

@@ -198,6 +198,57 @@ class Auth:
 
         return args
 
+    @staticmethod
+    def bitmart(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+        method: str = args[0]
+        url: URL = args[1]
+        headers: CIMultiDict = kwargs["headers"]
+
+        session = kwargs["session"]
+        host_key = url.host
+        try:
+            api_name = pybotters.auth.Hosts.items[host_key].name
+        except (KeyError, AttributeError):
+            api_name = host_key
+
+        creds = session.__dict__.get("_apis", {}).get(api_name)
+        if not creds or len(creds) < 3:
+            raise RuntimeError("Bitmart credentials (accessKey, accessSalt, device) are required")
+
+        access_key = creds[0]
+        access_salt = creds[1]
+        access_salt = access_salt.decode("utf-8")
+        device = creds[2]
+        extra_cookie = creds[3] if len(creds) > 3 else None
+
+        cookie_parts = [
+            f"accessKey={access_key}",
+            f"accessSalt={access_salt}",
+            "hasDelegation=false",
+            "delegationType=0",
+            "delegationTypeList=[]",
+        ]
+        if extra_cookie:
+            if isinstance(extra_cookie, str) and extra_cookie:
+                cookie_parts.append(extra_cookie.strip(";"))
+
+        headers["cookie"] = "; ".join(cookie_parts)
+
+        headers.setdefault("x-bm-client", "WEB")
+        headers.setdefault("x-bm-contract", "2")
+        headers.setdefault("x-bm-device", device)
+        headers.setdefault("x-bm-timezone", "Asia/Shanghai")
+        headers.setdefault("x-bm-timezone-offset", "-480")
+        headers.setdefault("x-bm-tag", "")
+        headers.setdefault("x-bm-version", "5e13905")
+        headers.setdefault('User-Agent', 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36 Edg/141.0.0.0')
+
+        ua = headers.get("User-Agent") or headers.get("user-agent")
+        if ua:
+            headers.setdefault("x-bm-ua", ua)
+
+        return args
+
     @staticmethod
     def coinw(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
         method: str = args[0]
@@ -294,3 +345,7 @@ pybotters.auth.Hosts.items["uuapi.rerrkvifj.com"] = pybotters.auth.Item(
 pybotters.auth.Hosts.items["api.coinw.com"] = pybotters.auth.Item(
     "coinw", Auth.coinw
 )
+
+pybotters.auth.Hosts.items["derivatives.bitmart.com"] = pybotters.auth.Item(
+    "bitmart", Auth.bitmart
+)

hyperquant/broker/bitmart.py

@@ -0,0 +1,471 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import random
+import time
+from typing import Any, Literal, Sequence
+
+import pybotters
+
+from .models.bitmart import BitmartDataStore
+from .lib.util import fmt_value
+
+class Bitmart:
+    """Bitmart 合约交易（REST + WebSocket）。"""
+
+    def __init__(
+        self,
+        client: pybotters.Client,
+        *,
+        public_api: str | None = None,
+        forward_api: str | None = None,
+        ws_url: str | None = None,
+        account_index: int | None = None,
+        apis: str = None
+    ) -> None:
+        self.client = client
+        self.store = BitmartDataStore()
+
+        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.account_index = account_index
+        self.apis = apis
+
+    async def __aenter__(self) -> "Bitmart":
+        await self.update("detail")
+        asyncio.create_task(self.auto_refresh())
+        return self
+    
+    async def auto_refresh(self, sec=3600, test=False) -> None:
+        """每隔一小时刷新token"""
+        client = self.client
+        while not client._session.closed:
+
+            await asyncio.sleep(sec)
+
+            if client._session.__dict__["_apis"].get("bitmart") is None:
+                continue
+
+            # 执行请求
+            res = await client.post(
+                f"{self.private_api}/gw-api/gateway/token/v2/renew",
+            )
+
+            print(await res.text())
+            resp:dict = await res.json()
+            if resp.get("success") is False:
+                raise ValueError(f"Bitmart refreshToken error: {resp}")
+
+            data:dict = resp.get("data", {})
+            new_token = data.get("accessToken")
+            secret = data.get("accessSalt")
+
+            # 加载原来的apis
+            apis_dict = client._load_apis(self.apis)
+            
+            device = apis_dict['bitmart'][2]
+
+            apis_dict["bitmart"] = [new_token, secret, device]
+
+            client._session.__dict__["_apis"] = client._encode_apis(apis_dict)
+            
+            if test:
+                print("Bitmart token refreshed.")
+                break
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # pragma: no cover - symmetry
+        return None
+
+    def get_contract_id(self, symbol: str) -> str | None:
+        """Resolve contract ID from cached detail data."""
+        detail = (
+            self.store.detail.get({"name": symbol})
+            or self.store.detail.get({"display_name": symbol})
+            or self.store.detail.get({"contract_id": symbol})
+        )
+        if detail is None:
+            return None
+        contract_id = detail.get("contract_id")
+        if contract_id is None:
+            return None
+        return str(contract_id)
+
+    def _get_detail_entry(
+        self,
+        *,
+        symbol: str | None = None,
+        market_index: int | None = None,
+    ) -> dict[str, Any] | None:
+        if symbol:
+            entry = (
+                self.store.detail.get({"name": symbol})
+                or self.store.detail.get({"display_name": symbol})
+            )
+            if entry:
+                return entry
+
+        if market_index is not None:
+            entries = self.store.detail.find({"contract_id": market_index})
+            if entries:
+                return entries[0]
+            entries = self.store.detail.find({"contract_id": str(market_index)})
+            if entries:
+                return entries[0]
+
+        return None
+
+    @staticmethod
+    def _normalize_enum(
+        value: int | str,
+        mapping: dict[str, int],
+        field: str,
+    ) -> int:
+        if isinstance(value, str):
+            key = value.lower()
+            try:
+                return mapping[key]
+            except KeyError as exc:
+                raise ValueError(f"Unsupported {field}: {value}") from exc
+        try:
+            return int(value)
+        except (TypeError, ValueError) as exc:
+            raise ValueError(f"Unsupported {field}: {value}") from exc
+
+    async def update(
+        self,
+        update_type: Literal[
+            "detail",
+            "orders",
+            "positions",
+            "balances",
+            "account",
+            "all",
+            "history_orders",
+        ] = "all",
+        *,
+        orders_params: dict[str, Any] | None = None,
+        positions_params: dict[str, Any] | None = None,
+    ) -> None:
+        """Refresh cached REST resources."""
+
+        tasks: dict[str, Any] = {}
+
+        include_detail = update_type in {"detail", "all"}
+        include_orders = update_type in {"orders", "all"}
+        include_positions = update_type in {"positions", "all"}
+        include_balances = update_type in {"balances", "account", "all"}
+        include_history_orders = update_type in {"history_orders"}
+
+        if include_detail:
+            tasks["detail"] = self.client.get(f"{self.public_api}/v1/ifcontract/contracts_all")
+
+        if include_orders:
+            params = {
+                "status": 3,
+                "size": 200,
+                "orderType": 0,
+                "offset": 0,
+                "direction": 0,
+                "type": 1,
+            }
+            if orders_params:
+                params.update(orders_params)
+            tasks["orders"] = self.client.get(
+                f"{self.forward_api}/v1/ifcontract/userAllOrders",
+                params=params,
+            )
+
+        if include_positions:
+            params = {"status": 1}
+            if positions_params:
+                params.update(positions_params)
+            tasks["positions"] = self.client.get(
+                f"{self.forward_api}/v1/ifcontract/userPositions",
+                params=params,
+            )
+
+        if include_balances:
+            tasks["balances"] = self.client.get(
+                f"{self.forward_api}/v1/ifcontract/copy/trade/user/info",
+            )
+
+        if include_history_orders:
+            d_params = {"offset": 0, "status": 60, "size": 20, "type": 1}
+            d_params.update(orders_params or {})
+            tasks["history_orders"] = self.client.get(
+                f"{self.forward_api}/v1/ifcontract/userAllOrders",
+                params=d_params,
+            )
+
+        if not tasks:
+            raise ValueError(f"Unsupported update_type: {update_type}")
+
+        results: dict[str, Any] = {}
+        for key, req in tasks.items():
+            res = await req
+            if res.content_type and "json" in res.content_type:
+                results[key] = await res.json()
+            else:
+                text = await res.text()
+                try:
+                    results[key] = json.loads(text)
+                except json.JSONDecodeError as exc:
+                    raise ValueError(
+                        f"Unexpected response format for {key}: {res.content_type} {text[:200]}"
+                    ) from exc
+
+        if "detail" in results:
+            resp = results["detail"]
+            if resp.get("success") is False or resp.get("errno") not in (None, "OK"):
+                raise ValueError(f"Bitmart detail API error: {resp}")
+            self.store.detail._onresponse(resp)
+            for entry in self.store.detail.find():
+                contract_id = entry.get("contract_id")
+                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"]
+            if resp.get("success") is False or resp.get("errno") not in (None, "OK"):
+                raise ValueError(f"Bitmart orders API error: {resp}")
+            self.store.orders._onresponse(resp)
+
+        if "positions" in results:
+            resp = results["positions"]
+            if resp.get("success") is False or resp.get("errno") not in (None, "OK"):
+                raise ValueError(f"Bitmart positions API error: {resp}")
+            self.store.positions._onresponse(resp)
+
+        if "balances" in results:
+            resp = results["balances"]
+            if resp.get("success") is False or resp.get("errno") not in (None, "OK"):
+                raise ValueError(f"Bitmart balances API error: {resp}")
+            self.store.balances._onresponse(resp)
+
+        if "history_orders" in results:
+            resp = results["history_orders"]
+            if resp.get("success") is False or resp.get("errno") not in (None, "OK"):
+                raise ValueError(f"Bitmart history_orders API error: {resp}")
+            self.store.orders._onresponse(resp)
+
+    async def sub_orderbook(
+        self,
+        symbols: Sequence[str] | str,
+        *,
+        depth: str = "Depth",
+        depth_limit: int | None = None,
+    ) -> pybotters.ws.WebSocketApp:
+        """Subscribe order book channel(s)."""
+
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        if not symbols:
+            raise ValueError("symbols must not be empty")
+
+        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)}")
+
+        if depth_limit is not None:
+            self.store.book.limit = depth_limit
+
+        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)
+
+        ws_app = self.client.ws_connect(
+            self.ws_url,
+            send_json=payload,
+            hdlr_json=self.store.onmessage,
+            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位随机数
+        return int(f"{ts}{rand}")
+    
+    async def place_order(
+        self,
+        symbol: str,
+        *,
+        category: Literal[1,2,"limit","market"] = "limit",
+        price: float,
+        qty: float,
+        way: Literal[1, 2, 3, 4, "open_long", "close_short", "close_long", "open_short", "buy", "sell"] = "open_long",
+        mode: Literal[1, 2, 3, 4, "gtc", "ioc", "fok", "maker_only", "maker-only", "post_only"] = "gtc",
+        open_type: Literal[1, 2, "cross", "isolated"] = "isolated",
+        leverage: int | str = 10,
+        reverse_vol: int | float = 0,
+        trigger_price: float | None = None,
+        custom_id: int | str | None = None,
+        extra_params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Submit an order via ``submitOrder``.
+        """
+
+        contract_id = self.get_contract_id(symbol)
+        if contract_id is None:
+            raise ValueError(f"Unknown symbol: {symbol}")
+        contract_id_int = int(contract_id)
+
+        detail = self._get_detail_entry(symbol=symbol, market_index=contract_id_int)
+        if detail is None:
+            await self.update("detail")
+            detail = self._get_detail_entry(symbol=symbol, market_index=contract_id_int)
+        if detail is None:
+            raise ValueError(f"Market metadata unavailable for symbol: {symbol}")
+
+
+        contract_size_str = detail.get("contract_size") or detail.get("vol_unit") or "1"
+        try:
+            contract_size_val = float(contract_size_str)
+        except (TypeError, ValueError):
+            contract_size_val = 1.0
+        if contract_size_val <= 0:
+            raise ValueError(f"Invalid contract_size for {symbol}: {contract_size_str}")
+
+        contracts_float = float(qty) / contract_size_val
+        contracts_int = int(round(contracts_float))
+        if contracts_int <= 0:
+            raise ValueError(
+                f"qty too small for contract size ({contract_size_val}): qty={qty}"
+            )
+        if abs(contracts_float - contracts_int) > 1e-8:
+            raise ValueError(
+                f"qty must be a multiple of contract_size ({contract_size_val}). "
+                f"Received qty={qty} -> {contracts_float} contracts."
+            )
+
+        price_unit = detail.get("price_unit") or 1
+        adjusted_price = float(fmt_value(price, price_unit))
+
+        category = self._normalize_enum(
+            category,
+            {
+                "limit": 1,
+                "market": 2,
+            },
+            "category",
+        )
+
+        way_value = self._normalize_enum(
+            way,
+            {
+                "open_long": 1,
+                "close_short": 2,
+                "close_long": 3,
+                "open_short": 4,
+                "buy": 1,
+                "sell": 4,
+            },
+            "way",
+        )
+        mode_value = self._normalize_enum(
+            mode,
+            {
+                "gtc": 1,
+                "fok": 2,
+                "ioc": 3,
+                "maker_only": 4,
+                "maker-only": 4,
+                "post_only": 4,
+            },
+            "mode",
+        )
+        open_type_value = self._normalize_enum(
+            open_type,
+            {
+                "cross": 1,
+                "isolated": 2,
+            },
+            "open_type",
+        )
+
+        payload: dict[str, Any] = {
+            "place_all_order": False,
+            "contract_id": contract_id_int,
+            "category": category,
+            "price": adjusted_price,
+            "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
+
+        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}")
+        return resp
+
+    async def cancel_order(
+        self,
+        symbol: str,
+        order_ids: Sequence[int | str],
+        *,
+        nonce: int | None = None,
+    ) -> dict[str, Any]:
+        """Cancel one or multiple orders."""
+
+        contract_id = self.get_contract_id(symbol)
+        if contract_id is None:
+            raise ValueError(f"Unknown symbol: {symbol}")
+
+        payload = {
+            "orders": [
+                {
+                    "contract_id": int(contract_id),
+                    "orders": [int(order_id) for order_id in order_ids],
+                }
+            ],
+            "nonce": nonce if nonce is not None else int(time.time()),
+        }
+
+        res = await self.client.post(
+            f"{self.forward_api}/v1/ifcontract/cancelOrders",
+            json=payload,
+        )
+        resp = await res.json()
+        if resp.get("success") is False or resp.get("errno") not in (None, "OK"):
+            raise ValueError(f"Bitmart cancelOrders error: {resp}")
+        return resp

hyperquant/broker/coinup.py

@@ -239,7 +239,7 @@ class Coinup:
                     },
                 }
             )
-        print(payloads)
+        # print(payloads)
 
         if not payloads:
             raise ValueError("channels must not be empty")