hyperquant 0.65__py3-none-any.whl → 0.67__py3-none-any.whl

hyperquant/broker/models/edgex.py

@@ -4,6 +4,7 @@ import asyncio
 from typing import Any, Awaitable, TYPE_CHECKING
 
 from aiohttp import ClientResponse
+import aiohttp
 from pybotters.store import DataStore, DataStoreCollection
 
 if TYPE_CHECKING:
@@ -121,7 +122,6 @@ class Book(DataStore):
         if updates:
             self._update(updates)
             self._trim(contract_id, contract_name)
-        
 
     def _build_items(
         self,
@@ -235,6 +235,22 @@ class Ticker(DataStore):
             else:
                 self._update([item])
 
+    def _onresponse(self, data: dict[str, Any]) -> None:
+        entries = data.get("data") or []
+
+        if not isinstance(entries, list):
+            entries = [entries]
+
+        items = []
+        for entry in entries:
+            item = self._format(entry)
+            if item:
+                items.append(item)
+
+        self._clear()
+        if items:
+            self._insert(items)
+
     def _format(self, entry: dict[str, Any]) -> dict[str, Any] | None:
         contract_id = entry.get("contractId")
         if contract_id is None:
@@ -279,6 +295,311 @@ class Ticker(DataStore):
         return item
 
 
+class Order(DataStore):
+    """Order data store combining REST results with trade-event deltas.
+
+    We only keep fields that are practical for trading book-keeping: identifiers,
+    basic order parameters, cumulative fills, high-level status and timestamps.
+    Network payloads carry hundreds of fields (``l2`` signatures, TPSL templates,
+    liquidation metadata, etc.), but the extra data adds noise and bloats memory
+    consumption.  This store narrows every entry to a compact schema while still
+    supporting diff events from the private websocket feed.
+    """
+
+    _KEYS = ["orderId"]
+
+    _TERMINAL_STATUSES = {
+        "FILLED",
+        "CANCELED",
+        "CANCELLED",
+        "REJECTED",
+        "EXPIRED",
+    }
+
+    _ACTIVE_STATUSES = {
+        "OPEN",
+        "PARTIALLY_FILLED",
+        "PENDING",
+        "CREATED",
+        "ACKNOWLEDGED",
+    }
+
+    _KEEP_FIELDS = (
+        "userId",
+        "accountId",
+        "coinId",
+        "contractId",
+        "clientOrderId",
+        "type",
+        "timeInForce",
+        "reduceOnly",
+        "price",
+        "size",
+        "cumFillSize",
+        "cumFillValue",
+        "cumMatchSize",
+        "cumMatchValue",
+        "cumMatchFee",
+        "triggerPrice",
+        "triggerPriceType",
+        "cancelReason",
+        "createdTime",
+        "updatedTime",
+        "matchSequenceId",
+    )
+
+    _BOOL_FIELDS = {"reduceOnly"}
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        content = msg.get("content") or {}
+        data = content.get("data") or {}
+        orders = data.get("order") or []
+
+        if not isinstance(orders, list):
+            orders = [orders]
+
+        items = [self._format(order) for order in orders]
+        items = [item for item in items if item]
+        if not items:
+            return
+
+        event = (content.get("event") or "").lower()
+        if event == "snapshot":
+            self._clear()
+            self._insert(items)
+            return
+
+        for item in items:
+            status = str(item.get("status") or "").upper()
+            criteria = {"orderId": item["orderId"]}
+            existing = self.find(criteria)
+
+            if status in self._TERMINAL_STATUSES:
+                if existing:
+                    self._update([item])
+                else:
+                    self._insert([item])
+                self._find_and_delete(criteria)
+                continue
+
+            if status and status not in self._ACTIVE_STATUSES:
+                if existing:
+                    self._update([item])
+                else:
+                    self._insert([item])
+                self._find_and_delete(criteria)
+                continue
+
+            if existing:
+                self._update([item])
+            else:
+                self._insert([item])
+
+    def _onresponse(self, data: dict[str, Any]) -> None:
+        payload = data.get("data")
+
+        if isinstance(payload, dict):
+            orders = payload.get("dataList") or payload.get("orderList") or []
+        else:
+            orders = payload or []
+
+        if not isinstance(orders, list):
+            orders = [orders]
+
+        items = [self._format(order) for order in orders]
+        items = [item for item in items if item]
+
+        self._clear()
+        if items:
+            self._insert(items)
+
+    @staticmethod
+    def _normalize_order_id(value: Any) -> str | None:
+        if value is None:
+            return None
+        return str(value)
+
+    @staticmethod
+    def _normalize_side(value: Any) -> str | None:
+        if value is None:
+            return None
+        if isinstance(value, str):
+            return value.lower()
+        return str(value)
+
+    @staticmethod
+    def _normalize_status(value: Any) -> str | None:
+        if value is None:
+            return None
+        return str(value).upper()
+
+    @staticmethod
+    def _stringify(value: Any) -> Any:
+        if value is None:
+            return None
+        if isinstance(value, (bool, dict, list)):
+            return value
+        return str(value)
+
+    def _format(self, order: dict[str, Any] | None) -> dict[str, Any] | None:
+        if not order:
+            return None
+
+        order_id = (
+            order.get("orderId")
+            or order.get("id")
+            or order.get("order_id")
+            or order.get("orderID")
+        )
+
+        normalized_id = self._normalize_order_id(order_id)
+        if normalized_id is None:
+            return None
+
+        item: dict[str, Any] = {"orderId": normalized_id, "id": normalized_id}
+
+        side = self._normalize_side(order.get("side"))
+        if side is not None:
+            item["side"] = side
+
+        status = self._normalize_status(order.get("status"))
+        if status is not None:
+            item["status"] = status
+
+        contract_name = order.get("contractName")
+        if contract_name:
+            symbol = self._stringify(contract_name)
+            item["contractName"] = symbol
+            item.setdefault("symbol", symbol)
+
+        for field in self._KEEP_FIELDS:
+            if field in ("side", "status"):
+                continue
+            value = order.get(field)
+            if value is None:
+                continue
+            if field in self._BOOL_FIELDS:
+                item[field] = bool(value)
+            else:
+                item[field] = self._stringify(value)
+
+        return item
+
+
+class Balance(DataStore):
+    """Account balance snapshot retaining only the trading-critical fields."""
+
+    _KEYS = ["accountId", "coinId"]
+
+
+    def _onresponse(self, data: dict[str, Any]) -> None:
+        data = data.get('data', {})
+        collateral_assets = data.get('collateralAssetModelList') or []
+        if collateral_assets:
+            self._update(collateral_assets)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        pass
+
+
+class Position(DataStore):
+    """
+    Stores per-account open positions in a simplified camelCase schema.
+    Only the current open position fields are retained: positionId, contractId, accountId,
+    userId, coinId, side, size, value, fee, fundingFee.
+    """
+
+    _KEYS = ["positionId"]
+
+    @staticmethod
+    def _stringify(value: Any) -> Any:
+        if value is None:
+            return None
+        if isinstance(value, (bool, dict, list)):
+            return value
+        return str(value)
+
+    def _onresponse(self, data: dict[str, Any]) -> None:
+        """
+        Handle REST response for getAccountAsset (open positions snapshot).
+        Expects data from getAccountAsset (REST), which returns a snapshot of **current open positions**,
+        as a list in data["positionList"].
+        Each entry is normalized to camelCase schema, only including essential fields for the current open position.
+        """
+        data = data.get("data", {}) or {}
+        positions = data.get("positionList") or []
+        if not isinstance(positions, list):
+            positions = [positions]
+        items = [self._normalize_position(pos) for pos in positions]
+        self._clear()
+        if items:
+            self._update(items)
+
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        data = msg.get("content", {}).get("data", {})
+        if not data:
+            return
+        positions = data.get("position")
+        if not positions:
+            return
+        items = [self._normalize_position(pos) for pos in positions]
+        self._clear()
+        if items:
+            self._update(items)
+
+    def _normalize_position(self, pos: dict[str, Any]) -> dict[str, Any]:
+        # Only keep essential fields for the current open position
+        def get(key, *alts):
+            for k in (key,) + alts:
+                if k in pos and pos[k] is not None:
+                    return pos[k]
+            return None
+
+        open_size = get("openSize")
+        open_value = get("openValue")
+        open_fee = get("openFee")
+        funding_fee = get("fundingFee")
+
+        # side: "long" if openSize > 0, "short" if openSize < 0, None if 0
+        side = None
+        try:
+            if open_size is not None:
+                fsize = float(open_size)
+                if fsize > 0:
+                    side = "long"
+                elif fsize < 0:
+                    side = "short"
+        except Exception:
+            side = None
+
+        size = None
+        if open_size is not None:
+            try:
+                size = str(abs(float(open_size)))
+            except Exception:
+                size = str(open_size)
+        value = None
+        if open_value is not None:
+            try:
+                value = str(abs(float(open_value)))
+            except Exception:
+                value = str(open_value)
+
+        item = {
+            "positionId": self._stringify(get("positionId", "position_id")),
+            "contractId": self._stringify(get("contractId")),
+            "accountId": self._stringify(get("accountId")),
+            "userId": self._stringify(get("userId")),
+            "coinId": self._stringify(get("coinId")),
+            "side": side,
+            "size": size,
+            "value": value,
+            "fee": self._stringify(open_fee),
+            "fundingFee": self._stringify(funding_fee),
+        }
+        return item
+
+
 class CoinMeta(DataStore):
     """Coin metadata (precision, StarkEx info, etc.)."""
 
@@ -310,7 +631,7 @@ class CoinMeta(DataStore):
 class ContractMeta(DataStore):
     """Per-contract trading parameters from the metadata endpoint."""
 
-    _KEYS = ["contractId"]
+    _KEYS = ["contractName"]
 
     _FIELDS = (
         "contractName",
@@ -342,7 +663,9 @@ class ContractMeta(DataStore):
             payload = {"contractId": str(contract_id)}
             for key in self._FIELDS:
                 payload[key] = contract.get(key)
-            payload["riskTierList"] = self._simplify_risk_tiers(contract.get("riskTierList"))
+            payload["riskTierList"] = self._simplify_risk_tiers(
+                contract.get("riskTierList")
+            )
 
             items.append(payload)
 
@@ -366,14 +689,57 @@ class ContractMeta(DataStore):
             )
         return items
 
+
+class AppMeta(DataStore):
+    """Global metadata (appName, env, fee account, etc.)."""
+
+    _KEYS = ["appName"]
+
+    def _onresponse(self, data: dict[str, Any]) -> None:
+        appdata = (data.get("data") or {}).get("global") or {}
+        if not appdata:
+            self._clear()
+            return
+        # Convert all values to str where appropriate, but preserve fields as-is (for bool/int etc).
+        item = {}
+        for k, v in appdata.items():
+            if k == "starkExCollateralCoin" and isinstance(v, dict):
+                # Flatten the dict into top-level fields with prefix
+                for subk, subv in v.items():
+                    # Compose the flattened key
+                    prefix = "starkExCollateral"
+                    # Capitalize first letter of subkey
+                    if subk and subk[0].islower():
+                        flatkey = prefix + subk[0].upper() + subk[1:]
+                    else:
+                        flatkey = prefix + subk
+                    item[flatkey] = subv if subv is None or isinstance(subv, (bool, int, float)) else str(subv)
+                continue
+            # Convert to str except for None; preserve bool/int/float as-is
+            if v is None:
+                item[k] = v
+            elif isinstance(v, (bool, int, float)):
+                item[k] = v
+            else:
+                item[k] = str(v)
+        self._clear()
+        if item:
+            self._insert([item])
+
+
 class EdgexDataStore(DataStoreCollection):
     """Edgex DataStore collection exposing the order book feed."""
 
     def _init(self) -> None:
         self._create("book", datastore_class=Book)
         self._create("ticker", datastore_class=Ticker)
+        self._create("orders", datastore_class=Order)
+        self._create("balance", datastore_class=Balance)
+        # Position store holds per-account open positions in simplified camelCase form
+        self._create("position", datastore_class=Position)
         self._create("meta_coin", datastore_class=CoinMeta)
         self._create("detail", datastore_class=ContractMeta)
+        self._create("app", datastore_class=AppMeta)
 
     @property
     def book(self) -> Book:
@@ -394,8 +760,121 @@ class EdgexDataStore(DataStoreCollection):
         """
         return self._get("book")
 
+    @property
+    def orders(self) -> Order:
+        """
+        账户订单数据流（REST 快照 + 私有 WS 增量）。
+
+        存储为**精简 schema**，仅保留实操必需字段。终态订单（FILLED / CANCELED / CANCELLED / REJECTED / EXPIRED）
+        会在写入一次后从本地缓存删除，只保留进行中的订单（OPEN / PARTIALLY_FILLED / PENDING / CREATED / ACKNOWLEDGED）。
 
 
+        存储示例（本地条目）
+        -------------------
+        REST 快照：
+
+        .. code:: json
+
+            [
+                {
+                    "orderId": "564815695875932430",
+                    "id": "564815695875932430",
+                    "contractId": "10000001",
+                    "contractName": "BTCUSD",
+                    "symbol": "BTCUSD",
+                    "side": "buy",
+                    "status": "OPEN",
+                    "type": "LIMIT",
+                    "timeInForce": "GOOD_TIL_CANCEL",
+                    "reduceOnly": false,
+                    "price": "97444.5",
+                    "size": "0.010",
+                    "cumFillSize": "0.000",
+                    "cumFillValue": "0",
+                    "clientOrderId": "553364074986685",
+                    "createdTime": "1734662555665",
+                    "updatedTime": "1734662555665"
+                }
+            ]
+
+
+        """
+        return self._get("orders")
+
+    @property
+    def balance(self) -> Balance:
+        """
+        获取账户资产余额（REST 快照 + 私有 WS 增量）。
+
+        .. code:: json
+
+            [
+                {
+                    userId: "663528067892773124",
+                    accountId: "663528067938910372",
+                    coinId: "1000",
+                    totalEquity: "22.721859",
+                    totalPositionValueAbs: "0",
+                    initialMarginRequirement: "0",
+                    starkExRiskValue: "0",
+                    pendingWithdrawAmount: "0",
+                    pendingTransferOutAmount: "0",
+                    orderFrozenAmount: "3.001126965030794963240623474121093750",
+                    availableAmount: "19.720732",
+                },
+            ]
+
+        """
+        return self._get("balance")
+        
+    @property
+    def position(self) -> "Position":
+        """
+        获取账户当前未平仓持仓（open positions，来自 getAccountAsset）。
+
+        本属性提供**当前未平仓持仓**的快照（由 REST ``getAccountAsset`` 提供），每条数据为当前账户的一个持仓（多/空/逐仓/全仓等）。
+        字段为 snake_case，包含持仓数量、均价、强平价、杠杆、保证金率等信息，适合用于持仓管理与风险监控。
+
+        数据示例：
+
+        .. code:: python
+
+        [
+            {
+                orderId: "665307878751470244",
+                id: "665307878751470244",
+                side: "buy",
+                status: "OPEN",
+                userId: "663528067892773124",
+                accountId: "663528067938910372",
+                coinId: "1000",
+                contractId: "10000003",
+                clientOrderId: "32570392453812747",
+                type: "LIMIT",
+                timeInForce: "GOOD_TIL_CANCEL",
+                reduceOnly: False,
+                price: "210.00",
+                size: "0.3",
+                cumFillSize: "0",
+                cumFillValue: "0",
+                cumMatchSize: "0",
+                cumMatchValue: "0",
+                cumMatchFee: "0",
+                triggerPrice: "0",
+                triggerPriceType: "UNKNOWN_PRICE_TYPE",
+                cancelReason: "UNKNOWN_ORDER_CANCEL_REASON",
+                createdTime: "1758621759117",
+                updatedTime: "1758621759122",
+                matchSequenceId: "784278904",
+            },
+        ];
+
+
+        本属性仅包含**当前持有的未平仓持仓**（由 REST ``getAccountAsset`` 提供）。
+        若需获取**历史已平仓持仓周期**，请调用 ``getPositionTermPage``。
+        """
+        return self._get("position")
+        
     @property
     def coins(self) -> CoinMeta:
         """
@@ -425,7 +904,7 @@ class EdgexDataStore(DataStoreCollection):
             [
                 {
                     "contractId": "10000001",
-                    "contractName": "BTCUSDT",
+                    "contractName": "BTCUSD",
                     "baseCoinId": "1001",
                     "quoteCoinId": "1000",
                     "tickSize": "0.1",
@@ -494,10 +973,20 @@ class EdgexDataStore(DataStoreCollection):
         for fut in asyncio.as_completed(aws):
             res = await fut
             data = await res.json()
+            if data['code'] != 'SUCCESS':
+                raise ValueError(f"Unexpected response code: {data}")
             if res.url.path == "/api/v1/public/meta/getMetaData":
                 self._apply_metadata(data)
+            elif res.url.path == "/api/v1/private/account/getAccountAsset":
+                self.balance._onresponse(data)
+                self.position._onresponse(data)
+            elif res.url.path == "/api/v1/private/order/getActiveOrderPage":
+                self.orders._onresponse(data)
+            elif res.url.path == "/api/v1/public/quote/getTicker":
+                self.ticker._onresponse(data)
 
     def onmessage(self, msg: Item, ws: ClientWebSocketResponse | None = None) -> None:
+        # print(msg)
         channel = (msg.get("channel") or "").lower()
         msg_type = (msg.get("type") or "").lower()
 
@@ -506,13 +995,59 @@ class EdgexDataStore(DataStoreCollection):
             asyncio.create_task(ws.send_json(payload))
             return
 
+        if msg_type in {"trade-event", "trade_event", "order-event", "order_event"}:
+            self.orders._on_message(msg)
+            self.position._on_message(msg)
+
         if "depth" in channel and msg_type in {"quote-event", "payload"}:
             self.book._on_message(msg)
 
         if channel.startswith("ticker") and msg_type in {"payload", "quote-event"}:
             self.ticker._on_message(msg)
 
-
     def _apply_metadata(self, data: dict[str, Any]) -> None:
+        self.app._onresponse(data)
         self.coins._onresponse(data)
         self.detail._onresponse(data)
+
+
+    @property
+    def app(self) -> AppMeta:
+        """
+        获取全局元数据，如 appName、环境、fee 账户等。
+
+        .. code:: python
+
+
+        [
+            {
+                "appName": "edgeX",
+                "appEnv": "mainnet",
+                "appOnlySignOn": "https://pro.edgex.exchange",
+                "feeAccountId": "256105",
+                "feeAccountL2Key": "0x70092acf49d535fbb64d99883abda95dcf9a4fc60f494437a3d76f27db0a0f5",
+                "poolAccountId": "508126509156794507",
+                "poolAccountL2Key": "0x7f2e1e8a572c847086ee93c9b5bbce8b96320aaa69147df1cfca91d5e90bc60",
+                "fastWithdrawAccountId": "508126509156794507",
+                "fastWithdrawAccountL2Key": "0x7f2e1e8a572c847086ee93c9b5bbce8b96320aaa69147df1cfca91d5e90bc60",
+                "fastWithdrawMaxAmount": "100000",
+                "fastWithdrawRegistryAddress": "0xBE9a129909EbCb954bC065536D2bfAfBd170d27A",
+                "starkExChainId": "0x1",
+                "starkExContractAddress": "0xfAaE2946e846133af314d1Df13684c89fA7d83DD",
+                "starkExCollateralCoinId": "1000",
+                "starkExCollateralCoinName": "USD",
+                "starkExCollateralStepSize": "0.000001",
+                "starkExCollateralShowStepSize": "0.0001",
+                "starkExCollateralIconUrl": "https://static.edgex.exchange/icons/coin/USDT.svg",
+                "starkExCollateralStarkExAssetId": "0x2ce625e94458d39dd0bf3b45a843544dd4a14b8169045a3a3d15aa564b936c5",
+                "starkExCollateralStarkExResolution": "0xf4240",
+                "starkExMaxFundingRate": 12000,
+                "starkExOrdersTreeHeight": 64,
+                "starkExPositionsTreeHeight": 64,
+                "starkExFundingValidityPeriod": 86400,
+                "starkExPriceValidityPeriod": 86400,
+                "maintenanceReason": "",
+            }
+        ]
+        """
+        return self._get("app")