walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/exchange/bitget/constants.py

@@ -0,0 +1,392 @@
+from enum import Enum
+from walrasquant.constants import AccountType
+from throttled.asyncio import Throttled, rate_limiter, RateLimiterType
+
+from walrasquant.constants import (
+    OrderStatus,
+    PositionSide,
+    OrderSide,
+    TimeInForce,
+    OrderType,
+    KlineInterval,
+    RateLimiter,
+)
+from walrasquant.error import KlineSupportedError
+from walrasquant.exchange.bitget.error import BitgetRateLimitError
+
+
+class BitgetAccountType(AccountType):
+    UTA = "UTA"
+    SPOT = "SPOT"
+    FUTURE = "FUTURE"
+    UTA_DEMO = "UTA_DEMO"
+    SPOT_DEMO = "SPOT_DEMO"
+    FUTURE_DEMO = "FUTURE_DEMO"
+
+    @property
+    def exchange_id(self):
+        return "bitget"
+
+    @property
+    def is_testnet(self):
+        return self in (
+            self.UTA_DEMO,
+            self.SPOT_DEMO,
+            self.FUTURE_DEMO,
+        )
+
+    @property
+    def stream_url(self):
+        version = "v3" if self.is_uta else "v2"
+        if self.is_testnet:
+            return f"wss://wspap.bitget.com/{version}/ws"
+        else:
+            return f"wss://ws.bitget.com/{version}/ws"
+
+    @property
+    def is_spot(self):
+        return self in (self.SPOT, self.SPOT_DEMO)
+
+    @property
+    def is_future(self):
+        return self in (
+            self.FUTURE,
+            self.FUTURE_DEMO,
+        )
+
+    @property
+    def is_uta(self):
+        return self in (self.UTA, self.UTA_DEMO)
+
+
+class BitgetInstType(Enum):
+    SPOT = "SPOT"
+    USDT_FUTURES = "USDT-FUTURES"
+    COIN_FUTURES = "COIN-FUTURES"
+    USDC_FUTURES = "USDC-FUTURES"
+    # SUSDT_FUTURES = "SUSD-FUTURES" # deprecated
+    # SUSDC_FUTURES = "SUSDC-FUTURES" # deprecated
+    # SCOIN_FUTURES = "SCOIN-FUTURES" # deprecated
+
+    @property
+    def is_spot(self) -> bool:
+        return self == BitgetInstType.SPOT
+
+    @property
+    def is_swap(self) -> bool:
+        return not self.is_spot
+
+    @property
+    def is_linear(self) -> bool:
+        return self in (BitgetInstType.USDT_FUTURES, BitgetInstType.USDC_FUTURES)
+
+    @property
+    def is_inverse(self) -> bool:
+        return self == BitgetInstType.COIN_FUTURES
+
+    @property
+    def is_usdc_swap(self) -> bool:
+        return self == BitgetInstType.USDC_FUTURES
+
+    @property
+    def is_usdt_swap(self) -> bool:
+        return self == BitgetInstType.USDT_FUTURES
+
+
+class BitgetUtaInstType(Enum):
+    SPOT = "spot"
+    USDT_FUTURES = "usdt-futures"
+    COIN_FUTURES = "coin-futures"
+    USDC_FUTURES = "usdc-futures"
+    UTA = "UTA"
+
+    @property
+    def is_spot(self) -> bool:
+        return self == BitgetInstType.SPOT
+
+    @property
+    def is_swap(self) -> bool:
+        return not self.is_spot
+
+    @property
+    def is_linear(self) -> bool:
+        return self in (BitgetInstType.USDT_FUTURES, BitgetInstType.USDC_FUTURES)
+
+    @property
+    def is_inverse(self) -> bool:
+        return self == BitgetInstType.COIN_FUTURES
+
+    @property
+    def is_usdc_swap(self) -> bool:
+        return self == BitgetInstType.USDC_FUTURES
+
+    @property
+    def is_usdt_swap(self) -> bool:
+        return self == BitgetInstType.USDT_FUTURES
+
+
+class BitgetKlineInterval(Enum):
+    MINUTE_1 = "1m"
+    MINUTE_5 = "5m"
+    MINUTE_15 = "15m"
+    MINUTE_30 = "30m"
+    HOUR_1 = "1H"
+    HOUR_4 = "4H"
+    HOUR_6 = "6H"
+    HOUR_12 = "12H"
+    DAY_1 = "1D"
+
+
+class BitgetOrderSide(Enum):
+    BUY = "buy"
+    SELL = "sell"
+
+
+class BitgetOrderStatus(Enum):
+    LIVE = "live"
+    NEW = "new"
+    FILLED = "filled"
+    CANCELED = "canceled"
+    CANCELLED = "cancelled"  # Alias pointing to the same value
+    PARTIALLY_FILLED = "partially_filled"
+
+
+class BitgetTimeInForce(Enum):
+    GTC = "gtc"
+    IOC = "ioc"
+    FOK = "fok"
+    POST_ONLY = "post_only"
+
+    @property
+    def is_gtc(self) -> bool:
+        return self == BitgetTimeInForce.GTC
+
+    @property
+    def is_ioc(self) -> bool:
+        return self == BitgetTimeInForce.IOC
+
+    @property
+    def is_fok(self) -> bool:
+        return self == BitgetTimeInForce.FOK
+
+    @property
+    def is_post_only(self) -> bool:
+        return self == BitgetTimeInForce.POST_ONLY
+
+
+class BitgetOrderType(Enum):
+    LIMIT = "limit"
+    MARKET = "market"
+
+    @property
+    def is_limit(self) -> bool:
+        return self == BitgetOrderType.LIMIT
+
+    @property
+    def is_market(self) -> bool:
+        return self == BitgetOrderType.MARKET
+
+
+class BitgetPositionSide(Enum):
+    LONG = "long"
+    SHORT = "short"
+    NET = "net"  # one-way mode position
+
+    @property
+    def is_long(self) -> bool:
+        return self == BitgetPositionSide.LONG
+
+    @property
+    def is_short(self) -> bool:
+        return self == BitgetPositionSide.SHORT
+
+    @property
+    def is_net(self) -> bool:
+        return self == BitgetPositionSide.NET
+
+    def parse_to_position_side(self) -> PositionSide:
+        if self == self.LONG:
+            return PositionSide.LONG
+        elif self == self.SHORT:
+            return PositionSide.SHORT
+        else:
+            return PositionSide.FLAT
+
+
+class BitgetEnumParser:
+    _kline_interval_map = {
+        BitgetKlineInterval.MINUTE_1: KlineInterval.MINUTE_1,
+        BitgetKlineInterval.MINUTE_5: KlineInterval.MINUTE_5,
+        BitgetKlineInterval.MINUTE_15: KlineInterval.MINUTE_15,
+        BitgetKlineInterval.MINUTE_30: KlineInterval.MINUTE_30,
+        BitgetKlineInterval.HOUR_1: KlineInterval.HOUR_1,
+        BitgetKlineInterval.HOUR_4: KlineInterval.HOUR_4,
+        BitgetKlineInterval.HOUR_6: KlineInterval.HOUR_6,
+        BitgetKlineInterval.HOUR_12: KlineInterval.HOUR_12,
+        BitgetKlineInterval.DAY_1: KlineInterval.DAY_1,
+    }
+
+    _order_status_map = {
+        BitgetOrderStatus.LIVE: OrderStatus.ACCEPTED,
+        BitgetOrderStatus.NEW: OrderStatus.ACCEPTED,
+        BitgetOrderStatus.FILLED: OrderStatus.FILLED,
+        BitgetOrderStatus.CANCELED: OrderStatus.CANCELED,
+        BitgetOrderStatus.CANCELLED: OrderStatus.CANCELED,  # Alias pointing to the same value
+        BitgetOrderStatus.PARTIALLY_FILLED: OrderStatus.PARTIALLY_FILLED,
+    }
+
+    _order_side_map = {
+        BitgetOrderSide.BUY: OrderSide.BUY,
+        BitgetOrderSide.SELL: OrderSide.SELL,
+    }
+
+    _time_in_force_map = {
+        BitgetTimeInForce.GTC: TimeInForce.GTC,
+        BitgetTimeInForce.IOC: TimeInForce.IOC,
+        BitgetTimeInForce.FOK: TimeInForce.FOK,
+    }
+
+    _order_type_map = {
+        BitgetOrderType.LIMIT: OrderType.LIMIT,
+        BitgetOrderType.MARKET: OrderType.MARKET,
+    }
+
+    _kline_interval_to_bitget_map = {v: k for k, v in _kline_interval_map.items()}
+    _order_side_to_bitget_map = {v: k for k, v in _order_side_map.items()}
+    _time_in_force_to_bitget_map = {v: k for k, v in _time_in_force_map.items()}
+
+    @classmethod
+    def parse_kline_interval(cls, interval: BitgetKlineInterval) -> KlineInterval:
+        return cls._kline_interval_map[interval]
+
+    @classmethod
+    def to_bitget_kline_interval(cls, interval: KlineInterval) -> BitgetKlineInterval:
+        bitget_interval = cls._kline_interval_to_bitget_map.get(interval)
+        if bitget_interval is None:
+            raise KlineSupportedError(
+                f"Unsupported KlineInterval: {interval}. Supported intervals: {list(cls._kline_interval_to_bitget_map.keys())}"
+            )
+        return bitget_interval
+
+    @classmethod
+    def parse_order_status(cls, status: BitgetOrderStatus) -> OrderStatus:
+        # we do not care the UTA account NEW order status, so we ignore it
+        # ref: https://www.bitget.com/zh-CN/api-doc/uta/websocket/private/Order-Channel
+        order_status = cls._order_status_map.get(status)
+        if order_status is None:
+            raise ValueError(f"Unsupported Bitget order status: {status}")
+        return order_status
+
+    @classmethod
+    def parse_order_side(cls, side: BitgetOrderSide) -> OrderSide:
+        return cls._order_side_map[side]
+
+    @classmethod
+    def to_bitget_order_side(cls, side: OrderSide) -> BitgetOrderSide:
+        return cls._order_side_to_bitget_map[side]
+
+    @classmethod
+    def parse_time_in_force(cls, tif: BitgetTimeInForce) -> TimeInForce:
+        return cls._time_in_force_map[tif]
+
+    @classmethod
+    def to_bitget_time_in_force(cls, tif: TimeInForce) -> BitgetTimeInForce:
+        return cls._time_in_force_to_bitget_map[tif]
+
+    @classmethod
+    def parse_order_type(cls, order_type: BitgetOrderType) -> OrderType:
+        return cls._order_type_map[order_type]
+
+
+class BitgetRateLimiter(RateLimiter):
+    def __init__(self, enable_rate_limit: bool = True):
+        self._enabled = enable_rate_limit
+        self._global_ip = Throttled(
+            quota=rate_limiter.per_min(6000),
+            timeout=-1,
+            using=RateLimiterType.FIXED_WINDOW.value,
+        )
+        self._throttled: dict[str, Throttled] = {
+            "/api/v2/mix/order/place-order": Throttled(
+                quota=rate_limiter.per_sec(10),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v2/spot/trade/place-order": Throttled(
+                quota=rate_limiter.per_sec(10),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v2/mix/order/cancel-order": Throttled(
+                quota=rate_limiter.per_sec(10),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v2/spot/trade/cancel-order": Throttled(
+                quota=rate_limiter.per_sec(10),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v3/trade/place-order": Throttled(
+                quota=rate_limiter.per_sec(10),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v3/trade/cancel-order": Throttled(
+                quota=rate_limiter.per_sec(10),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v3/trade/cancel-symbol-order": Throttled(
+                quota=rate_limiter.per_sec(5),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+        }
+        self._query = Throttled(
+            quota=rate_limiter.per_sec(20),
+            timeout=-1,
+            using=RateLimiterType.FIXED_WINDOW.value,
+        )
+
+    @staticmethod
+    def _raise_if_limited(
+        result, message: str, scope: str, endpoint: str | None = None
+    ):
+        if result.limited:
+            raise BitgetRateLimitError(
+                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=60)
+        self._raise_if_limited(result, "Bitget 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"Bitget query rate limit exceeded: {endpoint}",
+            scope="uid",
+            endpoint=endpoint,
+        )
+
+    async def order_limit(self, endpoint: str, cost: int = 1):
+        if not self._enabled:
+            return
+        result = await self._throttled[endpoint].limit(
+            key=endpoint, cost=cost, timeout=-1
+        )
+        self._raise_if_limited(
+            result,
+            f"Bitget order rate limit exceeded: {endpoint}",
+            scope="uid",
+            endpoint=endpoint,
+        )

walrasquant/exchange/bitget/ems.py

@@ -0,0 +1,202 @@
+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 (
+    InstrumentId,
+    CancelAllOrderSubmit,
+    CancelOrderSubmit,
+    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.bitget import BitgetAccountType
+from walrasquant.exchange.bitget.schema import BitgetMarket
+from walrasquant.base import ExecutionManagementSystem
+from walrasquant.base.ems import PriorityOrderQueue
+
+
+class BitgetExecutionManagementSystem(ExecutionManagementSystem):
+    _market: Dict[str, BitgetMarket]
+
+    def __init__(
+        self,
+        market: Dict[str, BitgetMarket],
+        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._bitget_futures_account_type: BitgetAccountType | None = None
+        self._bitget_spot_account_type: BitgetAccountType | None = None
+        self._bitget_uta_account_type: BitgetAccountType | None = None
+
+    def _build_order_submit_queues(self):
+        for account_type in self._private_connectors.keys():
+            if isinstance(account_type, BitgetAccountType):
+                self._order_submit_queues[account_type] = PriorityOrderQueue(
+                    maxsize=self._queue_maxsize
+                )
+
+    def _set_account_type(self):
+        account_types = self._private_connectors.keys()
+
+        if (
+            BitgetAccountType.UTA_DEMO in account_types
+            or BitgetAccountType.UTA in account_types
+        ):
+            self._bitget_uta_account_type = (
+                BitgetAccountType.UTA_DEMO
+                if BitgetAccountType.UTA_DEMO in account_types
+                else BitgetAccountType.UTA
+            )
+            return
+
+        self._bitget_futures_account_type = (
+            BitgetAccountType.FUTURE_DEMO
+            if BitgetAccountType.FUTURE_DEMO in account_types
+            else BitgetAccountType.FUTURE
+        )
+
+        self._bitget_spot_account_type = (
+            BitgetAccountType.SPOT_DEMO
+            if BitgetAccountType.SPOT_DEMO in account_types
+            else BitgetAccountType.SPOT
+        )
+
+    def _instrument_id_to_account_type(
+        self, instrument_id: InstrumentId
+    ) -> AccountType:
+        if self._bitget_uta_account_type:
+            return self._bitget_uta_account_type
+        if instrument_id.is_spot:
+            account_type = self._bitget_spot_account_type
+        elif instrument_id.is_linear or instrument_id.is_inverse:
+            account_type = self._bitget_futures_account_type
+        else:
+            raise ValueError(f"Unsupported instrument type: {instrument_id.type}")
+
+        if account_type is None:
+            raise ValueError(f"No Bitget account type configured for {instrument_id}")
+        return account_type
+
+    def _get_min_order_amount(
+        self, symbol: str, market: BaseMarket, px: float
+    ) -> Decimal:
+        bitget_market = cast(BitgetMarket, market)
+        if bitget_market.spot:
+            min_trade_usdt = bitget_market.info.minTradeUSDT or "0"
+            min_order_cost = float(min_trade_usdt)
+            min_order_amount = min_order_cost * 1.01 / px
+        else:
+            min_trade_num = bitget_market.info.minTradeNum or "0"
+            min_trade_usdt = bitget_market.info.minTradeUSDT or "0"
+            min_order_amt = float(min_trade_num)
+            min_order_cost = float(min_trade_usdt)
+            min_order_amount = max(min_order_cost * 1.02 / px, min_order_amt)
+        min_order_amount = self._amount_to_precision(
+            symbol, min_order_amount, mode="ceil"
+        )
+        return min_order_amount
+
+    def _amount_to_precision(
+        self,
+        symbol: str,
+        amount: float,
+        mode: Literal["round", "ceil", "floor"] = "round",
+    ) -> Decimal:
+        market = self._market[symbol]
+        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
+
+    def _price_to_precision(
+        self,
+        symbol: str,
+        price: float,
+        mode: Literal["round", "ceil", "floor"] = "round",
+    ) -> Decimal:
+        market = self._market[symbol]
+        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
+
+    async def _cancel_all_orders(
+        self, order_submit: CancelAllOrderSubmit, account_type: AccountType
+    ) -> None:
+        # override the base method
+        if isinstance(account_type, BitgetAccountType) and account_type.is_uta:
+            await super()._cancel_all_orders(order_submit, account_type)
+        else:
+            symbol = order_submit.symbol
+            await self._cache.wait_for_inflight_orders(symbol)
+            oids = self._cache.get_open_orders(symbol)
+            for oid in oids:
+                cancel_submit = CancelOrderSubmit(
+                    symbol=symbol,
+                    instrument_id=InstrumentId.from_str(symbol),
+                    oid=oid,
+                )
+                await self._cancel_order_ws(cancel_submit, account_type)
+
+    def _get_max_order_amount(
+        self, symbol: str, market: BaseMarket, is_market: bool, px: float
+    ) -> Decimal:
+        if market.spot:
+            return Decimal("Infinity")
+        else:
+            bybit_market = cast(BitgetMarket, market)
+            if is_market:
+                return Decimal(bybit_market.info.maxMarketOrderQty or "Infinity")
+            else:
+                return Decimal(bybit_market.info.maxOrderQty or "Infinity")

walrasquant/exchange/bitget/error.py

@@ -0,0 +1,36 @@
+class BitgetError(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 BitgetRateLimitError(Exception):
+    """
+    Raised when Bitget 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