hyperquant 0.64__py3-none-any.whl → 0.66__py3-none-any.whl

hyperquant/broker/auth.py

@@ -1,7 +1,10 @@
+import base64
+import hmac
+import urllib.parse
 import time
 import hashlib
 from typing import Any
-from aiohttp import ClientWebSocketResponse
+from aiohttp import ClientWebSocketResponse, FormData, JsonPayload
 from multidict import CIMultiDict
 from yarl import URL
 import pybotters
@@ -13,8 +16,106 @@ def md5_hex(s: str) -> str:
     return hashlib.md5(s.encode("utf-8")).hexdigest()
 
 
+
+def serialize(obj, prefix=''):
+    """
+    Python 版 UK/v：递归排序 + urlencode + 展平
+    """
+    def _serialize(obj, prefix=''):
+        if obj is None:
+            return []
+        if isinstance(obj, dict):
+            items = []
+            for k in sorted(obj.keys()):
+                v = obj[k]
+                n = f"{prefix}[{k}]" if prefix else k
+                items.extend(_serialize(v, n))
+            return items
+        elif isinstance(obj, list):
+            # JS style: output key once, then join values by &
+            values = []
+            for v in obj:
+                if isinstance(v, dict):
+                    # Recursively serialize dict, but drop key= part (just use value part)
+                    sub = _serialize(v, prefix)
+                    # sub is a list of key=value, but we want only value part
+                    for s in sub:
+                        # s is like 'key=value', need only value
+                        parts = s.split('=', 1)
+                        if len(parts) == 2:
+                            values.append(parts[1])
+                        else:
+                            values.append(parts[0])
+                else:
+                    # Handle booleans and empty strings
+                    if isinstance(v, bool):
+                        val = "true" if v else "false"
+                    elif v == "":
+                        val = ""
+                    else:
+                        val = str(v)
+                    values.append(val)
+            return [f"{urllib.parse.quote(str(prefix))}={'&'.join(values)}"]
+        else:
+            # Handle booleans and empty strings
+            if isinstance(obj, bool):
+                val = "true" if obj else "false"
+            elif obj == "":
+                val = ""
+            else:
+                val = str(obj)
+            return [f"{urllib.parse.quote(str(prefix))}={val}"]
+    return "&".join(_serialize(obj, prefix))
+
 # 🔑 Ourbit 的鉴权函数
 class Auth:
+    @staticmethod
+    def edgex(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
+        method: str = args[0]
+        url: URL = args[1]
+        data = kwargs.get("data") or {}
+        headers: CIMultiDict = kwargs["headers"]
+
+        session = kwargs["session"]
+        api_key:str = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][0]
+        secret = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][1]
+        passphrase:str = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][2]
+        passphrase = passphrase.split("-")[0]
+        timestamp = str(int(time.time() * 1000))
+        # timestamp = "1758535055061"
+
+        raw_body = ""
+        if data and method.upper() in ["POST", "PUT", "PATCH"] and data:
+            raw_body = serialize(data)
+        else:
+            raw_body = serialize(dict(url.query.items()))
+
+
+        secret_quoted = urllib.parse.quote(secret, safe="")
+        b64_secret = base64.b64encode(secret_quoted.encode("utf-8")).decode()
+        message = f"{timestamp}{method.upper()}{url.raw_path}{raw_body}"
+        sign = hmac.new(b64_secret.encode("utf-8"), message.encode("utf-8"), hashlib.sha256).hexdigest()
+        
+        sigh_header =  {
+                "X-edgeX-Api-Key": api_key,
+                "X-edgeX-Passphrase": passphrase,
+                "X-edgeX-Signature": sign,
+                "X-edgeX-Timestamp": timestamp,
+        }
+        # ws单独进行签名
+        if headers.get("Upgrade") == "websocket":
+            json_str = pyjson.dumps(sigh_header, separators=(",", ":"))
+            b64_str = base64.b64encode(json_str.encode("utf-8")).decode("utf-8")
+            b64_str.replace("=", "")
+            headers.update({"Sec-WebSocket-Protocol": b64_str})
+        else:
+            headers.update(sigh_header)
+
+        if data:
+            kwargs.update({"data": JsonPayload(data)})
+
+        return args
+    
     @staticmethod
     def ourbit(args: tuple[str, URL], kwargs: dict[str, Any]) -> tuple[str, URL]:
         method: str = args[0]
