walrasquant-lib 0.4.27__tar.gz → 0.4.28__tar.gz

{walrasquant_lib-0.4.27 → walrasquant_lib-0.4.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: walrasquant-lib
-Version: 0.4.27
+Version: 0.4.28
 Summary: fastest python trading bot
 Author: River-Shi
 Author-email: River-Shi <nachuan.shi.quant@gmail.com>

{walrasquant_lib-0.4.27 → walrasquant_lib-0.4.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walrasquant-lib"
-version = "0.4.27"
+version = "0.4.28"
 description = "fastest python trading bot"
 authors = [
     {name = "River-Shi",email = "nachuan.shi.quant@gmail.com"}

{walrasquant_lib-0.4.27 → walrasquant_lib-0.4.28}/src/walrasquant/base/ems.py

@@ -168,6 +168,40 @@ class ExecutionManagementSystem(ABC):
         self._build_order_submit_queues()
         self._set_account_type()
 
+    @staticmethod
+    def _quantize_step(
+        value: float,
+        step: float | str,
+        mode: Literal["round", "ceil", "floor"] = "round",
+    ) -> Decimal:
+        """
+        Snap ``value`` to the nearest integer multiple of ``step``.
+
+        Unlike ``Decimal.quantize`` (which aligns to a number of decimal
+        places), this aligns to the actual step value, so it is correct for
+        arbitrary steps such as tick sizes of 0.5 or 0.2 as well as the usual
+        powers of ten. The result is normalized to the number of decimal places
+        implied by ``step`` so its string form matches decimal-place rounding
+        for power-of-ten / integer steps (no spurious trailing zeros).
+
+        ``step`` arrives either as a float (ccxt ``market.precision``) or a str
+        (exchange-native tick fields); both are normalized via ``Decimal(str())``
+        to avoid binary-float error.
+        """
+        rounding = {
+            "round": ROUND_HALF_UP,
+            "ceil": ROUND_CEILING,
+            "floor": ROUND_FLOOR,
+        }[mode]
+        value_decimal = Decimal(str(value))
+        step_decimal = Decimal(str(step))
+        multiples = (value_decimal / step_decimal).quantize(
+            Decimal("1"), rounding=rounding
+        )
+        result = multiples * step_decimal
+        ndigits = max(0, -step_decimal.normalize().as_tuple().exponent)
+        return result.quantize(Decimal(1).scaleb(-ndigits))
+
     def _amount_to_precision(
         self,
         symbol: str,
@@ -178,29 +212,7 @@ class ExecutionManagementSystem(ABC):
         Convert the amount to the precision of the market
         """
         market = self._market[symbol]
-        amount_decimal: Decimal = Decimal(str(amount))
-        precision = market.precision.amount
-
-        if precision >= 1:
-            exp = Decimal(int(precision))
-            precision_decimal = Decimal("1")
-        else:
-            exp = Decimal("1")
-            precision_decimal = Decimal(str(precision))
-
-        if mode == "round":
-            format_amount = (amount_decimal / exp).quantize(
-                precision_decimal, rounding=ROUND_HALF_UP
-            ) * exp
-        elif mode == "ceil":
-            format_amount = (amount_decimal / exp).quantize(
-                precision_decimal, rounding=ROUND_CEILING
-            ) * exp
-        elif mode == "floor":
-            format_amount = (amount_decimal / exp).quantize(
-                precision_decimal, rounding=ROUND_FLOOR
-            ) * exp
-        return format_amount
+        return self._quantize_step(amount, market.precision.amount, mode)
 
     def _price_to_precision(
         self,
@@ -212,30 +224,7 @@ class ExecutionManagementSystem(ABC):
         Convert the price to the precision of the market
         """
         market = self._market[symbol]
-        price_decimal: Decimal = Decimal(str(price))
-
-        decimal = market.precision.price
-
-        if decimal >= 1:
-            exp = Decimal(int(decimal))
-            precision_decimal = Decimal("1")
-        else:
-            exp = Decimal("1")
-            precision_decimal = Decimal(str(decimal))
-
-        if mode == "round":
-            format_price = (price_decimal / exp).quantize(
-                precision_decimal, rounding=ROUND_HALF_UP
-            ) * exp
-        elif mode == "ceil":
-            format_price = (price_decimal / exp).quantize(
-                precision_decimal, rounding=ROUND_CEILING
-            ) * exp
-        elif mode == "floor":
-            format_price = (price_decimal / exp).quantize(
-                precision_decimal, rounding=ROUND_FLOOR
-            ) * exp
-        return format_price
+        return self._quantize_step(price, market.precision.price, mode)
 
     @abstractmethod
     def _instrument_id_to_account_type(

{walrasquant_lib-0.4.27 → walrasquant_lib-0.4.28}/src/walrasquant/constants.py

@@ -225,6 +225,7 @@ class ExchangeType(Enum):
     BYBIT = "bybit"
     HYPERLIQUID = "hyperliquid"
     BITGET = "bitget"
+    DERIBIT = "deribit"
 
 
 class AccountType(Enum):

{walrasquant_lib-0.4.27 → walrasquant_lib-0.4.28}/src/walrasquant/exchange/__init__.py

@@ -3,6 +3,7 @@ from walrasquant.exchange.bybit import BybitAccountType
 from walrasquant.exchange.okx import OkxAccountType
 from walrasquant.exchange.hyperliquid import HyperLiquidAccountType
 from walrasquant.exchange.bitget import BitgetAccountType
+from walrasquant.exchange.deribit import DeribitAccountType
 
 __all__ = [
     "BinanceAccountType",
@@ -10,4 +11,5 @@ __all__ = [
     "OkxAccountType",
     "HyperLiquidAccountType",
     "BitgetAccountType",
+    "DeribitAccountType",
 ]

{walrasquant_lib-0.4.27 → walrasquant_lib-0.4.28}/src/walrasquant/exchange/bitget/ems.py

@@ -1,7 +1,6 @@
 from typing import Dict, cast
 from decimal import Decimal
 from typing import Literal
-from decimal import ROUND_HALF_UP, ROUND_CEILING, ROUND_FLOOR
 
 from walrasquant.constants import AccountType
 from walrasquant.schema import (
@@ -124,26 +123,11 @@ class BitgetExecutionManagementSystem(ExecutionManagementSystem):
         mode: Literal["round", "ceil", "floor"] = "round",
     ) -> Decimal:
         market = self._market[symbol]
+        # Spot amount precision is a plain ccxt step handled by the base class;
+        # derivatives quantize to the contract sizeMultiplier.
         if market.spot:
             return super()._amount_to_precision(symbol, amount, mode)
-        else:
-            amount: Decimal = Decimal(str(amount))
-            amount_multiplier = Decimal(market.info.sizeMultiplier or "1")
-            multiplier_count = amount / amount_multiplier
-
-            if mode == "round":
-                amount = (
-                    multiplier_count.quantize(Decimal("1"), rounding=ROUND_HALF_UP)
-                ) * amount_multiplier
-            elif mode == "ceil":
-                amount = (
-                    multiplier_count.quantize(Decimal("1"), rounding=ROUND_CEILING)
-                ) * amount_multiplier
-            elif mode == "floor":
-                amount = (
-                    multiplier_count.quantize(Decimal("1"), rounding=ROUND_FLOOR)
-                ) * amount_multiplier
-            return amount
+        return self._quantize_step(amount, market.info.sizeMultiplier or "1", mode)
 
     def _price_to_precision(
         self,
@@ -152,26 +136,11 @@ class BitgetExecutionManagementSystem(ExecutionManagementSystem):
         mode: Literal["round", "ceil", "floor"] = "round",
     ) -> Decimal:
         market = self._market[symbol]
+        # Spot price precision is a plain ccxt step handled by the base class;
+        # derivatives quantize to the priceEndStep tick.
         if market.spot:
             return super()._price_to_precision(symbol, price, mode)
-        else:
-            price: Decimal = Decimal(str(price))
-            price_multiplier = Decimal(market.info.priceEndStep or "1")
-            multiplier_count = price / price_multiplier
-
-            if mode == "round":
-                price = (
-                    multiplier_count.quantize(Decimal("1"), rounding=ROUND_HALF_UP)
-                ) * price_multiplier
-            elif mode == "ceil":
-                price = (
-                    multiplier_count.quantize(Decimal("1"), rounding=ROUND_CEILING)
-                ) * price_multiplier
-            elif mode == "floor":
-                price = (
-                    multiplier_count.quantize(Decimal("1"), rounding=ROUND_FLOOR)
-                ) * price_multiplier
-            return price
+        return self._quantize_step(price, market.info.priceEndStep or "1", mode)
 
     async def _cancel_all_orders(
         self, order_submit: CancelAllOrderSubmit, account_type: AccountType

walrasquant_lib-0.4.28/src/walrasquant/exchange/deribit/__init__.py

@@ -0,0 +1,26 @@
+from walrasquant.exchange.deribit.constants import DeribitAccountType
+from walrasquant.exchange.deribit.connector import (
+    DeribitPrivateConnector,
+    DeribitPublicConnector,
+)
+from walrasquant.exchange.deribit.ems import DeribitExecutionManagementSystem
+from walrasquant.exchange.deribit.exchange import DeribitExchangeManager
+from walrasquant.exchange.deribit.factory import DeribitFactory
+from walrasquant.exchange.deribit.oms import DeribitOrderManagementSystem
+
+try:
+    from walrasquant.exchange.registry import register_factory
+
+    register_factory(DeribitFactory())
+except ImportError:
+    pass
+
+__all__ = [
+    "DeribitAccountType",
+    "DeribitExchangeManager",
+    "DeribitPublicConnector",
+    "DeribitPrivateConnector",
+    "DeribitOrderManagementSystem",
+    "DeribitExecutionManagementSystem",
+    "DeribitFactory",
+]

walrasquant_lib-0.4.28/src/walrasquant/exchange/deribit/connector.py

@@ -0,0 +1,439 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+import msgspec
+
+from walrasquant.base import PrivateConnector, PublicConnector
+from walrasquant.config import OrderQueryConfig
+from walrasquant.constants import BookLevel, KlineInterval
+from walrasquant.core.cache import AsyncCache
+from walrasquant.core.entity import TaskManager
+from walrasquant.core.nautilius_core import LiveClock, MessageBus
+from walrasquant.core.registry import OrderRegistry
+from walrasquant.exchange.deribit.constants import (
+    DeribitAccountType,
+    DeribitEnumParser,
+)
+from walrasquant.exchange.deribit.exchange import DeribitExchangeManager
+from walrasquant.exchange.deribit.oms import DeribitOrderManagementSystem
+from walrasquant.exchange.deribit.rest_api import DeribitApiClient
+from walrasquant.exchange.deribit.websockets import DeribitWSClient
+from walrasquant.schema import (
+    BookL1,
+    BookL2,
+    BookOrderData,
+    IndexPrice,
+    Kline,
+    KlineList,
+    MarkPrice,
+    Ticker,
+    Trade,
+)
+
+
+class DeribitPublicConnector(PublicConnector):
+    _ws_client: DeribitWSClient
+    _api_client: DeribitApiClient
+
+    def __init__(
+        self,
+        account_type: DeribitAccountType,
+        exchange: DeribitExchangeManager,
+        msgbus: MessageBus,
+        clock: LiveClock,
+        task_manager: TaskManager,
+        custom_url: str | None = None,
+        max_subscriptions_per_client: int | None = None,
+        max_clients: int | None = None,
+        **_: Any,
+    ):
+        super().__init__(
+            account_type=account_type,
+            market=exchange.market,
+            market_id=exchange.market_id,
+            exchange_id=exchange.exchange_id,
+            ws_client=DeribitWSClient(
+                account_type=account_type,
+                handler=self._ws_msg_handler,
+                task_manager=task_manager,
+                clock=clock,
+                custom_url=custom_url,
+                max_subscriptions_per_client=max_subscriptions_per_client,
+                max_clients=max_clients,
+            ),
+            msgbus=msgbus,
+            clock=clock,
+            api_client=DeribitApiClient(clock=clock, account_type=account_type),
+            task_manager=task_manager,
+        )
+
+    def _symbols(self, symbol: str | list[str]) -> list[tuple[str, str]]:
+        requested = [symbol] if isinstance(symbol, str) else symbol
+        result = []
+        for item in requested:
+            market = self._market.get(item)
+            if market is None:
+                raise ValueError(f"Unsupported Deribit symbol: {item}")
+            result.append((item, market.id))
+        return result
+
+    def _ws_msg_handler(self, raw: bytes) -> None:
+        try:
+            message = msgspec.json.decode(raw)
+            params = message.get("params", {})
+            channel = params.get("channel", "")
+            data = params.get("data")
+            if channel.startswith("trades."):
+                self._handle_trades(data)
+            elif channel.startswith("book."):
+                self._handle_book(channel, data)
+            elif channel.startswith("chart.trades."):
+                self._handle_kline(channel, data)
+            elif channel.startswith("ticker."):
+                self._handle_ticker(data)
+        except (KeyError, TypeError, ValueError, msgspec.DecodeError) as exc:
+            self._log.error(
+                "Error handling Deribit websocket message: %s: %s", raw, exc
+            )
+
+    def _handle_trades(self, data: list[dict[str, Any]]) -> None:
+        for item in data:
+            symbol = self._market_id[item["instrument_name"]]
+            self._msgbus.publish(
+                topic="trade",
+                msg=Trade(
+                    exchange=self._exchange_id,
+                    symbol=symbol,
+                    side=DeribitEnumParser.parse_direction(item["direction"]),
+                    price=float(item["price"]),
+                    size=float(item["amount"]),
+                    timestamp=int(item["timestamp"]),
+                ),
+            )
+
+    def _handle_book(self, channel: str, data: dict[str, Any]) -> None:
+        symbol = self._market_id[data["instrument_name"]]
+        bids = [
+            BookOrderData(price=float(px), size=float(size))
+            for px, size in data["bids"]
+        ]
+        asks = [
+            BookOrderData(price=float(px), size=float(size))
+            for px, size in data["asks"]
+        ]
+        timestamp = int(data["timestamp"])
+        depth = int(channel.split(".")[-2])
+        if depth == 1:
+            if not bids or not asks:
+                return
+            self._msgbus.publish(
+                topic="bookl1",
+                msg=BookL1(
+                    exchange=self._exchange_id,
+                    symbol=symbol,
+                    bid=bids[0].price,
+                    ask=asks[0].price,
+                    bid_size=bids[0].size,
+                    ask_size=asks[0].size,
+                    timestamp=timestamp,
+                ),
+            )
+        else:
+            self._msgbus.publish(
+                topic="bookl2",
+                msg=BookL2(
+                    exchange=self._exchange_id,
+                    symbol=symbol,
+                    bids=bids,
+                    asks=asks,
+                    timestamp=timestamp,
+                ),
+            )
+
+    def _handle_kline(self, channel: str, data: dict[str, Any]) -> None:
+        instrument_name = channel.split(".")[2]
+        resolution = channel.split(".")[3]
+        symbol = self._market_id[instrument_name]
+        interval = DeribitEnumParser.parse_resolution(resolution)
+        start = int(data["tick"])
+        self._msgbus.publish(
+            topic="kline",
+            msg=Kline(
+                exchange=self._exchange_id,
+                symbol=symbol,
+                interval=interval,
+                open=float(data["open"]),
+                high=float(data["high"]),
+                low=float(data["low"]),
+                close=float(data["close"]),
+                volume=float(data["volume"]),
+                start=start,
+                timestamp=self._clock.timestamp_ms(),
+                confirm=self._clock.timestamp_ms() >= start + interval.milliseconds,
+            ),
+        )
+
+    def _handle_ticker(self, data: dict[str, Any]) -> None:
+        symbol = self._market_id[data["instrument_name"]]
+        timestamp = int(data["timestamp"])
+        mark_price = data.get("mark_price")
+        index_price = data.get("index_price")
+        if mark_price is not None:
+            self._msgbus.publish(
+                topic="mark_price",
+                msg=MarkPrice(
+                    exchange=self._exchange_id,
+                    symbol=symbol,
+                    price=float(mark_price),
+                    timestamp=timestamp,
+                ),
+            )
+        if index_price is not None:
+            self._msgbus.publish(
+                topic="index_price",
+                msg=IndexPrice(
+                    exchange=self._exchange_id,
+                    symbol=symbol,
+                    price=float(index_price),
+                    timestamp=timestamp,
+                ),
+            )
+
+    async def request_ticker(self, symbol: str) -> Ticker:
+        market = self._market.get(symbol)
+        if market is None:
+            raise ValueError(f"Unsupported Deribit symbol: {symbol}")
+        result = await self._api_client.get_book_summary_by_instrument(market.id)
+        if not result:
+            raise ValueError(f"No Deribit ticker data for {symbol}")
+        data = result[0]
+        return Ticker(
+            exchange=self._exchange_id,
+            symbol=symbol,
+            last_price=float(data.get("last") or 0),
+            timestamp=int(data["creation_timestamp"]),
+            volume=float(data.get("volume") or 0),
+            volumeCcy=float(
+                (data.get("volume") if market.inverse else data.get("volume_notional"))
+                or 0
+            ),
+        )
+
+    async def request_all_tickers(self) -> dict[str, Ticker]:
+        currencies = {market.base for market in self._market.values()}
+        result: dict[str, Ticker] = {}
+        timestamp = self._clock.timestamp_ms()
+        for currency in currencies:
+            for item in await self._api_client.get_book_summary_by_currency(currency):
+                symbol = self._market_id.get(item["instrument_name"])
+                if symbol is None:
+                    continue
+                result[symbol] = Ticker(
+                    exchange=self._exchange_id,
+                    symbol=symbol,
+                    last_price=float(item.get("last") or 0),
+                    timestamp=timestamp,
+                    volume=float(item.get("volume") or 0),
+                    volumeCcy=float(
+                        (
+                            item.get("volume")
+                            if self._market[symbol].inverse
+                            else item.get("volume_notional")
+                        )
+                        or 0
+                    ),
+                )
+        return result
+
+    async def request_klines(
+        self,
+        symbol: str,
+        interval: KlineInterval,
+        limit: int | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> KlineList:
+        market = self._market.get(symbol)
+        if market is None:
+            raise ValueError(f"Unsupported Deribit symbol: {symbol}")
+        end = end_time or self._clock.timestamp_ms()
+        count = limit or 1000
+        start = (
+            start_time
+            if start_time is not None
+            else end - count * interval.milliseconds
+        )
+        data = await self._api_client.get_chart_data(
+            market.id, DeribitEnumParser.to_resolution(interval), start, end
+        )
+        klines = []
+        for index, tick in enumerate(data.get("ticks", [])):
+            klines.append(
+                Kline(
+                    exchange=self._exchange_id,
+                    symbol=symbol,
+                    interval=interval,
+                    open=float(data["open"][index]),
+                    high=float(data["high"][index]),
+                    low=float(data["low"][index]),
+                    close=float(data["close"][index]),
+                    volume=float(data["volume"][index]),
+                    start=int(tick),
+                    timestamp=end,
+                    confirm=end >= int(tick) + interval.milliseconds,
+                )
+            )
+        if limit is not None:
+            klines = klines[-limit:]
+        return KlineList(klines)
+
+    async def request_index_klines(
+        self,
+        symbol: str,
+        interval: KlineInterval,
+        limit: int | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> KlineList:
+        raise NotImplementedError("Deribit index klines are not supported")
+
+    def subscribe_trade(self, symbol: str | list[str]):
+        self._ws_client.subscribe(
+            [f"trades.{item}.100ms" for _, item in self._symbols(symbol)]
+        )
+
+    def unsubscribe_trade(self, symbol: str | list[str]):
+        self._ws_client.unsubscribe(
+            [f"trades.{item}.100ms" for _, item in self._symbols(symbol)]
+        )
+
+    def subscribe_bookl1(self, symbol: str | list[str]):
+        self._ws_client.subscribe(
+            [f"book.{item}.none.1.100ms" for _, item in self._symbols(symbol)]
+        )
+
+    def unsubscribe_bookl1(self, symbol: str | list[str]):
+        self._ws_client.unsubscribe(
+            [f"book.{item}.none.1.100ms" for _, item in self._symbols(symbol)]
+        )
+
+    def subscribe_bookl2(self, symbol: str | list[str], level: BookLevel):
+        if level not in {BookLevel.L10, BookLevel.L20}:
+            raise ValueError(
+                f"Deribit only supports BookLevel.L10 and BookLevel.L20, got {level}"
+            )
+        self._ws_client.subscribe(
+            [
+                f"book.{item}.none.{level.value}.100ms"
+                for _, item in self._symbols(symbol)
+            ]
+        )
+
+    def unsubscribe_bookl2(self, symbol: str | list[str], level: BookLevel):
+        if level not in {BookLevel.L10, BookLevel.L20}:
+            raise ValueError(
+                f"Deribit only supports BookLevel.L10 and BookLevel.L20, got {level}"
+            )
+        self._ws_client.unsubscribe(
+            [
+                f"book.{item}.none.{level.value}.100ms"
+                for _, item in self._symbols(symbol)
+            ]
+        )
+
+    def subscribe_kline(self, symbol: str | list[str], interval: KlineInterval):
+        resolution = DeribitEnumParser.to_resolution(interval)
+        self._ws_client.subscribe(
+            [f"chart.trades.{item}.{resolution}" for _, item in self._symbols(symbol)]
+        )
+
+    def unsubscribe_kline(self, symbol: str | list[str], interval: KlineInterval):
+        resolution = DeribitEnumParser.to_resolution(interval)
+        self._ws_client.unsubscribe(
+            [f"chart.trades.{item}.{resolution}" for _, item in self._symbols(symbol)]
+        )
+
+    def subscribe_mark_price(self, symbol: str | list[str]):
+        self._subscribe_tickers(symbol)
+
+    def unsubscribe_mark_price(self, symbol: str | list[str]):
+        self._unsubscribe_tickers(symbol)
+
+    def subscribe_index_price(self, symbol: str | list[str]):
+        self._subscribe_tickers(symbol)
+
+    def unsubscribe_index_price(self, symbol: str | list[str]):
+        self._unsubscribe_tickers(symbol)
+
+    def _subscribe_tickers(self, symbol: str | list[str]):
+        self._ws_client.subscribe(
+            [f"ticker.{item}.100ms" for _, item in self._symbols(symbol)]
+        )
+
+    def _unsubscribe_tickers(self, symbol: str | list[str]):
+        self._ws_client.unsubscribe(
+            [f"ticker.{item}.100ms" for _, item in self._symbols(symbol)]
+        )
+
+    def subscribe_funding_rate(self, symbol: str | list[str]):
+        raise NotImplementedError("Deribit funding rate is not supported")
+
+    def unsubscribe_funding_rate(self, symbol: str | list[str]):
+        raise NotImplementedError("Deribit funding rate is not supported")
+
+
+class DeribitPrivateConnector(PrivateConnector):
+    def __init__(
+        self,
+        account_type: DeribitAccountType,
+        exchange: DeribitExchangeManager,
+        cache: AsyncCache,
+        registry: OrderRegistry,
+        clock: LiveClock,
+        msgbus: MessageBus,
+        task_manager: TaskManager,
+        order_query_config: OrderQueryConfig,
+        **kwargs: Any,
+    ):
+        if not exchange.api_key or not exchange.secret:
+            raise ValueError("Deribit client_id and client_secret are required")
+        api_client = DeribitApiClient(
+            clock=clock,
+            account_type=account_type,
+            api_key=exchange.api_key,
+            secret=exchange.secret,
+        )
+        oms = DeribitOrderManagementSystem(
+            account_type=account_type,
+            api_key=exchange.api_key,
+            secret=exchange.secret,
+            market=cast(dict, exchange.market),
+            market_id=exchange.market_id,
+            registry=registry,
+            cache=cache,
+            api_client=api_client,
+            exchange_id=exchange.exchange_id,
+            clock=clock,
+            msgbus=msgbus,
+            task_manager=task_manager,
+            order_query_config=order_query_config,
+        )
+        super().__init__(
+            account_type=account_type,
+            market=exchange.market,
+            api_client=api_client,
+            task_manager=task_manager,
+            oms=oms,
+        )
+
+    async def connect(self):
+        self._oms._ws_client.subscribe(
+            [
+                "user.changes.future.any.100ms",
+                "user.changes.spot.any.100ms",
+                "user.portfolio.any",
+            ]
+        )
+        await self._oms._ws_client.connect()
+        await self._oms._ws_api_client.connect()