hyperquant 1.24__py3-none-any.whl → 1.26__py3-none-any.whl

hyperquant/broker/lighter.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import json
+from decimal import Decimal, ROUND_DOWN, ROUND_HALF_UP
 from typing import Any, Literal, Sequence
 
 import pybotters
@@ -296,19 +297,44 @@ class Lighter:
             self.ws_url,
             send_json=send_payload,
             hdlr_json=self.store.onmessage,
-            autoping=False,
         )
 
         await ws_app._event.wait()
         return ws_app
 
-    async def sub_accounts(
+
+    async def sub_orders(
         self,
-        account_ids: Sequence[int] | int,
+        account_ids: Sequence[int] | int = None,
     ) -> pybotters.ws.WebSocketApp:
-        """Subscribe to account-only websocket updates."""
+        """Subscribe to order updates via Account All Orders stream.
 
-        return await self.sub_orderbook(market_ids=[], account_ids=account_ids)
+        Channel per docs: "account_all_orders/{ACCOUNT_ID}" (requires auth).
+        Response carries an "orders" mapping of market_id -> [Order].
+        """
+        if account_ids:
+            if isinstance(account_ids, int):
+                account_id_list = [str(account_ids)]
+            else:
+                account_id_list = [str(aid) for aid in account_ids]
+        else:
+            account_id_list = [self.account_index]
+
+        channels = [f"account_all_orders/{aid}" for aid in account_id_list]
+        send_payload = [
+            {"type": "subscribe", "channel": channel, "auth": self.auth}
+            for channel in channels
+        ]
+
+        ws_app = self.client.ws_connect(
+            self.ws_url,
+            send_json=send_payload,
+            hdlr_json=self.store.onmessage,
+        )
+        await ws_app._event.wait()
+        return ws_app
+    
+    
 
     async def sub_kline(
         self,
@@ -441,30 +467,81 @@ class Lighter:
         except KeyError as exc:
             raise ValueError(f"Unsupported time_in_force: {time_in_force}") from exc
 
-        expiry = order_expiry if order_expiry is not None else self.signer.DEFAULT_28_DAY_ORDER_EXPIRY
+        # Per WS/API docs, OrderExpiry can be 0 with ExpiredAt computed by signer.
+        # Use caller-provided value if given; otherwise default to 0 to avoid
+        # "OrderExpiry is invalid" errors on some markets.
+        expiry = order_expiry if order_expiry is not None else 0
         nonce_value = nonce if nonce is not None else -1
         api_key_idx = api_key_index if api_key_index is not None else self.api_key_index
 
+        # ----- Precision and min constraints handling -----
+        # Prefer explicitly supported decimals. Avoid using quote decimals to infer size.
         price_decimals = (
             detail.get("supported_price_decimals")
             or detail.get("price_decimals")
-            or detail.get("quote_decimals")
             or 0
         )
         size_decimals = (
             detail.get("supported_size_decimals")
             or detail.get("size_decimals")
-            or detail.get("supported_quote_decimals")
             or 0
         )
 
+        # Optional constraints provided by the API
+        # Strings like "10.000000" may be returned – normalize via Decimal for accuracy
+        def _to_decimal(v, default: str | int = 0):
+            try:
+                if v is None or v == "":
+                    return Decimal(str(default))
+                return Decimal(str(v))
+            except Exception:
+                return Decimal(str(default))
+
+        min_base_amount = _to_decimal(detail.get("min_base_amount"), 0)
+        min_quote_amount = _to_decimal(detail.get("min_quote_amount"), 0)
+        order_quote_limit = _to_decimal(detail.get("order_quote_limit"), 0)
+
+        # Use Decimal for precise arithmetic and quantization
+        d_price = Decimal(str(price))
+        d_size = Decimal(str(base_amount))
+        quant_price = Decimal(1) / (Decimal(10) ** int(price_decimals)) if int(price_decimals) > 0 else Decimal(1)
+        quant_size = Decimal(1) / (Decimal(10) ** int(size_decimals)) if int(size_decimals) > 0 else Decimal(1)
+
+        # Round price/size to allowed decimals (half up to the nearest tick)
+        d_price = d_price.quantize(quant_price, rounding=ROUND_HALF_UP)
+        d_size = d_size.quantize(quant_size, rounding=ROUND_HALF_UP)
+
+        # Ensure minimum notional and minimum base constraints
+        # If violating, adjust size upward to the smallest valid amount respecting size tick
+        if min_quote_amount > 0:
+            notional = d_price * d_size
+            if notional < min_quote_amount:
+                # required size to reach min notional
+                required = (min_quote_amount / d_price).quantize(quant_size, rounding=ROUND_HALF_UP)
+                if required > d_size:
+                    d_size = required
+        if min_base_amount > 0 and d_size < min_base_amount:
+            d_size = min_base_amount.quantize(quant_size, rounding=ROUND_HALF_UP)
+
+        # Respect optional maximum notional limit if provided (>0)
+        if order_quote_limit and order_quote_limit > 0:
+            notional = d_price * d_size
+            if notional > order_quote_limit:
+                # Reduce size down to the maximum allowed notional (floor to tick)
+                max_size = (order_quote_limit / d_price).quantize(quant_size, rounding=ROUND_DOWN)
+                if max_size <= 0:
+                    raise ValueError("order would exceed order_quote_limit and cannot be reduced to a positive size")
+                d_size = max_size
+
+        # Convert to integer representation expected by signer
         price_scale = 10 ** int(price_decimals)
         size_scale = 10 ** int(size_decimals)
 
-        price_int = int(round(float(price) * price_scale))
-        base_amount_int = int(round(float(base_amount) * size_scale))
+        price_int = int((d_price * price_scale).to_integral_value(rounding=ROUND_HALF_UP))
+        base_amount_int = int((d_size * size_scale).to_integral_value(rounding=ROUND_HALF_UP))
+
         trigger_price_int = (
-            int(round(float(trigger_price) * price_scale))
+            int((Decimal(str(trigger_price)) * price_scale).to_integral_value(rounding=ROUND_HALF_UP))
             if trigger_price is not None
             else self.signer.NIL_TRIGGER_PRICE
         )

hyperquant/broker/models/lighter.py

@@ -220,6 +220,62 @@ class Orders(DataStore):
         if items:
             self._insert(items)
 
+    def _on_message(self, msg: dict[str, Any]) -> None:
+        """Handle websocket incremental updates for orders.
+
+        For WS updates we should not clear-and-reinsert. Instead:
+        - For fully filled or cancelled orders => delete
+        - Otherwise => update/insert
+        """
+        if not isinstance(msg, dict):
+            return
+
+        orders_obj = msg.get("orders")
+        if orders_obj is None:
+            account = msg.get("account")
+            if isinstance(account, dict):
+                orders_obj = account.get("orders")
+        if not orders_obj:
+            return
+
+        # Normalize orders to a flat list of dicts
+        if isinstance(orders_obj, dict):
+            raw_list: list[dict[str, Any]] = []
+            for _, lst in orders_obj.items():
+                if isinstance(lst, list):
+                    raw_list.extend([o for o in lst if isinstance(o, dict)])
+        elif isinstance(orders_obj, list):
+            raw_list = [o for o in orders_obj if isinstance(o, dict)]
+        else:
+            return
+
+        def _is_terminal(order: dict[str, Any]) -> bool:
+            status = str(order.get("status", "")).lower()
+            if status in {"cancelled", "canceled", "executed", "filled", "closed", "done"}:
+                return True
+            rem = order.get("remaining_base_amount")
+            try:
+                return float(rem) <= 0 if rem is not None else False
+            except Exception:
+                return False
+
+
+        for entry in raw_list:
+            normalized = self._normalize(entry)
+            if normalized is None:
+                continue
+            # enrich with symbol if mapping is available
+            if self.id_to_symbol:
+                market_id = entry.get("market_index")
+                if market_id is not None:
+                    symbol = self.id_to_symbol.get(str(market_id))
+                    if symbol is not None:
+                        normalized["symbol"] = symbol
+
+            self._update([normalized])
+            if _is_terminal(entry):
+                self._delete([normalized])
+
 
 
 
@@ -632,6 +688,9 @@ class LighterDataStore(DataStoreCollection):
             elif msg_type in {"subscribed/account_all", "update/account_all"}:
                 self.accounts._on_message(msg)
                 self.positions._on_message(msg)
+                self.orders._on_message(msg)
+            elif msg_type in {"subscribed/account_all_orders", "update/account_all_orders"}:
+                self.orders._on_message(msg)
             elif msg_type in {"subscribed/trade", "update/trade"}:
                 self.klines._on_message(msg)
 

{hyperquant-1.24.dist-info → hyperquant-1.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.24
+Version: 1.26
 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
@@ -17,7 +17,7 @@ Requires-Dist: aiohttp>=3.10.4
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: cryptography>=44.0.2
 Requires-Dist: duckdb>=1.2.2
-Requires-Dist: lighter-sdk>=0.1.4
+Requires-Dist: lighter-sdk
 Requires-Dist: numpy>=1.21.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pybotters>=1.9.1

{hyperquant-1.24.dist-info → hyperquant-1.26.dist-info}/RECORD

@@ -11,7 +11,7 @@ hyperquant/broker/coinw.py,sha256=SnJU0vASh77rfcpMGWaIfTblQSjQk3vjlW_4juYdbcs,17
 hyperquant/broker/edgex.py,sha256=TqUO2KRPLN_UaxvtLL6HnA9dAQXC1sGxOfqTHd6W5k8,18378
 hyperquant/broker/hyperliquid.py,sha256=7MxbI9OyIBcImDelPJu-8Nd53WXjxPB5TwE6gsjHbto,23252
 hyperquant/broker/lbank.py,sha256=98M5wmSoeHwbBYMA3rh25zqLb6fQKVaEmwqALF5nOvY,22181
-hyperquant/broker/lighter.py,sha256=mgkdHjXXmOAhVlU8uZJ28fcPqzHM0fnjJXXYMTD4wJs,21918
+hyperquant/broker/lighter.py,sha256=xyF967a-AwzecJ9qRPatxEzqis-J8dKQB6Xh1deR9Vc,25611
 hyperquant/broker/ourbit.py,sha256=NUcDSIttf-HGWzoW1uBTrGLPHlkuemMjYCm91MigTno,18228
 hyperquant/broker/ws.py,sha256=AzyFAHIDF4exxwm_IAEV6ihftwAlu19al8Vla4ygk-A,4354
 hyperquant/broker/lib/edgex_sign.py,sha256=lLUCmY8HHRLfLKyGrlTJYaBlSHPsIMWg3EZnQJKcmyk,95785
@@ -24,12 +24,12 @@ hyperquant/broker/models/coinw.py,sha256=LvLMVP7i-qkkTK1ubw8eBkMK2RQmFoKPxdKqmC4
 hyperquant/broker/models/edgex.py,sha256=vPAkceal44cjTYKQ_0BoNAskOpmkno_Yo1KxgMLPc6Y,33954
 hyperquant/broker/models/hyperliquid.py,sha256=c4r5739ibZfnk69RxPjQl902AVuUOwT8RNvKsMtwXBY,9459
 hyperquant/broker/models/lbank.py,sha256=vHkNKxIMzpoC_EwcZnEOPOupizF92yGWi9GKxvYYFUQ,19181
-hyperquant/broker/models/lighter.py,sha256=vpo1xm3S_FEV3GOlbN9_qEhrgj8qXM7jP8jstBP2S0Y,28217
+hyperquant/broker/models/lighter.py,sha256=I6hjM0of8NLtjSmI6OlbJlvpYDDswLn9yyQLz0I1Mes,30495
 hyperquant/broker/models/ourbit.py,sha256=xMcbuCEXd3XOpPBq0RYF2zpTFNnxPtuNJZCexMZVZ1k,41965
 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-1.24.dist-info/METADATA,sha256=B2YHKuabMfGfMSx-OVQnCphVOPL5K94nuG5m5PENKAs,4352
-hyperquant-1.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperquant-1.24.dist-info/RECORD,,
+hyperquant-1.26.dist-info/METADATA,sha256=MwZeeyWfKbippluTm-wo6qMk1GJ185ZLtX8sZ2BoDTc,4345
+hyperquant-1.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperquant-1.26.dist-info/RECORD,,