@@ -67,16 +168,6 @@ class Auth:
         token = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][0]
         cookie = f"uc_token={token}; u_id={token}; "
         headers.update({"cookie": cookie})
-
-        # wss消息增加参数
-        # if headers.get("Upgrade") == "websocket":
-        #     args = (method, url)
-        #     # 拼接 token
-        #     q = dict(url.query)
-        #     q["token"] = token
-        #     url = url.with_query(q)
-
-
         return args
 
 
@@ -86,3 +177,12 @@ pybotters.auth.Hosts.items["futures.ourbit.com"] = pybotters.auth.Item(
 pybotters.auth.Hosts.items["www.ourbit.com"] = pybotters.auth.Item(
     "ourbit", Auth.ourbit_spot
 )
+
+pybotters.auth.Hosts.items["pro.edgex.exchange"] = pybotters.auth.Item(
+    "edgex", Auth.edgex
+)
+
+
+pybotters.auth.Hosts.items["quote.edgex.exchange"] = pybotters.auth.Item(
+    "edgex", Auth.edgex
+)

hyperquant/broker/edgex.py

@@ -1,12 +1,43 @@
 from __future__ import annotations
 
+import asyncio
+from decimal import Decimal
+import hashlib
+import math
+import random
+import re
 import time
 from typing import Any, Iterable, Literal
 
 import pybotters
 
 from .models.edgex import EdgexDataStore
-
+from .lib.edgex_sign import LimitOrderMessage, LimitOrderSigner
+from .lib.util import fmt_value
+
+def gen_client_id():
+    # 1. 生成 [0,1) 的浮点数
+    r = random.random()
+    # 2. 转成字符串
+    s = str(r)  # e.g. "0.123456789"
+    # 3. 去掉 "0."
+    digits = s[2:]
+    # 4. 去掉前导 0
+    digits = re.sub(r"^0+", "", digits)
+    return digits
+
+
+def calc_nonce(client_order_id: str) -> int:
+    digest = hashlib.sha256(client_order_id.encode()).hexdigest()
+    return int(digest[:8], 16)
+
+def bignumber_to_string(x: Decimal) -> str:
+    # normalize 去掉尾随零，然后用 f 格式避免科学计数法
+    s = format(x.normalize(), "f")
+    # 去掉小数点后多余的 0
+    if "." in s:
+        s = s.rstrip("0").rstrip(".")
+    return s
 
 class Edgex:
     """
@@ -35,11 +66,47 @@ class Edgex:
         # 公共端点可能因环境/地区不同而变化，允许外部覆盖。
         self.api_url = api_url or "https://pro.edgex.exchange"
         self.ws_url = "wss://quote.edgex.exchange"
+        self.userid = None
+        self.eth_address = None
+        self.l2key = None
+
+        api = self.client._session.__dict__['_apis'].get("edgex")  # type: ignore
+        if api:
+            self.l2key = api[2].split("-")[1]
 
     async def __aenter__(self) -> "Edgex":
         # 初始化基础合约元数据，便于后续使用 tickSize 等字段。
         await self.update_detail()
+        await self.sync_user()
         return self
+    
+    async def sync_user(self) -> dict[str, Any]:
+        # https://pro.edgex.exchange/api/v1/private/user/getUserInfo
+        # https://pro.edgex.exchange/api/v1/private/account/getAccountPage?size=100
+        # url = self._resolve_api_path("/api/v1/private/user/getUserInfo")
+        # url = self._resolve_api_path("/api/v1/private/account/getAccountPage")
+   
+        res = await self.client.get(f'{self.api_url}/api/v1/private/account/getAccountPage?size=100')
+        
+        data = await res.json()
+      
+        # 重新取 userId ethAddress accountId
+        data = data.get("data", {})
+        accounts = data.get("dataList", [])
+        if accounts:
+            account = accounts[0]
+            self.userid = account.get("userId")
+            self.eth_address = account.get("ethAddress")
+            self.accountid = account.get("id")
+        else:
+            raise ValueError("No account data found in response")
+    
+    async def sub_personal(self) -> None:
+        """订阅用户相关的私有频道（需要登录）。"""
+        await self.client.ws_connect(
+            f"{self.ws_url}/api/v1/private/ws?accountId={self.accountid}&timestamp=" + str(int(time.time() * 1000)),
+            hdlr_json=self.store.onmessage,
+        )
 
     async def __aexit__(
         self,
@@ -53,20 +120,46 @@ class Edgex:
     async def update_detail(self) -> dict[str, Any]:
         """Fetch and cache contract metadata via the public REST endpoint."""
 
-        url = self._resolve_api_path("/api/v1/public/meta/getMetaData")
-        res = await self.client.get(url)
-        res.raise_for_status()
-        data = await res.json()
+        await self.store.initialize(
+            self.client.get(f'{self.api_url}/api/v1/public/meta/getMetaData'),
+        )
 
-        if data.get("code") != "SUCCESS":  # pragma: no cover - defensive guard
-            raise RuntimeError(f"Failed to fetch Edgex metadata: {data}")
+    async def update(
+        self,
+        update_type: Literal["balance", "position", "orders", "all"] = "all",
+    ):
+        """使用 REST 刷新本地缓存的账户资产、持仓及活动订单。"""
+
+        if not getattr(self, "accountid", None):
+            raise ValueError("accountid not set; call sync_user() before update().")
+
+        account_asset_url = (
+            f"{self.api_url}/api/v1/private/account/getAccountAsset"
+            f"?accountId={self.accountid}"
+        )
+        active_orders_url = (
+            f"{self.api_url}/api/v1/private/order/getActiveOrderPage"
+            f"?accountId={self.accountid}&size=200"
+        )
+
+        all_urls = [account_asset_url, active_orders_url]
+
+        url_map = {
+            "balance": [account_asset_url],
+            "position": [account_asset_url],
+            "orders": [active_orders_url],
+            "all": all_urls,
+        }
+
+        try:
+            urls = url_map[update_type]
+        except KeyError:
+            raise ValueError(f"update_type err: {update_type}")
+
+        # 直接传协程进去，initialize 会自己 await
+        await self.store.initialize(*(self.client.get(url) for url in urls))
 
-        self.store._apply_metadata(data)
-        return data
 
-    def _resolve_api_path(self, path: str) -> str:
-        base = (self.api_url or "").rstrip("/")
-        return f"{base}{path}"
 
     async def sub_orderbook(
         self,
@@ -172,6 +265,218 @@ class Edgex:
         wsapp = self.client.ws_connect(url, send_json=payload, hdlr_json=self.store.onmessage)
         await wsapp._event.wait()
 
+    def _fmt_price(self, symbol: str, price: float) -> str:
+        o = self.store.detail.get({"contractName": symbol})
+        if not o:
+            raise ValueError(f"Unknown Edgex symbol: {symbol}")
+        tick = float(o.get("tickSize"))
+        return fmt_value(price, float(tick))
+    
+    def _fmt_size(self, symbol: str, size: float) -> str:
+        o = self.store.detail.get({"contractName": symbol})
+        if not o:
+            raise ValueError(f"Unknown Edgex symbol: {symbol}")
+        step = float(o.get("stepSize"))
+        return fmt_value(size, float(step))
+    
+
+    async def place_order(
+        self,
+        symbol: str,
+        side: Literal["buy", "sell"],
+        price: float = None,
+        quantity: float = None,
+        order_type: Literal["market", "limit_ioc", "limit_gtc"] = "limit_ioc",
+        usdt_amount: float = None,
+    ):  
+        """下单接口（私有 REST）。
+        返回值order_id: str
+        """
+        
+        # 前端请求模板
+        args = {
+            "price": "210.00",
+            "size": "1.0",
+            "type": "LIMIT",
+            "timeInForce": "GOOD_TIL_CANCEL",
+            "reduceOnly": False,
+            "isPositionTpsl": False,
+            "isSetOpenTp": False,
+            "isSetOpenSl": False,
+            "accountId": "663528067938910372",
+            "contractId": "10000003",
+            "side": "BUY",
+            "triggerPrice": "",
+            "triggerPriceType": "LAST_PRICE",
+            "clientOrderId": "39299826149407513",
+            "expireTime": "1760352231536",
+            "l2Nonce": "1872301",
+            "l2Value": "210",
+            "l2Size": "1.0",
+            "l2LimitFee": "1",
+            "l2ExpireTime": "1761129831536",
+            "l2Signature": "03c4d84c30586b12ab9fec939a875201e58dac9a0391f15eb6118ab2fb50464804ce38b19cc5e07c973fc66b449bec0274058ea2d012c1c7a580f805d2c7a1d3",
+            "extraType": "",
+            "extraDataJson": "",
+            "symbol": "SOLUSD",
+            "showEqualValInput": False,
+            "maxSellQTY": 1, # 不需要特别计算, 服务器不校验
+            "maxBuyQTY": 1 # 不需要特别计算, 服务器不校验
+        }
+
+        try:
+            size = Decimal(self._fmt_size(symbol, quantity))
+            price = Decimal(self._fmt_price(symbol, price))
+        except (ValueError, TypeError):
+            raise ValueError("failed to parse size or price")
+        
+        if 'gtc' in order_type:
+            args['timeInForce'] = "GOOD_TIL_CANCEL"
+        if 'ioc' in order_type:
+            args['timeInForce'] = "IMMEDIATE_OR_CANCEL"
+        if 'limit' in order_type:
+            args['type'] = "LIMIT"
+        if 'market' in order_type:
+            args['type'] = "MARKET"
+  
+            if side == 'buy':
+                price = price * 10
+            else:
+                tick_size = self.store.detail.get({'contractName': symbol}).get("tickSize")
+                price = Decimal(tick_size)
+
+        if not self.l2key or not self.userid:
+            raise ValueError("L2 key or userId is not set. Ensure API keys are correctly configured.")
+
+
+        collateral_coin = self.store.app.get({'appName': 'edgeX'})
+
+        c = self.store.detail.get({'contractName': symbol})
+        if not c:
+            raise ValueError(f"Unknown Edgex symbol: {symbol}")
+        hex_resolution = c.get("starkExResolution", "0x0")
+        hex_resolution = hex_resolution.replace("0x", "")
+
+        try:
+            resolution_int = int(hex_resolution, 16)
+            resolution = Decimal(resolution_int)
+        except (ValueError, TypeError):
+            raise ValueError("failed to parse hex resolution")
+        
+        client_order_id = gen_client_id()
+
+        # Calculate values
+        value_dm:Decimal = price * size
+        
+        amount_synthetic = int(size * resolution)
+        amount_collateral = int(value_dm * Decimal("1000000"))  # Shift 6 decimal places
+        
+        
+        # Calculate fee based on order type (maker/taker)
+        try:
+            fee_rate = Decimal(c.get("defaultTakerFeeRate", "0"))
+        except (ValueError, TypeError):
+            raise ValueError("failed to parse fee rate")
+
+        # Calculate fee amount in decimal with ceiling to integer
+        amount_fee_dm = Decimal(str(math.ceil(float(value_dm * fee_rate))))
+        amount_fee_str = str(amount_fee_dm)
+
+        # Convert to the required integer format for the protocol
+        amount_fee = int(amount_fee_dm * Decimal("1000000"))  # Shift 6 decimal places
+
+        nonce = calc_nonce(client_order_id)
+        now = int(time.time() * 1000)
+        l2_expire_time = int(now + 2592e6)  # 30 天后
+        expireTime = int(l2_expire_time - 7776e5)  # 提前 9 天
+
+
+        # Calculate signature using asset IDs from metadata
+        expire_time_unix = int(l2_expire_time // (60 * 60 * 1000))
+
+        asset_id_synthetic = c.get("starkExSyntheticAssetId")
+
+        act_id = self.accountid
+
+        message = LimitOrderMessage(
+            asset_id_synthetic=asset_id_synthetic, # SOLUSD
+            asset_id_collateral=collateral_coin.get("starkExCollateralStarkExAssetId"), # USDT
+            asset_id_fee=collateral_coin.get("starkExCollateralStarkExAssetId"),
+            is_buy= side=='buy',  # isBuyingSynthetic
+            amount_synthetic=amount_synthetic,      # quantumsAmountSynthetic
+            amount_collateral=amount_collateral,     # quantumsAmountCollateral
+            amount_fee=amount_fee,              # quantumsAmountFee
+            nonce=int(nonce),                # nonce
+            position_id=int(act_id),  # positionId
+            expiration_epoch_hours=int(expire_time_unix),   # 此处也比较重要 # TODO: 计算
+        )
+
+        # 取 L2 私钥
+
+
+        signer = LimitOrderSigner(self.l2key)
+        hash_hex, signature_hex = signer.sign(message)
+        value_str = bignumber_to_string(value_dm)
+        
+        price_str = str(price) if 'limit' in order_type else "0"
+
+        args.update({
+            'price': price_str,
+            'size': str(float(size)),
+            'side': side.upper(),
+            'accountId': str(act_id),
+            'contractId': str(c.get("contractId")),
+            'clientOrderId': client_order_id,
+            'expireTime': str(expireTime),
+            'l2ExpireTime': str(l2_expire_time),
+            'l2Nonce': str(nonce),
+            'l2Value': value_str,
+            'l2Size': str(float(size)),
+            'l2LimitFee': amount_fee_str,
+            'l2Signature': signature_hex,
+            'symbol': symbol
+        })
+
+
+
+        res = await self.client.post(
+            f'{self.api_url}/api/v1/private/order/createOrder',
+            data=args
+        )
+
+        data:dict = await res.json()
+        if data.get("code") != "SUCCESS":  # pragma: no cover - defensive guard
+            raise RuntimeError(f"Failed to place Edgex order: {data}")
+
+        # latency = int(data.get("responseTime",0)) - int(data.get("requestTime",0))
+
+        order_id = data.get("data", {}).get("orderId")
+        return order_id
+    
+    async def cancel_orders(self, order_ids: list[str]) -> dict[str, Any]:
+        """
+        批量撤单接口（私有 REST）。
+        
+        .. code:: json
+            {
+                "665186247567737508": "SUCCESS"
+            }
+        """
+
+        args = {
+            "orderIdList": order_ids,
+            "accountId": str(self.accountid),
+        }
+        res = await self.client.post(
+            f'{self.api_url}/api/v1/private/order/cancelOrderById',
+            data=args
+        )
+        data: dict = await res.json()
+        print(data)
+        if data.get("code") != "SUCCESS":  # pragma: no cover - defensive guard
+            raise RuntimeError(f"Failed to cancel Edgex orders: {data}")
+        return data.get("data", {}).get("cancelResultMap", {})
+
 
     async def __aexit__(
         self,
@@ -180,4 +485,4 @@ class Edgex:
         tb: BaseException | None,
     ) -> None:
         # Edgex 当前没有需要关闭的资源；保持接口与 Ourbit 等类一致。
-        return None
+        return None

hyperquant/broker/lbank.py

@@ -102,4 +102,9 @@ class Lbank:
             self.store.register_book_channel(str(y), symbol)
             y += 1
 
-        await asyncio.gather(*(sub(send_json) for send_json in send_jsons))
+        # Rate limit: max 5 subscriptions per second
+        for i in range(0, len(send_jsons), 5):
+            batch = send_jsons[i:i+5]
+            await asyncio.gather(*(sub(send_json) for send_json in batch))
+            if i + 5 < len(send_jsons):
+                await asyncio.sleep(0.1)