hyperquant 1.22__py3-none-any.whl → 1.25__py3-none-any.whl

hyperquant/broker/lighter.py

@@ -3,12 +3,14 @@ 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
 
 from lighter.api.account_api import AccountApi
 from lighter.api.order_api import OrderApi
+from lighter.api.candlestick_api import CandlestickApi
 from lighter.api_client import ApiClient
 from lighter.configuration import Configuration
 from lighter.signer_client import SignerClient
@@ -31,6 +33,7 @@ class Lighter:
         api_key_index: int = 3,
         api_client: ApiClient | None = None,
         order_api: OrderApi | None = None,
+        candlestick_api: CandlestickApi | None = None,
         account_api: AccountApi | None = None,
         ws_url: str | None = None,
     ) -> None:
@@ -46,6 +49,7 @@ class Lighter:
         self._owns_api_client = api_client is None
 
         self.order_api = order_api or OrderApi(self._api_client)
+        self.candlestick_api = candlestick_api or CandlestickApi(self._api_client)
         self.account_api = account_api or AccountApi(self._api_client)
         self.signer: SignerClient = None
 
@@ -150,7 +154,9 @@ class Lighter:
 
 
         if include_detail:
-            tasks.append(("detail", self.order_api.order_books()))
+            # Use raw HTTP to avoid strict SDK model validation issues (e.g., status 'inactive').
+            url = f"{self.configuration.host.rstrip('/')}/api/v1/orderBooks"
+            tasks.append(("detail", self.client.get(url)))
 
         if include_orders:
             if account_index is None or symbol is None:
@@ -206,7 +212,12 @@ class Lighter:
         results: dict[str, Any] = {}
         for key, coroutine in tasks:
             try:
-                results[key] = await coroutine
+                resp = await coroutine
+                if key == "detail":
+                    # Parse JSON body for detail endpoint
+                    results[key] = await resp.json()
+                else:
+                    results[key] = resp
             except Exception:
                 logger.exception("Lighter REST request %s failed", key)
                 raise
@@ -292,13 +303,104 @@ class Lighter:
         await ws_app._event.wait()
         return ws_app
 
-    async def sub_accounts(
+
+    async def sub_orders(
+        self,
+        account_ids: Sequence[int] | int = None,
+    ) -> pybotters.ws.WebSocketApp:
+        """Subscribe to order updates via Account All Orders stream.
+
+        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,
-        account_ids: Sequence[int] | int,
+        symbols: Sequence[str] | str,
+        *,
+        resolutions: Sequence[str] | str,
     ) -> pybotters.ws.WebSocketApp:
-        """Subscribe to account-only websocket updates."""
+        """Subscribe to trade streams and aggregate into klines in the store.
 
-        return await self.sub_orderbook(market_ids=[], account_ids=account_ids)
+        - symbols: list of symbols (e.g., ["BTC-USD"]) or a single symbol; may also be numeric market_ids.
+        - resolutions: list like ["1m", "5m"] or a single resolution; added to kline store for aggregation.
+        """
+
+        # Normalize inputs
+        symbol_list = [symbols] if isinstance(symbols, str) else list(symbols)
+        res_list = [resolutions] if isinstance(resolutions, str) else list(resolutions)
+
+        if not symbol_list:
+            raise ValueError("At least one symbol must be provided")
+        if not res_list:
+            raise ValueError("At least one resolution must be provided")
+
+        # Ensure market metadata for symbol->market_id resolution
+        needs_detail = any(self.get_contract_id(sym) is None and not str(sym).isdigit() for sym in symbol_list)
+        if needs_detail:
+            try:
+                await self.update("detail")
+            except Exception:
+                logger.exception("Failed to refresh Lighter market metadata for kline subscription")
+                raise
+
+        # Resolve market ids and populate id->symbol mapping for klines store
+        trade_market_ids: list[str] = []
+        for sym in symbol_list:
+            market_id = self.get_contract_id(sym)
+            if market_id is None:
+                if str(sym).isdigit():
+                    market_id = str(sym)
+                    symbol_for_map = str(sym)
+                else:
+                    raise ValueError(f"Unknown symbol: {sym}")
+            else:
+                symbol_for_map = sym
+            market_id_str = str(market_id)
+            trade_market_ids.append(market_id_str)
+            # ensure klines store can resolve symbol from market id
+            self.store.klines.id_to_symbol[market_id_str] = symbol_for_map
+
+        # Register resolutions into kline store aggregation list
+        for r in res_list:
+            if r not in self.store.klines._res_list:
+                self.store.klines._res_list.append(r)
+
+        # Build subscribe payload for trade channels
+        channels = [f"trade/{mid}" for mid in trade_market_ids]
+        send_payload = [{"type": "subscribe", "channel": ch} for ch 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 place_order(
         self,
@@ -366,30 +468,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
         )
@@ -468,3 +621,60 @@ class Lighter:
             "request": request_payload,
             "response": response_payload,
         }
+
+    async def update_kline(
+        self,
+        symbol: str,
+        *,
+        resolution: str,
+        start_timestamp: int,
+        end_timestamp: int,
+        count_back: int,
+        set_timestamp_to_end: bool | None = None,
+    ) -> list[dict[str, Any]]:
+        """Fetch candlesticks and update the Kline store.
+
+        Parameters
+        - symbol: market symbol, e.g. "BTC-USD".
+        - resolution: e.g. "1m", "5m", "1h".
+        - start_timestamp: epoch milliseconds.
+        - end_timestamp: epoch milliseconds.
+        - count_back: number of bars to fetch.
+        - set_timestamp_to_end: if True, API sets last bar timestamp to the end.
+        """
+
+        market_id = self.get_contract_id(symbol)
+        if market_id is None:
+            # try to refresh metadata once
+            await self.update("detail")
+            market_id = self.get_contract_id(symbol)
+        if market_id is None:
+            raise ValueError(f"Unknown symbol: {symbol}")
+
+        resp = await self.candlestick_api.candlesticks(
+            market_id=int(market_id),
+            resolution=resolution,
+            start_timestamp=int(start_timestamp),
+            end_timestamp=int(end_timestamp),
+            count_back=int(count_back),
+            set_timestamp_to_end=bool(set_timestamp_to_end) if set_timestamp_to_end is not None else None,
+        )
+
+        # Update store
+        self.store.klines._onresponse(resp, symbol=symbol, resolution=resolution)
+
+        payload = _maybe_to_dict(resp) or {}
+        items = payload.get("candlesticks") or []
+        # attach symbol/resolution to return
+        out: list[dict[str, Any]] = []
+        for it in items:
+            if hasattr(it, "to_dict"):
+                d = it.to_dict()
+            elif hasattr(it, "model_dump"):
+                d = it.model_dump()
+            else:
+                d = dict(it) if isinstance(it, dict) else {"value": it}
+            d["symbol"] = symbol
+            d["resolution"] = resolution
+            out.append(d)
+        return out