walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/exchange/bybit/constants.py

@@ -0,0 +1,479 @@
+from datetime import timedelta
+from throttled.asyncio import Throttled, rate_limiter, RateLimiterType
+from throttled import Throttled as ThrottledSync
+
+from walrasquant.constants import (
+    AccountType,
+    OrderStatus,
+    PositionSide,
+    OrderSide,
+    TimeInForce,
+    OrderType,
+    KlineInterval,
+    RateLimiter,
+    TriggerType,
+)
+from enum import Enum
+from walrasquant.error import KlineSupportedError
+from walrasquant.exchange.bybit.error import BybitRateLimitError
+
+
+class BybitOpType(Enum):
+    AUTH = "auth"
+    PING = "ping"
+    PONG = "pong"
+    ORDER_CREATE = "order.create"
+    ORDER_AMEND = "order.amend"
+    ORDER_CANCEL = "order.cancel"
+    ORDER_CREATE_BATCH = "order.create-batch"
+    ORDER_AMEND_BATCH = "order.amend-batch"
+    ORDER_CANCEL_BATCH = "order.cancel-batch"
+
+
+class BybitKlineInterval(Enum):
+    MINUTE_1 = "1"
+    MINUTE_3 = "3"
+    MINUTE_5 = "5"
+    MINUTE_15 = "15"
+    MINUTE_30 = "30"
+    HOUR_1 = "60"
+    HOUR_2 = "120"
+    HOUR_4 = "240"
+    HOUR_6 = "360"
+    HOUR_12 = "720"
+    DAY_1 = "D"
+    WEEK_1 = "W"
+    MONTH_1 = "M"
+
+
+class BybitAccountType(AccountType):
+    SPOT = "SPOT"
+    LINEAR = "LINEAR"
+    INVERSE = "INVERSE"
+    OPTION = "OPTION"
+    SPOT_TESTNET = "SPOT_TESTNET"
+    LINEAR_TESTNET = "LINEAR_TESTNET"
+    INVERSE_TESTNET = "INVERSE_TESTNET"
+    OPTION_TESTNET = "OPTION_TESTNET"
+    UNIFIED = "UNIFIED"
+    UNIFIED_TESTNET = "UNIFIED_TESTNET"
+
+    @property
+    def exchange_id(self):
+        return "bybit"
+
+    @property
+    def is_testnet(self):
+        return self in {
+            self.SPOT_TESTNET,
+            self.LINEAR_TESTNET,
+            self.INVERSE_TESTNET,
+            self.OPTION_TESTNET,
+            self.UNIFIED_TESTNET,
+        }
+
+    @property
+    def ws_public_url(self):
+        return WS_PUBLIC_URL[self]
+
+    @property
+    def ws_private_url(self):
+        if self.is_testnet:
+            return "wss://stream-testnet.bybit.com/v5/private"
+        return "wss://stream.bybit.com/v5/private"
+
+    @property
+    def ws_api_url(self):
+        if self.is_testnet:
+            return "wss://stream-testnet.bybit.com/v5/trade"
+        return "wss://stream.bybit.com/v5/trade"
+
+    @property
+    def is_spot(self):
+        return self in {self.SPOT, self.SPOT_TESTNET}
+
+    @property
+    def is_linear(self):
+        return self in {self.LINEAR, self.LINEAR_TESTNET}
+
+    @property
+    def is_inverse(self):
+        return self in {self.INVERSE, self.INVERSE_TESTNET}
+
+
+WS_PUBLIC_URL = {
+    BybitAccountType.SPOT: "wss://stream.bybit.com/v5/public/spot",
+    BybitAccountType.LINEAR: "wss://stream.bybit.com/v5/public/linear",
+    BybitAccountType.INVERSE: "wss://stream.bybit.com/v5/public/inverse",
+    BybitAccountType.OPTION: "wss://stream.bybit.com/v5/public/option",
+    BybitAccountType.SPOT_TESTNET: "wss://stream-testnet.bybit.com/v5/public/spot",
+    BybitAccountType.LINEAR_TESTNET: "wss://stream-testnet.bybit.com/v5/public/linear",
+    BybitAccountType.INVERSE_TESTNET: "wss://stream-testnet.bybit.com/v5/public/inverse",
+    BybitAccountType.OPTION_TESTNET: "wss://stream-testnet.bybit.com/v5/public/option",
+}
+
+
+class BybitBaseUrl(Enum):
+    MAINNET_1 = "MAINNET_1"
+    MAINNET_2 = "MAINNET_2"
+    TESTNET = "TESTNET"
+    NETHERLAND = "NETHERLAND"
+    HONGKONG = "HONGKONG"
+    TURKEY = "TURKEY"
+    HAZAKHSTAN = "HAZAKHSTAN"
+
+    @property
+    def base_url(self):
+        return REST_API_URL[self]
+
+
+REST_API_URL = {
+    BybitBaseUrl.MAINNET_1: "https://api.bybit.com",
+    BybitBaseUrl.MAINNET_2: "https://api.bytick.com",
+    BybitBaseUrl.TESTNET: "https://api-testnet.bybit.com",
+    BybitBaseUrl.NETHERLAND: "https://api.bybit.nl",
+    BybitBaseUrl.HONGKONG: "https://api.byhkbit.com",
+    BybitBaseUrl.TURKEY: "https://api.bybit-tr.com",
+    BybitBaseUrl.HAZAKHSTAN: "https://api.bybit.kz",
+}
+
+
+class BybitOrderSide(Enum):
+    BUY = "Buy"
+    SELL = "Sell"
+
+
+class BybitOrderStatus(Enum):
+    NEW = "New"
+    REJECTED = "Rejected"
+    PARTIALLY_FILLED = "PartiallyFilled"
+    PARTIALLY_FILLED_CANCELED = "PartiallyFilledCanceled"
+    FILLED = "Filled"
+    CANCELED = "Cancelled"
+    UNTRIGGERED = "Untriggered"
+    TRIGGERED = "Triggered"
+    DEACTIVATED = "Deactivated"
+
+
+class BybitTimeInForce(Enum):
+    GTC = "GTC"
+    IOC = "IOC"
+    FOK = "FOK"
+    POST_ONLY = "PostOnly"
+
+
+class BybitPositionIdx(Enum):
+    FLAT = 0
+    LONG = 1
+    SHORT = 2
+
+    def is_one_way_mode(self):
+        return self == self.FLAT
+
+
+class BybitPositionSide(Enum):
+    FLAT = ""
+    BUY = "Buy"
+    SELL = "Sell"
+
+    def parse_to_position_side(self) -> PositionSide:
+        if self == self.FLAT:
+            return PositionSide.FLAT
+        elif self == self.BUY:
+            return PositionSide.LONG
+        elif self == self.SELL:
+            return PositionSide.SHORT
+        raise RuntimeError(f"Invalid position side: {self}")
+
+
+class BybitOrderType(Enum):
+    MARKET = "Market"
+    LIMIT = "Limit"
+    UNKNOWN = "Unknown"
+
+
+class BybitProductType(Enum):
+    SPOT = "spot"
+    LINEAR = "linear"
+    INVERSE = "inverse"
+    OPTION = "option"
+
+    @property
+    def is_spot(self):
+        return self == self.SPOT
+
+    @property
+    def is_linear(self):
+        return self == self.LINEAR
+
+    @property
+    def is_inverse(self):
+        return self == self.INVERSE
+
+    @property
+    def is_option(self):
+        return self == self.OPTION
+
+
+class BybitTriggerType(Enum):
+    NONE = ""  # Default
+    LAST_PRICE = "LastPrice"
+    INDEX_PRICE = "IndexPrice"
+    MARK_PRICE = "MarkPrice"
+
+
+class BybitTriggerDirection(Enum):
+    NONE = 0
+    RISES_TO = 1  # Triggered when market price rises to triggerPrice
+    FALLS_TO = 2
+
+
+class BybitStopOrderType(Enum):
+    NONE = ""  # Default
+    UNKNOWN = "UNKNOWN"  # Classic account value
+    TAKE_PROFIT = "TakeProfit"
+    STOP_LOSS = "StopLoss"
+    TRAILING_STOP = "TrailingStop"
+    STOP = "Stop"
+    PARTIAL_TAKE_PROFIT = "PartialTakeProfit"
+    PARTIAL_STOP_LOSS = "PartialStopLoss"
+    TPSL_ORDER = "tpslOrder"
+    OCO_ORDER = "OcoOrder"  # Spot only
+    MM_RATE_CLOSE = "MmRateClose"
+    BIDIRECTIONAL_TPSL_ORDER = "BidirectionalTpslOrder"
+
+
+class BybitEnumParser:
+    _bybit_kline_interval_map = {
+        BybitKlineInterval.MINUTE_1: KlineInterval.MINUTE_1,
+        BybitKlineInterval.MINUTE_3: KlineInterval.MINUTE_3,
+        BybitKlineInterval.MINUTE_5: KlineInterval.MINUTE_5,
+        BybitKlineInterval.MINUTE_15: KlineInterval.MINUTE_15,
+        BybitKlineInterval.MINUTE_30: KlineInterval.MINUTE_30,
+        BybitKlineInterval.HOUR_1: KlineInterval.HOUR_1,
+        BybitKlineInterval.HOUR_2: KlineInterval.HOUR_2,
+        BybitKlineInterval.HOUR_4: KlineInterval.HOUR_4,
+        BybitKlineInterval.HOUR_6: KlineInterval.HOUR_6,
+        BybitKlineInterval.HOUR_12: KlineInterval.HOUR_12,
+        BybitKlineInterval.DAY_1: KlineInterval.DAY_1,
+        BybitKlineInterval.WEEK_1: KlineInterval.WEEK_1,
+        BybitKlineInterval.MONTH_1: KlineInterval.MONTH_1,
+    }
+
+    _bybit_order_status_map = {
+        BybitOrderStatus.NEW: OrderStatus.ACCEPTED,
+        BybitOrderStatus.PARTIALLY_FILLED: OrderStatus.PARTIALLY_FILLED,
+        BybitOrderStatus.PARTIALLY_FILLED_CANCELED: OrderStatus.CANCELED,
+        BybitOrderStatus.FILLED: OrderStatus.FILLED,
+        BybitOrderStatus.CANCELED: OrderStatus.CANCELED,
+        BybitOrderStatus.TRIGGERED: OrderStatus.ACCEPTED,
+        BybitOrderStatus.UNTRIGGERED: OrderStatus.PENDING,
+        BybitOrderStatus.DEACTIVATED: OrderStatus.EXPIRED,
+        BybitOrderStatus.REJECTED: OrderStatus.FAILED,
+    }
+
+    _bybit_position_side_map = {
+        BybitPositionIdx.FLAT: PositionSide.FLAT,
+        BybitPositionIdx.LONG: PositionSide.LONG,
+        BybitPositionIdx.SHORT: PositionSide.SHORT,
+    }
+
+    _bybit_order_side_map = {
+        BybitOrderSide.BUY: OrderSide.BUY,
+        BybitOrderSide.SELL: OrderSide.SELL,
+    }
+
+    _bybit_order_time_in_force_map = {
+        BybitTimeInForce.IOC: TimeInForce.IOC,
+        BybitTimeInForce.GTC: TimeInForce.GTC,
+        BybitTimeInForce.FOK: TimeInForce.FOK,
+        BybitTimeInForce.POST_ONLY: TimeInForce.GTC,
+    }
+
+    _bybit_order_type_map = {
+        BybitOrderType.MARKET: OrderType.MARKET,
+        BybitOrderType.LIMIT: OrderType.LIMIT,
+    }
+
+    _bybit_trigger_type_map = {
+        BybitTriggerType.LAST_PRICE: TriggerType.LAST_PRICE,
+        BybitTriggerType.INDEX_PRICE: TriggerType.INDEX_PRICE,
+        BybitTriggerType.MARK_PRICE: TriggerType.MARK_PRICE,
+    }
+
+    # Add reverse mapping dictionaries
+    _order_status_to_bybit_map = {v: k for k, v in _bybit_order_status_map.items()}
+    # Ensure CANCELED maps to the right status
+    _order_status_to_bybit_map[OrderStatus.CANCELED] = BybitOrderStatus.CANCELED
+    _position_side_to_bybit_map = {v: k for k, v in _bybit_position_side_map.items()}
+    _order_side_to_bybit_map = {v: k for k, v in _bybit_order_side_map.items()}
+    _time_in_force_to_bybit_map = {
+        v: k for k, v in _bybit_order_time_in_force_map.items()
+    }
+    _time_in_force_to_bybit_map[TimeInForce.GTC] = BybitTimeInForce.GTC
+    _order_type_to_bybit_map = {
+        v: k for k, v in _bybit_order_type_map.items() if v is not None
+    }
+    _kline_interval_to_bybit_map = {
+        v: k for k, v in _bybit_kline_interval_map.items() if v is not None
+    }
+    _trigger_type_to_bybit_map = {
+        v: k for k, v in _bybit_trigger_type_map.items() if v is not None
+    }
+
+    @classmethod
+    def parse_trigger_type(cls, trigger_type: BybitTriggerType) -> TriggerType:
+        return cls._bybit_trigger_type_map[trigger_type]
+
+    @classmethod
+    def parse_kline_interval(cls, interval: BybitKlineInterval) -> KlineInterval:
+        return cls._bybit_kline_interval_map[interval]
+
+    # Add reverse parsing methods
+    @classmethod
+    def parse_order_status(cls, status: BybitOrderStatus) -> OrderStatus:
+        return cls._bybit_order_status_map[status]
+
+    @classmethod
+    def parse_position_side(cls, side: BybitPositionIdx) -> PositionSide:
+        return cls._bybit_position_side_map[side]
+
+    @classmethod
+    def parse_order_side(cls, side: BybitOrderSide) -> OrderSide:
+        return cls._bybit_order_side_map[side]
+
+    @classmethod
+    def parse_time_in_force(cls, tif: BybitTimeInForce) -> TimeInForce:
+        return cls._bybit_order_time_in_force_map[tif]
+
+    @classmethod
+    def parse_order_type(
+        cls, order_type: BybitOrderType, time_in_force: TimeInForce | None = None
+    ) -> OrderType:
+        if time_in_force == BybitTimeInForce.POST_ONLY:
+            return OrderType.POST_ONLY
+        return cls._bybit_order_type_map[order_type]
+
+    @classmethod
+    def to_bybit_order_status(cls, status: OrderStatus) -> BybitOrderStatus:
+        return cls._order_status_to_bybit_map[status]
+
+    @classmethod
+    def to_bybit_position_side(cls, side: PositionSide) -> BybitPositionIdx:
+        return cls._position_side_to_bybit_map[side]
+
+    @classmethod
+    def to_bybit_order_side(cls, side: OrderSide) -> BybitOrderSide:
+        return cls._order_side_to_bybit_map[side]
+
+    @classmethod
+    def to_bybit_time_in_force(cls, tif: TimeInForce) -> BybitTimeInForce:
+        return cls._time_in_force_to_bybit_map[tif]
+
+    @classmethod
+    def to_bybit_order_type(cls, order_type: OrderType) -> BybitOrderType:
+        return cls._order_type_to_bybit_map[order_type]
+
+    @classmethod
+    def to_bybit_kline_interval(cls, interval: KlineInterval) -> BybitKlineInterval:
+        if interval not in cls._kline_interval_to_bybit_map:
+            raise KlineSupportedError(
+                f"Kline interval {interval} is not supported by Bybit"
+            )
+        return cls._kline_interval_to_bybit_map[interval]
+
+    @classmethod
+    def to_bybit_trigger_type(cls, trigger_type: TriggerType) -> BybitTriggerType:
+        return cls._trigger_type_to_bybit_map[trigger_type]
+
+
+class BybitRateLimiter(RateLimiter):
+    def __init__(self, enable_rate_limit: bool = True):
+        self._enabled = enable_rate_limit
+        self._global_ip = Throttled(
+            quota=rate_limiter.per_duration(timedelta(seconds=5), limit=600),
+            timeout=-1,
+            using=RateLimiterType.GCRA.value,
+        )
+        self._spot_order = Throttled(
+            quota=rate_limiter.per_sec(20),
+            timeout=-1,
+            using=RateLimiterType.GCRA.value,
+        )
+        self._futures_order = Throttled(
+            quota=rate_limiter.per_sec(10),
+            timeout=-1,
+            using=RateLimiterType.GCRA.value,
+        )
+        self._query = Throttled(
+            quota=rate_limiter.per_sec(50),
+            timeout=-1,
+            using=RateLimiterType.GCRA.value,
+        )
+        self._public = Throttled(
+            quota=rate_limiter.per_duration(timedelta(seconds=5), limit=600),
+            timeout=-1,
+            using=RateLimiterType.GCRA.value,
+        )
+
+    @staticmethod
+    def _raise_if_limited(
+        result, message: str, scope: str, endpoint: str | None = None
+    ):
+        if result.limited:
+            raise BybitRateLimitError(
+                message,
+                retry_after=result.state.retry_after,
+                scope=scope,
+                endpoint=endpoint,
+            )
+
+    async def ip_limit(self):
+        if not self._enabled:
+            return
+        result = await self._global_ip.limit(key="ip", cost=1, timeout=5)
+        self._raise_if_limited(result, "Bybit IP rate limit exceeded", scope="ip")
+
+    async def query_limit(self, endpoint: str, cost: int = 1):
+        if not self._enabled:
+            return
+        result = await self._query.limit(key=endpoint, cost=cost, timeout=1)
+        self._raise_if_limited(
+            result,
+            f"Bybit query rate limit exceeded: {endpoint}",
+            scope="uid",
+            endpoint=endpoint,
+        )
+
+    async def public_limit(self, endpoint: str, cost: int = 1):
+        if not self._enabled:
+            return
+        result = await self._public.limit(key=endpoint, cost=cost, timeout=5)
+        self._raise_if_limited(
+            result,
+            f"Bybit public rate limit exceeded: {endpoint}",
+            scope="ip",
+            endpoint=endpoint,
+        )
+
+    async def order_limit(self, category: str, endpoint: str, cost: int = 1):
+        if not self._enabled:
+            return
+        if category == "spot":
+            result = await self._spot_order.limit(key=endpoint, cost=cost, timeout=-1)
+            self._raise_if_limited(
+                result,
+                f"Bybit spot order rate limit exceeded: {endpoint}",
+                scope="uid",
+                endpoint=endpoint,
+            )
+        else:
+            result = await self._futures_order.limit(
+                key=endpoint, cost=cost, timeout=-1
+            )
+            self._raise_if_limited(
+                result,
+                f"Bybit futures order rate limit exceeded: {endpoint}",
+                scope="uid",
+                endpoint=endpoint,
+            )

