hyperquant 0.26__py3-none-any.whl → 0.31__py3-none-any.whl

hyperquant/__init__.py

@@ -3,4 +3,6 @@ from .draw import *
 from .logkit import *
 from .datavison import *
 from .notikit import *
-__version__ = "0.1.0"
+__version__ = "0.1.0"
+
+from .broker import auth, ws

hyperquant/broker/auth.py

@@ -0,0 +1,51 @@
+import time
+import hashlib
+from typing import Any
+from multidict import CIMultiDict
+from yarl import URL
+import pybotters
+import json as pyjson
+from urllib.parse import urlencode
+
+
+def md5_hex(s: str) -> str:
+    return hashlib.md5(s.encode("utf-8")).hexdigest()
+
+
+# 🔑 Ourbit 的鉴权函数
+class Auth:
+    @staticmethod
+    def ourbit(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 里取 token
+        session = kwargs["session"]
+        token = session.__dict__["_apis"][pybotters.auth.Hosts.items[url.host].name][0]
+
+        # 时间戳 & body
+        now_ms = int(time.time() * 1000)
+        raw_body_for_sign = data if isinstance(data, str) else pyjson.dumps(data, separators=(",", ":"), ensure_ascii=False)
+
+        # 签名
+        mid_hash = md5_hex(f"{token}{now_ms}")[7:]
+        final_hash = md5_hex(f"{now_ms}{raw_body_for_sign}{mid_hash}")
+
+        # 设置 headers
+        headers.update({
+            "Authorization": token,
+            "Language": "Chinese",
+            "language": "Chinese",
+            "Content-Type": "application/json",
+            "x-ourbit-sign": final_hash,
+            "x-ourbit-nonce": str(now_ms),
+        })
+
+        # 更新 kwargs.body，保证发出去的与签名一致
+        kwargs.update({"data": raw_body_for_sign})
+
+        return args
+
+pybotters.auth.Hosts.items['futures.ourbit.com'] = pybotters.auth.Item("ourbit", Auth.ourbit)

hyperquant/broker/hyperliquid.py

@@ -26,10 +26,34 @@ from typing import Any, Dict, Optional
 import pybotters
 from yarl import URL
 
-from .lib.hpstore import MyHyperStore
-from .lib.hyper_types import AccountBalance
+from .models.hyperliquid import MyHyperStore
 
-import uuid
+def to_cloid(s: str) -> str:
+    """
+    可逆地将字符串转为 Hyperliquid cloid 格式（要求字符串最多16字节，超出报错）。
+    :param s: 原始字符串
+    :return: 形如0x...的cloid字符串
+    """
+    b = s.encode('utf-8')
+    if len(b) > 16:
+        raise ValueError("String too long for reversible cloid (max 16 bytes)")
+    # 补齐到16字节
+    b = b.ljust(16, b'\0')
+    return "0x" + b.hex()
+
+def cloid_to_str(cloid: str) -> str:
+    """
+    从cloid还原回原始字符串
+    :param cloid: 形如0x...的cloid字符串
+    :return: 原始字符串
+    """
+    try:
+        if not (cloid.startswith("0x") and len(cloid) == 34):
+            raise ValueError("Invalid cloid format for reversal")
+        b = bytes.fromhex(cloid[2:])
+        return b.rstrip(b'\0').decode('utf-8')
+    except Exception as e:
+        return ''
 
 
 __all__ = [
@@ -56,6 +80,7 @@ class AssetMeta:
     asset_id: int
     name: str
     sz_decimals: int
+    tick_size: float = None
 
 @dataclass(frozen=True, slots=True)
 class SpotAssetMeta:
@@ -80,31 +105,27 @@ class OrderData():
 
 _DECIMAL_CTX_5 = decimal.Context(prec=5)
 
+def normalize_number(n):
+    # 能去掉小数点后多余的零
+    return format(decimal.Decimal(str(n)).normalize(), "f")
 
-def _normalize_number(number: str) -> str:
-    """Normalize a number.
-
-    e.g. "3300.0" -> "3300"
-
-    Hyperliquid API expects normalized numbers. Otherwise, `L1 error` will occur.
+def _fmt_price(price: float, sz_decimals: int, *, max_decimals: int = 6) -> float:
     """
-    return format(decimal.Decimal(number).normalize(), "f")
-
-def _fmt_price(price: float, sz_decimals: int, *, max_decimals: int = 6) -> str:
-    """Format *price* according to Hyperliquid rules.
-
-    * For `price >= 1` keep five significant digits.
-    * For small prices keep *max_decimals - sz_decimals* after the dot.
+    格式化价格：
+      - 大于100000直接取整数
+      - 其它情况保留5个有效数字，然后再按max_decimals-sz_decimals截断小数位
     """
-    if price >= 1:
-        return format(_DECIMAL_CTX_5.create_decimal(price).normalize(), "f")
+    if price > 100_000:
+        return str(round(price))
+    # 先保留5个有效数字，再截断小数位
+    price_5sf = float(f"{price:.5g}")
+    return normalize_number(round(price_5sf, max_decimals - sz_decimals))
 
-    decimal_places = max_decimals - sz_decimals
-    return _normalize_number(format(decimal.Decimal(price).quantize(decimal.Decimal(f"1e-{decimal_places}")), "f"))
-
-
-def _fmt_size(size: float, sz_decimals: int) -> str:
-    return _normalize_number(format(decimal.Decimal(size).quantize(decimal.Decimal(f"1e-{sz_decimals}")), "f"))
+def _fmt_size(sz: float, sz_decimals: int) -> float:
+    """
+    格式化数量：直接按 sz_decimals 小数位截断
+    """
+    return normalize_number(round(sz, sz_decimals))
 
 
 # ╭─────────────────────────────────────────────────────────────────────────╮
@@ -144,6 +165,7 @@ class HyperliquidTrader:
 
         self._ws_app: Optional[pybotters.ws.WebSocketConnection] = None
         self.store: MyHyperStore = MyHyperStore()
+        
 
 
     # ──────────────────────────────────────────────────────────────────────
@@ -165,6 +187,7 @@ class HyperliquidTrader:
         if self._user:
             await self.store.initialize(
                 ("orders", self._client.post(_INFO, data={"type": "openOrders", "user": self._user})),
+                ("positions", self._client.post(_INFO, data={"type": "clearinghouseState", "user": self._user})),
             )
             self._client.ws_connect(
                 self._wss_url,
@@ -198,6 +221,12 @@ class HyperliquidTrader:
     async def __aexit__(self, exc_type, exc, tb):  # noqa: D401
         if not self._external_client and self._client is not None:
             await self._client.__aexit__(exc_type, exc, tb)
+    
+    async def sync_orders(self):
+        await self.store.orders._clear()
+        await self.store.initialize(
+            ("orders", self._client.post(_INFO, data={"type": "openOrders", "user": self._user})),
+        )
 
     # ──────────────────────────────────────────────────────────────────────
     # Internal – metadata & formatting helpers
@@ -209,7 +238,7 @@ class HyperliquidTrader:
             raise RuntimeError(f"Failed to fetch meta: {resp.error}")
 
         self._assets = {
-            d["name"]: AssetMeta(asset_id=i, name=d["name"], sz_decimals=d["szDecimals"])
+            d["name"]: AssetMeta(asset_id=i, name=d["name"], sz_decimals=d["szDecimals"], tick_size=10**(d["szDecimals"] - 6))
             for i, d in enumerate(resp.data["universe"])
         }
 
@@ -313,7 +342,7 @@ class HyperliquidTrader:
     # ──────────────────────────────────────────────────────────────────────
     # Public API – account
     # ──────────────────────────────────────────────────────────────────────
-    async def balances(self, user: Optional[str] = None) -> AccountBalance | None:  # todo support spot
+    async def balances(self, user: Optional[str] = None):  # todo support spot
         try:
             user = user or self._user
             if user is None:
@@ -437,6 +466,8 @@ class HyperliquidTrader:
         price: Optional[float] = None,  # required for limit orders
         use_ws: bool = False,
         is_spot: bool = False,
+        reduce_only: bool = False,  # whether to place a reduce‑only order
+        cloid: Optional[str] = None, 
     ) -> OrderData:
         """`place_order` 下订单
 
@@ -462,6 +493,7 @@ class HyperliquidTrader:
             tif = "Ioc"
 
         size_str = _fmt_size(size, meta.sz_decimals)
+        # print(f'下单 @ size_str: {size_str}, price_str: {price_str}, asset: {asset}, is_spot: {is_spot}')
         order_payload = {
             "action": {
                 "type": "order",
@@ -471,26 +503,26 @@ class HyperliquidTrader:
                         "b": is_buy,
                         "p": price_str,
                         "s": size_str,
-                        "r": False,
+                        "r": reduce_only,
                         "t": {"limit": {"tif": tif}},
                     }
                 ],
                 "grouping": "na",
             }
         }
-        # 创建时间戳cid
-        # Generate a 128-bit client order ID as a hex string (0x-prefixed, 32 hex chars)
-        cloid = uuid.uuid4().hex
-        cloid = "0x" + cloid
-        
-        order_payload["action"]["orders"][0]["c"] = cloid
+        if cloid is not None:
+            if not cloid.startswith("0x"):
+                cloid = to_cloid(cloid)
+            
+            order_payload["action"]["orders"][0]["c"] = cloid
 
         # print(f"Placing order: {order_payload}")
-        print(order_payload)
+        # print(order_payload)
 
         if not use_ws:
             ret = await self._post(_EXCHANGE, order_payload)
-            if 'error' in str(ret):
+            print(ret)
+            if 'error' in str(ret) or 'err' in str(ret):
                 raise RuntimeError(f"Failed to place order: {ret}")
             elif 'filled' in str(ret):
                 return OrderData(

hyperquant/broker/models/hyperliquid.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import time
+from aiohttp import ClientWebSocketResponse
+import aiohttp
+
+def callback(msg, ws: ClientWebSocketResponse = None):
+    print("Received message:", msg)
+
+
+import asyncio
+import pybotters
+from pybotters.store import DataStore, DataStoreCollection
+from pybotters.models.hyperliquid import HyperliquidDataStore
+from typing import TYPE_CHECKING, Awaitable
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+    from pybotters.ws import ClientWebSocketResponse
+
+
+
+# {'channel': 'orderUpdates', 'data': [{'order': {'coin': 'HYPE', 'side': 'A', 'limitPx': '22.887', 'sz': '1.12', 'oid': 29641480516, 'timestamp': 1746766108031, 'origSz': '1.12', 'reduceOnly': True}, 'status': 'rejected', 'statusTimestamp': 1746766108031}]}
+class OrderStore(DataStore):
+    _KEYS = ["oid"]
+
+    def _onmessage(self, msg: Item) -> None:
+
+        for rec in msg:
+            order = rec["order"]
+            item = {
+                **order,
+                "status": rec.get("status"),
+                "px": None,
+                'fee': None,
+                "statusTimestamp": rec.get("statusTimestamp"),
+            }
+
+            if item["status"] == "open":
+                self._update([item])
+            else:
+                self._delete([item])
+
+class FillStore(DataStore):
+    _KEYS = ["oid"]
+
+    def _onmessage(self, msg: Item) -> None:
+        for fill in msg:
+            self._update([fill])
+
+
+
+class Account(DataStore):
+    _KEYS = ["marginCoin", "value"]
+     
+    def _onmessage(self, data: list[Item]) -> None:
+            self._update(
+                [
+                    {
+                        "marginCoin": 'USDC',
+                        'value': float(item['accountValue']),
+                        'frozen': float(item['totalMarginUsed']),
+                        'available': float(item['accountValue']) - float(item['totalMarginUsed']),
+                    }
+                    for item in data
+                ]
+            )
+
+class SpotAccount(DataStore):
+
+    _KEYS = ["coin"]
+
+    def _onmessage(self, data: list[Item]) -> None:
+        self._update(
+            [
+                {
+                    "coin": item['coin'],
+                    "total": float(item['total']),
+                    "frozen": float(item['hold']),
+                    "available": float(item['total']) - float(item['hold']),
+                    "entryNtl": float(item['entryNtl']),
+                }
+                for item in data
+            ]
+        )
+
+class PositionStore(DataStore):
+    _KEYS = ["coin"]
+
+    def _onmessage(self, data: list[Item]) -> None:
+      
+        self._clear()
+        self._update([
+
+            {
+                "coin": item['position']['coin'],
+                "sz": float(item['position']['szi']),
+                "px": float(item['position']['entryPx']),
+                'unpnl': float(item['position']['unrealizedPnl']),
+                'rt': float(item['position']['returnOnEquity']),
+                'lv': int(item['position']['leverage']['value']),
+                'update_time': int(time.time() * 1000)
+            }
+            for item in data
+        ])
+
+
+        
+class MyHyperStore(HyperliquidDataStore):
+    ORDER_TYPE = 'orderUpdates'
+    WEBDATA2_TYPE = 'webData2'
+    ORDER_FILL_TYPE = 'userFills'
+
+    def _init(self) -> None:
+        self._create("orders", datastore_class=OrderStore)
+        self._create("account", datastore_class=Account)
+        self._create("positions", datastore_class=PositionStore)
+        self._create("spot_account", datastore_class=SpotAccount)
+        self._create("fills", datastore_class=FillStore)
+        super()._init()
+
+    def _onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+
+        if msg.get("channel") == self.ORDER_TYPE:
+            self.orders._onmessage(msg.get('data', []))
+        elif msg.get("channel") == self.WEBDATA2_TYPE:
+            # print(msg.get('data', {}).get('clearinghouseState', {}))
+            act_data = msg.get('data', {}).get('clearinghouseState', {}).get('crossMarginSummary', [])
+            if act_data:
+                self.account._onmessage([act_data])
+
+            pos_data = msg.get('data', {}).get('clearinghouseState', {}).get('assetPositions', [])
+            self.positions._onmessage(pos_data)
+
+            spot_act_data = msg.get('data', {}).get('spotState', {}).get('balances', [])
+            self.spot_account._onmessage(spot_act_data)
+
+        elif msg.get("channel") == self.ORDER_FILL_TYPE:
+            fills = msg.get('data', {}).get('fills', [])
+            is_snap = msg.get('data', {}).get('isSnapshot', False)
+            if not is_snap:
+                self.fills._onmessage(fills)
+  
+        super()._onmessage(msg, ws)
+
+            
+    async def initialize(self, *aws: tuple[str, Awaitable[aiohttp.ClientResponse]]) -> None:
+        for a in aws:
+            method, f = a
+            resp = await f
+            data = await resp.json()
+            
+            if method == "orders":
+                self.orders._onmessage(
+                    [
+                        {
+                            'order': o,
+                            'status': "open",
+                            'statusTimestamp': int(time.time() * 1000)
+                        } for o in data
+                    ]
+                )
+            elif method == "positions":
+                # 处理持仓数据初始化
+                pos_data = data.get('assetPositions', [])
+                if pos_data:
+                    self.positions._onmessage(pos_data)
+                
+                # 处理账户数据初始化
+                # act_data = data.get('crossMarginSummary', {})
+                # if act_data:
+                #     self.account._onmessage([act_data])
+        pass
+
+    @property
+    def orders(self) -> OrderStore:
+        """``orders`` data stream.
+
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+
+        Data structure:
+
+        .. code:: python
+            [
+                {
+                    "coin": "HYPE",
+                    "side": "A",
+                    "limitPx": "22.887",
+                    "sz": "1.12",
+                    "oid": 29641480516,
+                    "timestamp": 1746766108031,
+                    "origSz": "1.12",
+                    "reduceOnly": True
+                    "status": "open",
+                    "statusTimestamp": 1746766108031
+                }...
+            ]
+        """
+        return self._get("orders", OrderStore)
+    @property
+    def account(self) -> Account:
+        """``account`` data stream.
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+        Data structure:
+        .. code:: python
+            [
+                {
+                    "marginCoin": 'USDC',
+                    'value': float(item['accountValue']),
+                    'frozen': float(item['totalMarginUsed']),
+                    'available': float(item['accountValue']) - float(item['totalMarginUsed']),
+                }...
+            ]
+        """
+        return self._get("account", Account)
+    
+    @property
+    def positions(self) -> PositionStore:
+        """
+        获取当前的持仓信息。
+        Data structure:
+        .. code:: python
+            [
+                {                    
+                    "coin": item['position']['coin'],
+                    "sz": float(item['position']['szi']),
+                    "px": float(item['position']['entryPx']),
+                    'unpnl': float(item['position']['unrealizedPnl']),
+                    'rt': float(item['position']['returnOnEquity']),
+                    'lv': int(item['position']['leverage']['value']),
+                    'update_time': int(time.time() * 1000)
+                }...
+            ]
+        """
+
+        return self._get("positions", PositionStore)
+    
+    @property
+    def spot_account(self) -> SpotAccount:
+        """``spot_account`` data stream.
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+        Data structure:
+        .. code:: python
+            [
+                {
+                    "coin": 'FEUSD',
+                    "sz": "21.0",
+                    "px": "0.9719",
+                    "unpnl": "0.0",
+                    "rt": "0.0",
+                    "lv": 1,
+                }...
+            ]
+        """
+        return self._get("spot_account", SpotAccount)
+   
+    @property
+    def fills(self) -> FillStore:
+        """``fills`` data stream.
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+        Data structure:
+        .. code:: python
+            [
+                {
+                    "coin": 'FEUSD',
+                    "px": "0.9719",
+                    "sz": "21.0",
+                    "side": 'buy',
+                    "time": 1679999999999,
+                    "startPosition": '0.0',
+                    "dir": 'buy',
+                    "closedPnl": '0.0',
+                    "hash": '0x123456789abcdef',
+                    "oid": 123456789,
+                    "crossed": True,
+                    "fee": '-0.0001',
+                    "tid": 987654321,
+                    "liquidation": None,
+                    "feeToken": 'USDC',
+                }...
+            ]
+        """
+        return self._get("fills", FillStore)
+

hyperquant/broker/models/ourbit.py

@@ -0,0 +1,502 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any, Awaitable
+
+import aiohttp
+from pybotters.store import DataStore, DataStoreCollection
+
+if TYPE_CHECKING:
+    from pybotters.typedefs import Item
+    from pybotters.ws import ClientWebSocketResponse
+
+
+logger = logging.getLogger(__name__)
+
+
+class Book(DataStore):
+    """深度数据存储类，用于处理订单簿深度信息
+
+    Channel: push.depth.step
+
+    用于存储和管理订单簿深度数据，包含买卖盘的价格和数量信息
+    Keys: ["symbol", "side", "px"]
+    - symbol: 交易对符号
+    - side: 买卖方向 (A: ask卖出, B: bid买入)
+    - px: 价格
+
+
+    """
+
+    _KEYS = ["symbol", "side", "px"]
+
+    def _init(self) -> None:
+        # super().__init__()
+        self._time: int | None = None
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+
+        symbol = msg.get("symbol")
+        data = msg.get("data", {})
+        asks = data.get("asks", [])
+        bids = data.get("bids", [])
+        timestamp = data.get("ct")  # 使用服务器时间
+
+        data_to_insert: list[Item] = []
+
+        # 先删除旧的订单簿数据
+        self._find_and_delete({"symbol": symbol})
+
+        # 处理买卖盘数据
+        for side_id, levels in (("B", bids), ("A", asks)):
+            for level in levels:
+                # level格式: [price, size, count]
+                if len(level) >= 3:
+                    price, size, count = level[0:3]
+                    data_to_insert.append(
+                        {
+                            "symbol": symbol,
+                            "side": side_id,
+                            "px": str(price),
+                            "sz": str(size),
+                            "count": count,
+                        }
+                    )
+
+        # 插入新的订单簿数据
+        self._insert(data_to_insert)
+        self._time = timestamp
+
+    @property
+    def time(self) -> int | None:
+        """返回最后更新时间"""
+        return self._time
+
+    @property
+    def sorted(self) -> dict[str, list[Item]]:
+        """获取排序后的订单簿数据
+
+        Returns:
+            返回按价格排序的买卖盘数据，卖盘升序，买盘降序
+
+        .. code-block:: python
+
+            {
+                "asks": [
+                    {"symbol": "BTC_USDT", "side": "A", "px": "110152.5", "sz": "53539", "count": 1},
+                    {"symbol": "BTC_USDT", "side": "A", "px": "110152.6", "sz": "95513", "count": 2}
+                ],
+                "bids": [
+                    {"symbol": "BTC_USDT", "side": "B", "px": "110152.4", "sz": "76311", "count": 1},
+                    {"symbol": "BTC_USDT", "side": "B", "px": "110152.3", "sz": "104688", "count": 2}
+                ]
+            }
+        """
+        return self._sorted(
+            item_key="side",
+            item_asc_key="A",  # asks 升序
+            item_desc_key="B",  # bids 降序
+            sort_key="px",
+        )
+
+
+class Ticker(DataStore):
+    _KEYS = ["symbol"]
+
+    def _on_message(self, data: dict[str, Any]):
+        self._onresponse(data)
+
+    def _onresponse(self, data: dict[str, Any]):
+        tickers = data.get("data", [])
+        if tickers:
+            data_to_insert: list[Item] = []
+            for ticker in tickers:
+                ticker: dict[str, Any] = ticker
+                for ticker in tickers:
+                    data_to_insert.append(
+                        {
+                            "amount24": ticker.get("amount24"),
+                            "fair_price": ticker.get("fairPrice"),
+                            "high24_price": ticker.get("high24Price"),
+                            "index_price": ticker.get("indexPrice"),
+                            "last_price": ticker.get("lastPrice"),
+                            "lower24_price": ticker.get("lower24Price"),
+                            "max_bid_price": ticker.get("maxBidPrice"),
+                            "min_ask_price": ticker.get("minAskPrice"),
+                            "rise_fall_rate": ticker.get("riseFallRate"),
+                            "symbol": ticker.get("symbol"),
+                            "timestamp": ticker.get("timestamp"),
+                            "volume24": ticker.get("volume24"),
+                        }
+                    )
+            # self._clear()
+            self._insert(data_to_insert)
+
+
+class Orders(DataStore):
+    _KEYS = ["order_id"]
+
+    # {'success': True, 'code': 0, 'data': [{'orderId': '219108574599630976', 'symbol': 'SOL_USDT', 'positionId': 0, 'price': 190, 'priceStr': '190', 'vol': 1, 'leverage': 20, 'side': 1, 'category': 1, 'orderType': 1, 'dealAvgPrice': 0, 'dealAvgPriceStr': '0', 'dealVol': 0, 'orderMargin': 0.09652, 'takerFee': 0, 'makerFee': 0, 'profit': 0, 'feeCurrency': 'USDT', 'openType': 1, 'state': 2, 'externalOid': '_m_2228b23a75204e1982b301e44d439cbb', 'errorCode': 0, 'usedMargin': 0, 'createTime': 1756277955008, 'updateTime': 1756277955037, 'positionMode': 1, 'version': 1, 'showCancelReason': 0, 'showProfitRateShare': 0, 'voucher': False}]}
+    def _onresponse(self, data: dict[str, Any]):
+        orders = data.get("data", [])
+        if orders:
+            data_to_insert: list[Item] = []
+            for order in orders:
+                order: dict[str, Any] = order
+
+                data_to_insert.append(
+                    {
+                        "order_id": order.get("orderId"),
+                        "symbol": order.get("symbol"),
+                        "px": order.get("priceStr"),
+                        "vol": order.get("vol"),
+                        "lev": order.get("leverage"),
+                        "side": "buy" if order.get("side") == 1 else "sell",
+                        "deal_vol": order.get("dealVol"),
+                        "deal_avg_px": order.get("dealAvgPriceStr"),
+                        "create_ts": order.get("createTime"),
+                        "update_ts": order.get("updateTime"),
+                    }
+                )
+
+            self._clear()
+            self._update(data_to_insert)
+
+
+class Detail(DataStore):
+    _KEYS = ["symbol"]
+
+    def _on_message(self, data: dict[str, Any]):
+        self._onresponse(data)
+
+    def _onresponse(self, data: dict[str, Any]):
+        details: dict = data.get("data", {})
+        data_to_insert: list[Item] = []
+        if details:
+            for detail in details:
+                data_to_insert.append(
+                    {
+                        "symbol": detail.get("symbol"),
+                        "ft": detail.get("ft"),
+                        "max_lev": detail.get("maxL"),
+                        "tick_size": detail.get("pu"),
+                        "vol_unit": detail.get("vu"),
+                        "io": detail.get("io"),
+                        "contract_sz": detail.get("cs"),
+                        "minv": detail.get("minV"),
+                        "maxv": detail.get("maxV")
+                    }
+                )
+        self._update(data_to_insert)
+
+class Position(DataStore):
+    _KEYS = ["position_id"]
+    # {"success":true,"code":0,"data":[{"positionId":5355366,"symbol":"SOL_USDT","positionType":1,"openType":1,"state":1,"holdVol":1,"frozenVol":0,"closeVol":0,"holdAvgPrice":203.44,"holdAvgPriceFullyScale":"203.44","openAvgPrice":203.44,"openAvgPriceFullyScale":"203.44","closeAvgPrice":0,"liquidatePrice":194.07,"oim":0.10253376,"im":0.10253376,"holdFee":0,"realised":-0.0008,"leverage":20,"marginRatio":0.0998,"createTime":1756275984696,"updateTime":1756275984696,"autoAddIm":false,"version":1,"profitRatio":0,"newOpenAvgPrice":203.44,"newCloseAvgPrice":0,"closeProfitLoss":0,"fee":0.00081376}]}
+    def _onresponse(self, data: dict[str, Any]):
+        positions = data.get("data", [])
+        if positions:
+            data_to_insert: list[Item] = []
+            for position in positions:
+                position: dict[str, Any] = position
+
+                data_to_insert.append(
+                    {
+                        "position_id": position.get("positionId"),
+                        "symbol": position.get("symbol"),
+                        "side": "short" if position.get("positionType") == 2 else "long",
+                        "open_type": position.get("openType"),
+                        "state": position.get("state"),
+                        "hold_vol": position.get("holdVol"),
+                        "frozen_vol": position.get("frozenVol"),
+                        "close_vol": position.get("closeVol"),
+                        "hold_avg_price": position.get("holdAvgPriceFullyScale"),
+                        "open_avg_price": position.get("openAvgPriceFullyScale"),
+                        "close_avg_price": str(position.get("closeAvgPrice")),
+                        "liquidate_price": str(position.get("liquidatePrice")),
+                        "oim": position.get("oim"),
+                        "im": position.get("im"),
+                        "hold_fee": position.get("holdFee"),
+                        "realised": position.get("realised"),
+                        "leverage": position.get("leverage"),
+                        "margin_ratio": position.get("marginRatio"),
+                        "create_ts": position.get("createTime"),
+                        "update_ts": position.get("updateTime"),
+                    }
+                )
+
+            self._clear()
+            self._insert(data_to_insert)
+
+class Balance(DataStore):
+    _KEYS = ["currency"]
+
+    def _onresponse(self, data: dict[str, Any]):
+        balances = data.get("data", [])
+        if balances:
+            data_to_insert: list[Item] = []
+            for balance in balances:
+                balance: dict[str, Any] = balance
+                data_to_insert.append({
+                    "currency": balance.get("currency"),
+                    "position_margin": balance.get("positionMargin"),
+                    "available_balance": balance.get("availableBalance"),
+                    "cash_balance": balance.get("cashBalance"),
+                    "frozen_balance": balance.get("frozenBalance"),
+                    "equity": balance.get("equity"),
+                    "unrealized": balance.get("unrealized"),
+                    "bonus": balance.get("bonus"),
+                    "last_bonus": balance.get("lastBonus"),
+                    "wallet_balance": balance.get("walletBalance"),
+                    "voucher": balance.get("voucher"),
+                    "voucher_using": balance.get("voucherUsing"),
+                })
+            self._clear()
+            self._insert(data_to_insert)
+
+class OurbitSwapDataStore(DataStoreCollection):
+    """
+    Ourbit DataStoreCollection
+
+    REST API:
+      - 地址: https://futures.ourbit.com
+      - 合约详情
+        GET /api/v1/contract/detailV2?client=web
+      - ticker
+        GET /api/v1/contract/ticker
+      - open_orders
+        GET /api/v1/private/order/list/open_orders?page_size=200
+      - open_positions
+        GET /api/v1/private/position/open_positions
+
+    WebSocket API:
+      - 地址: wss://futures.ourbit.com/edge or /ws
+      - 支持频道:
+        * 深度数据（Book）: push.depth.step
+        * 行情数据（Ticker）: push.tickers
+
+    示例订阅 JSON:
+
+    .. code:: json
+
+        {
+            "method": "sub.depth.step",
+            "param": {
+                "symbol": "BTC_USDT",
+                "step": "0.1"
+            }
+        }
+
+    .. code:: json
+
+        {
+            "method": "sub.tickers",
+            "param": {
+                "timezone": "UTC+8"
+            }
+        }
+
+    TODO:
+      - 添加 trades、ticker、candle 等其他数据流
+    """
+
+    def _init(self) -> None:
+        self._create("book", datastore_class=Book)
+        self._create("detail", datastore_class=Detail)
+        self._create("ticker", datastore_class=Ticker)
+        self._create("orders", datastore_class=Orders)
+        self._create("position", datastore_class=Position)
+        self._create("balance", datastore_class=Balance)
+        # TODO: 添加其他数据流，如 trades, ticker, candle 等
+
+    def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+        channel = msg.get("channel")
+
+        if channel == "push.depth.step":
+            self.book._on_message(msg)
+        if channel == "push.tickers":
+            self.ticker._on_message(msg)
+        else:
+            logger.debug(f"未知的channel: {channel}")
+
+    async def initialize(self, *aws: Awaitable[aiohttp.ClientResponse]) -> None:
+        """Initialize DataStore from HTTP response data."""
+        for f in asyncio.as_completed(aws):
+            res = await f
+            data = await res.json()
+            if res.url.path == "/api/v1/contract/detailV2":
+                self.detail._onresponse(data)
+            if res.url.path == "/api/v1/contract/ticker":
+                self.ticker._onresponse(data)
+            if res.url.path == "/api/v1/private/order/list/open_orders":
+                self.orders._onresponse(data)
+            if res.url.path == "/api/v1/private/position/open_positions":
+                self.position._onresponse(data)
+            if res.url.path == "/api/v1/private/account/assets":
+                self.balance._onresponse(data)
+
+    @property
+    def detail(self) -> Detail:
+        """合约详情
+        Data structure:
+        .. code:: python
+        [
+            {
+                "symbol": "BTC_USDT",   # 交易对
+                "ft": 100,            # 合约面值
+                "max_lev": 100,       # 最大杠杆
+                "tick_size": 0.1,     # 最小变动价位
+                "vol_unit": 1,        # 合约单位
+                "io": ["binance", "mexc"],  # 交易所列表
+                "contract_sz": 1,
+                "minv": 1,
+                "maxv": 10000
+
+            }
+        ]
+        """
+        return self._get("detail", Detail)
+
+    @property
+    def book(self) -> Book:
+        """订单簿深度数据流
+
+        Data type: Mutable
+
+        Keys: ("symbol", "side", "px")
+
+        Data structure:
+
+        .. code:: python
+
+            [
+                {
+                    "symbol": "BTC_USDT",    # 交易对
+                    "side": "A",             # 卖出方向
+                    "px": "110152.5",        # 价格
+                    "sz": "53539",           # 数量
+                    "count": 1               # 订单数量
+                },
+                {
+                    "symbol": "BTC_USDT",    # 交易对
+                    "side": "B",             # 买入方向
+                    "px": "110152.4",        # 价格
+                    "sz": "76311",           # 数量
+                    "count": 1               # 订单数量
+                }
+            ]
+        """
+        return self._get("book", Book)
+
+    @property
+    def ticker(self) -> Ticker:
+        """市场行情数据流
+
+        Data type: Mutable
+
+        Keys: ("symbol",)
+
+        Data structure:
+
+        .. code:: python
+
+            [
+                {
+                    "symbol": "BTC_USDT",        # 交易对
+                    "last_price": "110152.5",    # 最新价格
+                    "index_price": "110000.0",   # 指数价格
+                    "fair_price": "110100.0",    # 公允价格
+                    "high24_price": "115000.0",  # 24小时最高价
+                    "lower24_price": "105000.0", # 24小时最低价
+                    "volume24": "1500",          # 24小时交易量
+                    "amount24": "165000000",     # 24小时交易额
+                    "rise_fall_rate": "0.05",    # 涨跌幅
+                    "max_bid_price": "110150.0", # 买一价
+                    "min_ask_price": "110155.0", # 卖一价
+                    "timestamp": 1625247600000   # 时间戳
+                }
+            ]
+        """
+        return self._get("ticker", Ticker)
+
+    @property
+    def orders(self) -> Orders:
+        """
+        订单数据
+        Data structure:
+
+        .. code:: json
+
+            [
+                {
+                    "id": "123456",
+                    "symbol": "BTC_USDT",
+                    "side": "buy",
+                    "price": "110152.5",
+                    "size": "0.1",
+                    "status": "open",
+                    "create_ts": 1625247600000,
+                    "update_ts": 1625247600000
+                }
+            ]
+        """
+        return self._get("orders", Orders)
+
+    @property
+    def position(self) -> Position:
+        """
+        持仓数据
+
+        Data structure:
+        .. code:: python
+        [
+            {
+                "position_id": "123456",
+                "symbol": "BTC_USDT",
+                "side": "long",
+                "open_type": "limit",
+                "state": "open",
+                "hold_vol": "0.1",
+                "frozen_vol": "0.0",
+                "close_vol": "0.0",
+                "hold_avg_price": "110152.5",
+                "open_avg_price": "110152.5",
+                "close_avg_price": "0.0",
+                "liquidate_price": "100000.0",
+                "oim": "0.0",
+                "im": "0.0",
+                "hold_fee": "0.0",
+                "realised": "0.0",
+                "leverage": "10",
+                "margin_ratio": "0.1",
+                "create_ts": 1625247600000,
+                "update_ts": 1625247600000
+            }
+        ]
+        """
+        return self._get("position", Position)
+
+    @property
+    def balance(self) -> Balance:
+        """账户余额数据
+        
+        Data structure:
+        .. code:: python
+            [
+                {
+                    "currency": "USDT",            # 币种
+                    "position_margin": 0.3052,     # 持仓保证金
+                    "available_balance": 19.7284,  # 可用余额
+                    "cash_balance": 19.7284,      # 现金余额
+                    "frozen_balance": 0,          # 冻结余额
+                    "equity": 19.9442,           # 权益
+                    "unrealized": -0.0895,       # 未实现盈亏
+                    "bonus": 0,                  # 奖励
+                    "last_bonus": 0,             # 最后奖励
+                    "wallet_balance": 20.0337,   # 钱包余额
+                    "voucher": 0,               # 代金券
+                    "voucher_using": 0          # 使用中的代金券
+                }
+            ]
+        """
+        return self._get("balance", Balance)

hyperquant/broker/ourbit.py

@@ -0,0 +1,247 @@
+from typing import Literal, Optional
+import pybotters
+from .models.ourbit import OurbitSwapDataStore
+
+
+class OurbitSwap:
+
+    def __init__(self, client: pybotters.Client):
+        """
+        ✅ 完成:
+            下单, 撤单, 查询资金, 查询持有订单, 查询历史订单
+
+        """
+        self.client = client
+        self.store = OurbitSwapDataStore()
+        self.api_url = "https://futures.ourbit.com"
+        self.ws_url = "wss://futures.ourbit.com/edge"
+
+    async def __aenter__(self) -> "OurbitSwap":
+        client = self.client
+        await self.store.initialize(
+            client.get(f"{self.api_url}/api/v1/contract/detailV2?client=web")
+        )
+        return self
+
+    async def update(
+        self, update_type: Literal["position", "orders", "balance", "ticker", "all"] = "all"
+    ):
+        """由于交易所很多不支持ws推送，这里使用Rest"""
+        all_urls = [
+            f"{self.api_url}/api/v1/private/position/open_positions",
+            f"{self.api_url}/api/v1/private/order/list/open_orders?page_size=200",
+            f"{self.api_url}/api/v1/private/account/assets",
+            f"{self.api_url}/api/v1/contract/ticker",
+        ]
+
+        url_map = {
+            "position": [all_urls[0]],
+            "orders": [all_urls[1]],
+            "balance": [all_urls[2]],
+            "ticker": [all_urls[3]],
+            "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))
+
+    async def sub_tickers(self):
+        self.client.ws_connect(
+            self.ws_url,
+            send_json={
+                "method": "sub.tickers",
+                "param": {
+                    "timezone": "UTC+8"
+                }
+            },
+            hdlr_json=self.store.onmessage
+        )
+
+    async def sub_order_book(self, symbols: str | list[str]):
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        send_jsons = []
+        # send_json={"method":"sub.depth.step","param":{"symbol":"BTC_USDT","step":"0.1"}},
+
+        for symbol in symbols:
+            step = self.store.detail.find({"symbol": symbol})[0].get("tick_size")
+            
+            send_jsons.append({
+                "method": "sub.depth.step",
+                "param": {
+                    "symbol": symbol,
+                    "step": str(step)
+                }
+            })
+
+        await self.client.ws_connect(
+            self.ws_url,
+            send_json=send_jsons,
+            hdlr_json=self.store.onmessage
+        )
+
+    def ret_content(self, res: pybotters.FetchResult):
+        match res.data:
+            case {"success": True}:
+                return res.data["data"]
+            case _:
+                raise Exception(f"Failed api {res.response.url}: {res.data}")
+            
+
+    async def place_order(
+        self,
+        symbol: str,
+        side: Literal["buy", "sell", "close_buy", "close_sell"],
+        size: float = None,
+        price: float = None,
+        order_type: Literal["market", "limit_GTC", "limit_IOC"] = "market",
+        usdt_amount: Optional[float] = None,
+        leverage: Optional[int] = 20,
+        position_id: Optional[int] = None,
+    ):
+        """
+        size为合约张数
+
+        .. code ::
+        {
+            "orderId": "219602019841167810",
+            "ts": 1756395601543
+        }
+
+        """
+        if (size is None) == (usdt_amount is None):
+            raise ValueError("params err")
+
+        max_lev = self.store.detail.find({"symbol": symbol})[0].get("max_lev")
+        
+        if usdt_amount is not None:
+            cs = self.store.detail.find({"symbol": symbol})[0].get("contract_sz")
+            size = max(int(usdt_amount / cs / price), 1)
+            
+
+        leverage = max(max_lev, leverage)
+
+        data = {
+            "symbol": symbol,
+            "side": 1 if side == "buy" else 3,
+            "openType": 1,
+            "type": "5",
+            "vol": size,
+            "leverage": leverage,
+            "marketCeiling": False,
+            "priceProtect": "0",
+        }
+
+        if order_type == "limit_IOC":
+            data["type"] = 3
+            data["price"] = str(price)
+        if order_type == "limit_GTC":
+            data["type"] = "1"
+            data["price"] = str(price)
+
+        if "close" in side:
+            if side == 'close_buy':
+                data["side"] = 4
+            elif side == 'close_sell':
+                data["side"] = 2
+                data["type"] = 5
+            if position_id is None:
+                raise ValueError("position_id is required for closing position")
+            data["positionId"] = position_id
+        import time
+        print(time.time(), '下单')
+        res =  await self.client.fetch(
+            "POST", f"{self.api_url}/api/v1/private/order/create", data=data
+        )
+        return self.ret_content(res)
+
+    async def cancel_orders(self, order_ids: list[str]):
+        res = await self.client.fetch(
+            "POST",
+            f"{self.api_url}/api/v1/private/order/cancel",
+            data=order_ids,
+        )
+        return self.ret_content(res)
+
+    async def query_orders(
+        self,
+        symbol: str,
+        states: list[Literal["filled", "canceled"]],  # filled:已成交, canceled:已撤销
+        start_time: Optional[int] = None,
+        end_time: Optional[int] = None,
+        page_size: int = 200,
+        page_num: int = 1,
+    ):
+        """查询历史订单
+
+        Args:
+            symbol: 交易对
+            states: 订单状态列表 ["filled":已成交, "canceled":已撤销]
+            start_time: 开始时间戳(毫秒), 可选
+            end_time: 结束时间戳(毫秒), 可选
+            page_size: 每页数量, 默认200
+            page_num: 页码, 默认1
+        """
+        state_map = {"filled": 3, "canceled": 4}
+
+        params = {
+            "symbol": symbol,
+            "states": ",".join(str(state_map[state]) for state in states),
+            "page_size": page_size,
+            "page_num": page_num,
+            "category": 1,
+        }
+
+        if start_time:
+            params["start_time"] = start_time
+        if end_time:
+            params["end_time"] = end_time
+
+        res = await self.client.fetch(
+            "GET",
+            f"{self.api_url}/api/v1/private/order/list/history_orders",
+            params=params,
+        )
+
+        return self.ret_content(res)
+
+    async def query_order(self, order_id: str):
+        """查询单个订单的详细信息
+
+        Args:
+            order_id: 订单ID
+
+        Returns:
+            ..code:python
+
+            订单详情数据，例如:
+            [
+                    {
+                        "id": "38600506",          # 成交ID
+                        "symbol": "SOL_USDT",      # 交易对
+                        "side": 4,                 # 方向(1:买入, 3:卖出, 4:平仓)
+                        "vol": 1,                  # 成交数量
+                        "price": 204.11,          # 成交价格
+                        "fee": 0.00081644,        # 手续费
+                        "feeCurrency": "USDT",    # 手续费币种
+                        "profit": -0.0034,        # 盈亏
+                        "category": 1,            # 品类
+                        "orderId": "219079365441409152",  # 订单ID
+                        "timestamp": 1756270991000,       # 时间戳
+                        "positionMode": 1,        # 持仓模式
+                        "voucher": false,         # 是否使用代金券
+                        "taker": true            # 是否是taker
+                    }
+            ]
+        """
+        res = await self.client.fetch(
+            "GET",
+            f"{self.api_url}/api/v1/private/order/deal_details/{order_id}",
+        )
+        return self.ret_content(res)

hyperquant/broker/ws.py

@@ -0,0 +1,12 @@
+import asyncio
+import pybotters
+
+
+class Heartbeat:
+    @staticmethod
+    async def ourbit(ws: pybotters.ws.ClientWebSocketResponse):
+        while not ws.closed:
+            await ws.send_str('{"method":"ping"}')
+            await asyncio.sleep(10.0)
+
+pybotters.ws.HeartbeatHosts.items['futures.ourbit.com'] = Heartbeat.ourbit

{hyperquant-0.26.dist-info → hyperquant-0.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 0.26
+Version: 0.31
 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

{hyperquant-0.26.dist-info → hyperquant-0.31.dist-info}/RECORD

@@ -1,16 +1,21 @@
-hyperquant/__init__.py,sha256=gUuAPVpg5k8X_dpda5OpqmMyZ-ZXNQq-xwx-6JR5Jr4,131
+hyperquant/__init__.py,sha256=UpjiX4LS5jmrBc2kE8RiLR02eCfD8JDQrR1q8zkLNcQ,161
 hyperquant/core.py,sha256=7XrpuHvccWl9lNyVihqaptupqUMsG3xYmQr8eEDrwS4,20610
 hyperquant/db.py,sha256=i2TjkCbmH4Uxo7UTDvOYBfy973gLcGexdzuT_YcSeIE,6678
 hyperquant/draw.py,sha256=up_lQ3pHeVLoNOyh9vPjgNwjD0M-6_IetSGviQUgjhY,54624
 hyperquant/logkit.py,sha256=WALpXpIA3Ywr5DxKKK3k5EKubZ2h-ISGfc5dUReQUBQ,7795
 hyperquant/notikit.py,sha256=x5yAZ_tAvLQRXcRbcg-VabCaN45LUhvlTZnUqkIqfAA,3596
-hyperquant/broker/hyperliquid.py,sha256=mSBVfmjcv6ciI1vWrmHYwBOTHrg-NQrwcyVFUXYEgVw,21998
+hyperquant/broker/auth.py,sha256=hrdVuBTZwD3xSy5GI5JTFJhKiHhvIjZHA_7G5IUFznQ,1580
+hyperquant/broker/hyperliquid.py,sha256=7MxbI9OyIBcImDelPJu-8Nd53WXjxPB5TwE6gsjHbto,23252
+hyperquant/broker/ourbit.py,sha256=VE1eLvQ1hakOxWbXHmW8KXwYrP_Apsv0_FOPtmU3MKs,8033
+hyperquant/broker/ws.py,sha256=98Djt5n5sHUJKVbQ8Ql1t-G-Wiwu__4MYcUr5P6SDL0,326
 hyperquant/broker/lib/hpstore.py,sha256=LnLK2zmnwVvhEbLzYI-jz_SfYpO1Dv2u2cJaRAb84D8,8296
 hyperquant/broker/lib/hyper_types.py,sha256=HqjjzjUekldjEeVn6hxiWA8nevAViC2xHADOzDz9qyw,991
+hyperquant/broker/models/hyperliquid.py,sha256=c4r5739ibZfnk69RxPjQl902AVuUOwT8RNvKsMtwXBY,9459
+hyperquant/broker/models/ourbit.py,sha256=zvjtx6fmOuOPAJ8jxD2RK9_mao2XuE2EXkxR74nmXKM,18525
 hyperquant/datavison/_util.py,sha256=92qk4vO856RqycO0YqEIHJlEg-W9XKapDVqAMxe6rbw,533
 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-0.26.dist-info/METADATA,sha256=YAc40ZCIrhQE-5pyXnxPRz3bVSToOyJKiB2XHFspzZs,4317
-hyperquant-0.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-0.26.dist-info/RECORD,,
+hyperquant-0.31.dist-info/METADATA,sha256=ZfMLDTVVmQdtj-qCg1kwN1fl1TJfRpzHki-6AoUnhEI,4317
+hyperquant-0.31.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-0.31.dist-info/RECORD,,