walrasquant/exchange/bybit/ems.py

@@ -0,0 +1,93 @@
+from typing import Dict, cast
+from decimal import Decimal
+from walrasquant.constants import AccountType
+from walrasquant.schema import InstrumentId, BaseMarket
+from walrasquant.core.cache import AsyncCache
+from walrasquant.core.nautilius_core import MessageBus, LiveClock
+from walrasquant.core.entity import TaskManager
+from walrasquant.core.registry import OrderRegistry
+from walrasquant.exchange.bybit import BybitAccountType
+from walrasquant.exchange.bybit.schema import BybitMarket
+from walrasquant.base import ExecutionManagementSystem
+from walrasquant.base.ems import PriorityOrderQueue
+
+
+class BybitExecutionManagementSystem(ExecutionManagementSystem):
+    _market: Dict[str, BybitMarket]
+
+    def __init__(
+        self,
+        market: Dict[str, BybitMarket],
+        cache: AsyncCache,
+        msgbus: MessageBus,
+        clock: LiveClock,
+        task_manager: TaskManager,
+        registry: OrderRegistry,
+        queue_maxsize: int = 100_000,
+    ):
+        super().__init__(
+            market=market,
+            cache=cache,
+            msgbus=msgbus,
+            clock=clock,
+            task_manager=task_manager,
+            registry=registry,
+            queue_maxsize=queue_maxsize,
+        )
+        self._bybit_account_type: BybitAccountType | None = None
+
+    def _build_order_submit_queues(self):
+        # if not self._private_connectors:
+        #     raise RuntimeError(
+        #         "No private connectors found for building order submit queues."
+        #     )
+        for account_type in self._private_connectors.keys():
+            if isinstance(account_type, BybitAccountType):
+                self._order_submit_queues[account_type] = PriorityOrderQueue(
+                    maxsize=self._queue_maxsize
+                )
+
+    def _set_account_type(self):
+        # if not self._private_connectors:
+        #     raise RuntimeError(
+        #         "No private connectors found for setting account type."
+        #     )
+        account_types = self._private_connectors.keys()
+        self._bybit_account_type = (
+            BybitAccountType.UNIFIED_TESTNET
+            if BybitAccountType.UNIFIED_TESTNET in account_types
+            else BybitAccountType.UNIFIED
+        )
+
+    def _instrument_id_to_account_type(
+        self, instrument_id: InstrumentId
+    ) -> AccountType:
+        if self._bybit_account_type is None:
+            raise ValueError("No Bybit account type configured")
+        return self._bybit_account_type
+
+    def _get_min_order_amount(
+        self, symbol: str, market: BaseMarket, px: float
+    ) -> Decimal:
+        bybit_market = cast(BybitMarket, market)
+        lot_size_filter = bybit_market.info.lotSizeFilter
+        if lot_size_filter is None:
+            raise ValueError(f"Missing lotSizeFilter for {symbol}")
+        min_order_qty = float(lot_size_filter.minOrderQty or "0")
+        min_order_amt = float(
+            lot_size_filter.minOrderAmt or lot_size_filter.minNotionalValue or "0"
+        )
+        min_order_amount = max(min_order_amt * 1.02 / px, min_order_qty)
+        min_order_amount = self._amount_to_precision(
+            symbol, min_order_amount, mode="ceil"
+        )
+        return min_order_amount
+
+    def _get_max_order_amount(
+        self, symbol: str, market: BaseMarket, is_market: bool, px: float
+    ) -> Decimal:
+        bybit_market = cast(BybitMarket, market)
+        if is_market:
+            return Decimal(bybit_market.info.lotSizeFilter.maxMktOrderQty or "Infinity")
+        else:
+            return Decimal(bybit_market.info.lotSizeFilter.maxOrderQty or "Infinity")

walrasquant/exchange/bybit/error.py

@@ -0,0 +1,36 @@
+class BybitError(Exception):
+    """
+    Represents Bybit specific errors.
+    """
+
+    def __init__(
+        self,
+        code: int | None,
+        message: str | None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(code={self.code}, message='{self.message}')"
+
+    __str__ = __repr__
+
+
+class BybitRateLimitError(Exception):
+    """
+    Raised when Bybit API rate limit is exceeded.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        retry_after: float = 0.0,
+        scope: str | None = None,
+        endpoint: str | None = None,
+    ):
+        super().__init__(message)
+        self.retry_after = retry_after
+        self.scope = scope
+        self.endpoint = endpoint