walrasquant-lib 0.5.0__tar.gz → 0.5.2__tar.gz

{walrasquant_lib-0.5.0 → walrasquant_lib-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: walrasquant-lib
-Version: 0.5.0
+Version: 0.5.2
 Summary: fastest python trading bot
 Author: River-Shi
 Author-email: River-Shi <nachuan.shi.quant@gmail.com>
@@ -30,6 +30,7 @@ Requires-Dist: msgspec>=0.21.1
 Requires-Dist: pandas<3.0.0
 Requires-Dist: numpy>=2.2.0
 Requires-Dist: ccxt>=4.5.64
+Requires-Dist: aiofastnet>=0.21.0
 Requires-Python: >=3.11, <3.15
 Description-Content-Type: text/markdown
 

{walrasquant_lib-0.5.0 → walrasquant_lib-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walrasquant-lib"
-version = "0.5.0"
+version = "0.5.2"
 description = "fastest python trading bot"
 authors = [
     {name = "River-Shi",email = "nachuan.shi.quant@gmail.com"}
@@ -34,6 +34,7 @@ dependencies = [
     "pandas<3.0.0",
     "numpy>=2.2.0",
     "ccxt>=4.5.64",
+    "aiofastnet>=0.21.0",
 ]
 
 [project.scripts]

{walrasquant_lib-0.5.0 → walrasquant_lib-0.5.2}/src/walrasquant/base/oms.py

@@ -513,7 +513,7 @@ class OrderManagementSystem(ABC):
         pass
 
     @abstractmethod
-    async def cancel_batch_orders(self, orders: List[CancelOrderSubmit]) -> None:
+    async def cancel_batch_orders(self, orders: List[CancelOrderSubmit]) -> bool | None:
         """Cancel multiple orders in a single batch request"""
         pass
 

{walrasquant_lib-0.5.0 → walrasquant_lib-0.5.2}/src/walrasquant/exchange/bitget/connector.py

@@ -12,11 +12,11 @@ from walrasquant.schema import (
     BookL1,
     Trade,
     Kline,
-    # BookL2,
-    # BookOrderData,
-    # FundingRate,
-    # IndexPrice,
-    # MarkPrice,
+    BookL2,
+    BookOrderData,
+    FundingRate,
+    IndexPrice,
+    MarkPrice,
     KlineList,
     Ticker,
 )
@@ -31,6 +31,8 @@ from walrasquant.exchange.bitget.schema import (
     BitgetBooks1WsMsg,
     BitgetWsTradeWsMsg,
     BitgetWsCandleWsMsg,
+    BitgetBooksWsMsg,
+    BitgetWsTickerWsMsg,
 )
 from walrasquant.exchange.bitget.rest_api import BitgetApiClient
 from walrasquant.exchange.bitget.websockets import BitgetWSClient
@@ -48,6 +50,7 @@ from walrasquant.exchange.bitget.exchange import BitgetExchangeManager
 class BitgetPublicConnector(PublicConnector):
     _uta_inst_type_map = {
         BitgetUtaInstType.SPOT: "spot",
+        BitgetUtaInstType.MARGIN: "spot",
         BitgetUtaInstType.USDC_FUTURES: "linear",
         BitgetUtaInstType.USDT_FUTURES: "linear",
         BitgetUtaInstType.COIN_FUTURES: "inverse",
@@ -109,6 +112,9 @@ class BitgetPublicConnector(PublicConnector):
         self._ws_books1_decoder = msgspec.json.Decoder(BitgetBooks1WsMsg)
         self._ws_trade_decoder = msgspec.json.Decoder(BitgetWsTradeWsMsg)
         self._ws_candle_decoder = msgspec.json.Decoder(BitgetWsCandleWsMsg)
+        self._ws_books_decoder = msgspec.json.Decoder(BitgetBooksWsMsg)
+        self._ws_ticker_decoder = msgspec.json.Decoder(BitgetWsTickerWsMsg)
+        self._last_kline: Dict[tuple[str, KlineInterval], Kline] = {}
 
     def _get_inst_type(self, market: BitgetMarket):
         if market.spot:
@@ -118,6 +124,15 @@ class BitgetPublicConnector(PublicConnector):
         elif market.inverse:
             return "coin-futures"
 
+    def _get_category(self, market: BitgetMarket) -> str:
+        if market.spot:
+            return "SPOT"
+        if market.linear:
+            return "USDT-FUTURES" if market.quote == "USDT" else "USDC-FUTURES"
+        if market.inverse:
+            return "COIN-FUTURES"
+        raise ValueError(f"Unsupported market type: {market.type}")
+
     def _uta_inst_type_suffix(self, inst_type: BitgetUtaInstType):
         return self._uta_inst_type_map[inst_type]
 
@@ -133,7 +148,14 @@ class BitgetPublicConnector(PublicConnector):
         end_time: int | None = None,
     ) -> KlineList:
         """Request klines"""
-        raise NotImplementedError
+        return await self._request_klines(
+            symbol=symbol,
+            interval=interval,
+            kline_type="MARKET",
+            limit=limit,
+            start_time=start_time,
+            end_time=end_time,
+        )
 
     async def request_ticker(
         self,
@@ -144,16 +166,11 @@ class BitgetPublicConnector(PublicConnector):
         if not market:
             raise ValueError(f"Symbol is not available: {symbol}")
 
-        if market.spot:
-            category = "SPOT"
-        elif market.linear:
-            category = "USDT-FUTURES" if market.quote == "USDT" else "USDC-FUTURES"
-        elif market.inverse:
-            category = "COIN-FUTURES"
+        category = self._get_category(market)
 
         res = await self._api_client.get_api_v3_market_tickers(
             category=category,
-            symbol=symbol,
+            symbol=market.id,
         )
 
         ticker_response = res.data[0]
@@ -174,6 +191,8 @@ class BitgetPublicConnector(PublicConnector):
     ) -> Dict[str, Ticker]:
         """Request 24hr ticker data for multiple symbols"""
         all_tickers: Dict[str, Ticker] = {}
+        # COIN-FUTURES (inverse) is intentionally excluded from load_markets, so
+        # its tickers would all be dropped by the market_id lookup below.
         for category in ["SPOT", "USDT-FUTURES", "USDC-FUTURES"]:
             res = await self._api_client.get_api_v3_market_tickers(
                 category=category,
@@ -207,7 +226,118 @@ class BitgetPublicConnector(PublicConnector):
         end_time: int | None = None,
     ) -> KlineList:
         """Request index klines"""
-        raise NotImplementedError
+        market = self._market.get(symbol)
+        if not market:
+            raise ValueError(f"Symbol {symbol} formated wrongly, or not supported")
+        if market.spot:
+            raise ValueError("Spot market is not supported for index klines")
+        return await self._request_klines(
+            symbol=symbol,
+            interval=interval,
+            kline_type="INDEX",
+            limit=limit,
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+    async def _request_klines(
+        self,
+        *,
+        symbol: str,
+        interval: KlineInterval,
+        kline_type: str,
+        limit: int | None,
+        start_time: int | None,
+        end_time: int | None,
+    ) -> KlineList:
+        market = self._market.get(symbol)
+        if not market:
+            raise ValueError(f"Symbol {symbol} formated wrongly, or not supported")
+
+        bitget_interval = BitgetEnumParser.to_bitget_kline_interval(interval)
+        all_klines: list[Kline] = []
+        seen_timestamps: set[int] = set()
+        prev_start_time: int | None = None
+
+        while True:
+            if prev_start_time is not None and prev_start_time == start_time:
+                break
+            prev_start_time = start_time
+
+            response = await self._api_client.get_api_v3_market_candles(
+                category=self._get_category(market),
+                symbol=market.id,
+                interval=bitget_interval.value,
+                type=kline_type,
+                startTime=start_time,
+                endTime=end_time,
+                limit=100,
+            )
+            response_rows = sorted(response.data, key=lambda row: int(row[0]))
+            if not response_rows:
+                break
+
+            new_klines = [
+                self._handle_candlesticks(
+                    symbol=symbol,
+                    interval=interval,
+                    row=row,
+                    timestamp=response.requestTime,
+                )
+                for row in response_rows
+                if int(row[0]) not in seen_timestamps
+            ]
+            if not new_klines:
+                break
+
+            all_klines.extend(new_klines)
+            seen_timestamps.update(int(row[0]) for row in response_rows)
+            start_time = int(response_rows[-1][0]) + 1
+            if end_time is not None and start_time >= end_time:
+                break
+
+        if limit is not None and len(all_klines) > limit:
+            all_klines = all_klines[-limit:]
+
+        return KlineList(
+            all_klines,
+            fields=[
+                "timestamp",
+                "symbol",
+                "open",
+                "high",
+                "low",
+                "close",
+                "volume",
+                "quote_volume",
+                "confirm",
+            ],
+        )
+
+    def _handle_candlesticks(
+        self,
+        *,
+        symbol: str,
+        interval: KlineInterval,
+        row: List[str],
+        timestamp: int,
+    ) -> Kline:
+        start = int(row[0])
+        confirm = self._clock.timestamp_ms() >= start + interval.seconds * 1000 - 1
+        return Kline(
+            exchange=self._exchange_id,
+            symbol=symbol,
+            interval=interval,
+            open=float(row[1]),
+            high=float(row[2]),
+            low=float(row[3]),
+            close=float(row[4]),
+            volume=float(row[5]),
+            quote_volume=float(row[6]),
+            start=start,
+            timestamp=timestamp,
+            confirm=confirm,
+        )
 
     def _ws_msg_handler(self, raw: bytes):
         """Handle incoming WebSocket messages"""
@@ -224,10 +354,14 @@ class BitgetPublicConnector(PublicConnector):
             elif msg.arg is not None:
                 if msg.arg.topic == "books1":
                     self._handle_books1_data(raw, msg.arg)
+                elif msg.arg.topic in ("books5", "books50"):
+                    self._handle_books_data(raw, msg.arg)
                 elif msg.arg.topic == "publicTrade":
                     self._handle_trade_data(raw, msg.arg)
                 elif msg.arg.topic == "kline":
                     self._handle_candle_data(raw, msg.arg)
+                elif msg.arg.topic == "ticker":
+                    self._handle_ticker_data(raw, msg.arg)
 
             # print(f"Received WebSocket message: {raw}")
         except msgspec.DecodeError as e:
@@ -251,6 +385,12 @@ class BitgetPublicConnector(PublicConnector):
             BitgetKlineInterval(arg.interval)
         )
         for data in msg.data:
+            key = (symbol, interval)
+            cached = self._last_kline.get(key)
+            if cached is not None and int(data.start) > cached.start:
+                self._msgbus.publish(
+                    topic="kline", msg=msgspec.structs.replace(cached, confirm=True)
+                )
             kline = Kline(
                 exchange=self._exchange_id,
                 symbol=symbol,
@@ -263,10 +403,11 @@ class BitgetPublicConnector(PublicConnector):
                 start=int(data.start),
                 timestamp=self._clock.timestamp_ms(),
                 interval=interval,
-                confirm=False,  # NOTE: need to handle confirm yourself
+                confirm=False,
             )
             self._msgbus.publish(topic="kline", msg=kline)
-            # self._log.debug(f"Kline update: {str(kline)}")
+            if cached is None or kline.start >= cached.start:
+                self._last_kline[key] = kline
 
     def _handle_trade_data(self, raw: bytes, arg: BitgetWsUtaArgMsg):
         msg = self._ws_trade_decoder.decode(raw)
@@ -302,6 +443,68 @@ class BitgetPublicConnector(PublicConnector):
             self._msgbus.publish(topic="bookl1", msg=bookl1)
             # self._log.debug(f"BookL1 update: {str(bookl1)}")
 
+    def _handle_books_data(self, raw: bytes, arg: BitgetWsUtaArgMsg):
+        msg = self._ws_books_decoder.decode(raw)
+        sym_id = f"{arg.symbol}_{self._uta_inst_type_suffix(arg.instType)}"
+        symbol = self._market_id[sym_id]
+        for data in msg.data:
+            bids = [
+                BookOrderData(price=float(book.px), size=float(book.sz))
+                for book in data.b
+            ] or [BookOrderData(price=0, size=0)]
+            asks = [
+                BookOrderData(price=float(book.px), size=float(book.sz))
+                for book in data.a
+            ] or [BookOrderData(price=0, size=0)]
+            self._msgbus.publish(
+                topic="bookl2",
+                msg=BookL2(
+                    exchange=self._exchange_id,
+                    symbol=symbol,
+                    bids=bids,
+                    asks=asks,
+                    timestamp=int(data.ts),
+                ),
+            )
+
+    def _handle_ticker_data(self, raw: bytes, arg: BitgetWsUtaArgMsg):
+        msg = self._ws_ticker_decoder.decode(raw)
+        sym_id = f"{arg.symbol}_{self._uta_inst_type_suffix(arg.instType)}"
+        symbol = self._market_id[sym_id]
+        timestamp = int(msg.ts) if msg.ts is not None else self._clock.timestamp_ms()
+        for data in msg.data:
+            if data.fundingRate is not None and data.nextFundingTime is not None:
+                self._msgbus.publish(
+                    topic="funding_rate",
+                    msg=FundingRate(
+                        exchange=self._exchange_id,
+                        symbol=symbol,
+                        rate=float(data.fundingRate),
+                        next_funding_time=int(data.nextFundingTime),
+                        timestamp=timestamp,
+                    ),
+                )
+            if data.indexPrice is not None:
+                self._msgbus.publish(
+                    topic="index_price",
+                    msg=IndexPrice(
+                        exchange=self._exchange_id,
+                        symbol=symbol,
+                        price=float(data.indexPrice),
+                        timestamp=timestamp,
+                    ),
+                )
+            if data.markPrice is not None:
+                self._msgbus.publish(
+                    topic="mark_price",
+                    msg=MarkPrice(
+                        exchange=self._exchange_id,
+                        symbol=symbol,
+                        price=float(data.markPrice),
+                        timestamp=timestamp,
+                    ),
+                )
+
     def subscribe_bookl1(self, symbol: str | List[str]):
         symbol = symbol if isinstance(symbol, list) else [symbol]
         symbols_by_inst_type = {}
@@ -408,35 +611,92 @@ class BitgetPublicConnector(PublicConnector):
 
     def subscribe_bookl2(self, symbol: str | List[str], level: BookLevel):
         """Subscribe to the bookl2 data"""
-        raise NotImplementedError
+        topic_by_level = {BookLevel.L5: "books5", BookLevel.L50: "books50"}
+        topic = topic_by_level.get(level)
+        if topic is None:
+            raise ValueError(
+                f"Unsupported book level for Bitget: {level}. Use L5 or L50."
+            )
+        symbol = symbol if isinstance(symbol, list) else [symbol]
+        symbols_by_inst_type: Dict[str, List[str]] = {}
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(f"Symbol {sym} not found in market data.")
+            symbols_by_inst_type.setdefault(self._get_inst_type(market), []).append(
+                market.id
+            )
+        for inst_type, symbols in symbols_by_inst_type.items():
+            self._ws_client.subscribe_depth_v3(symbols, inst_type, topic)
 
     def unsubscribe_bookl2(self, symbol: str | List[str], level: BookLevel):
         """Unsubscribe from the bookl2 data"""
-        raise NotImplementedError
+        topic_by_level = {BookLevel.L5: "books5", BookLevel.L50: "books50"}
+        topic = topic_by_level.get(level)
+        if topic is None:
+            raise ValueError(
+                f"Unsupported book level for Bitget: {level}. Use L5 or L50."
+            )
+        symbol = symbol if isinstance(symbol, list) else [symbol]
+        symbols_by_inst_type: Dict[str, List[str]] = {}
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(f"Symbol {sym} not found in market data.")
+            symbols_by_inst_type.setdefault(self._get_inst_type(market), []).append(
+                market.id
+            )
+        for inst_type, symbols in symbols_by_inst_type.items():
+            self._ws_client.unsubscribe_depth_v3(symbols, inst_type, topic)
+
+    def _ticker_symbols_by_inst_type(
+        self, symbol: str | List[str]
+    ) -> Dict[str, List[str]]:
+        symbol = symbol if isinstance(symbol, list) else [symbol]
+        symbols_by_inst_type: Dict[str, List[str]] = {}
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(f"Symbol {sym} not found in market data.")
+            if market.spot:
+                raise ValueError(
+                    "Funding, index, and mark ticker subscriptions are not "
+                    "supported for Bitget spot markets"
+                )
+            symbols_by_inst_type.setdefault(self._get_inst_type(market), []).append(
+                market.id
+            )
+        return symbols_by_inst_type
 
     def subscribe_funding_rate(self, symbol: str | List[str]):
         """Subscribe to the funding rate data"""
-        raise NotImplementedError
+        for inst_type, symbols in self._ticker_symbols_by_inst_type(symbol).items():
+            self._ws_client.subscribe_ticker_v3(symbols, inst_type)
 
     def unsubscribe_funding_rate(self, symbol: str | List[str]):
         """Unsubscribe from the funding rate data"""
-        raise NotImplementedError
+        for inst_type, symbols in self._ticker_symbols_by_inst_type(symbol).items():
+            self._ws_client.unsubscribe_ticker_v3(symbols, inst_type)
 
     def subscribe_index_price(self, symbol: str | List[str]):
         """Subscribe to the index price data"""
-        raise NotImplementedError
+        for inst_type, symbols in self._ticker_symbols_by_inst_type(symbol).items():
+            self._ws_client.subscribe_ticker_v3(symbols, inst_type)
 
     def unsubscribe_index_price(self, symbol: str | List[str]):
         """Unsubscribe from the index price data"""
-        raise NotImplementedError
+        for inst_type, symbols in self._ticker_symbols_by_inst_type(symbol).items():
+            self._ws_client.unsubscribe_ticker_v3(symbols, inst_type)
 
     def subscribe_mark_price(self, symbol: str | List[str]):
         """Subscribe to the mark price data"""
-        raise NotImplementedError
+        for inst_type, symbols in self._ticker_symbols_by_inst_type(symbol).items():
+            self._ws_client.subscribe_ticker_v3(symbols, inst_type)
 
     def unsubscribe_mark_price(self, symbol: str | List[str]):
         """Unsubscribe from the mark price data"""
-        raise NotImplementedError
+        for inst_type, symbols in self._ticker_symbols_by_inst_type(symbol).items():
+            self._ws_client.unsubscribe_ticker_v3(symbols, inst_type)
 
 
 class BitgetPrivateConnector(PrivateConnector):
@@ -508,6 +768,10 @@ class BitgetPrivateConnector(PrivateConnector):
 
     async def connect(self):
         if self._account_type.is_uta:
+            self._log.warning(
+                "Bitget UTA private trading support is beta and under development; "
+                "use classic SPOT/FUTURE accounts for stable trading workflows."
+            )
             self._oms._ws_client.subscribe_v3_order()
             self._oms._ws_client.subscribe_v3_position()
             self._oms._ws_client.subscribe_v3_account()

{walrasquant_lib-0.5.0 → walrasquant_lib-0.5.2}/src/walrasquant/exchange/bitget/constants.py

@@ -10,6 +10,7 @@ from walrasquant.constants import (
     OrderType,
     KlineInterval,
     RateLimiter,
+    TriggerType,
 )
 from walrasquant.error import KlineSupportedError
 from walrasquant.exchange.bitget.error import BitgetRateLimitError
@@ -95,6 +96,7 @@ class BitgetInstType(Enum):
 
 class BitgetUtaInstType(Enum):
     SPOT = "spot"
+    MARGIN = "margin"
     USDT_FUTURES = "usdt-futures"
     COIN_FUTURES = "coin-futures"
     USDC_FUTURES = "usdc-futures"
@@ -102,31 +104,39 @@ class BitgetUtaInstType(Enum):
 
     @property
     def is_spot(self) -> bool:
-        return self == BitgetInstType.SPOT
+        return self == BitgetUtaInstType.SPOT
 
     @property
     def is_swap(self) -> bool:
-        return not self.is_spot
+        return self in (
+            BitgetUtaInstType.USDT_FUTURES,
+            BitgetUtaInstType.USDC_FUTURES,
+            BitgetUtaInstType.COIN_FUTURES,
+        )
 
     @property
     def is_linear(self) -> bool:
-        return self in (BitgetInstType.USDT_FUTURES, BitgetInstType.USDC_FUTURES)
+        return self in (
+            BitgetUtaInstType.USDT_FUTURES,
+            BitgetUtaInstType.USDC_FUTURES,
+        )
 
     @property
     def is_inverse(self) -> bool:
-        return self == BitgetInstType.COIN_FUTURES
+        return self == BitgetUtaInstType.COIN_FUTURES
 
     @property
     def is_usdc_swap(self) -> bool:
-        return self == BitgetInstType.USDC_FUTURES
+        return self == BitgetUtaInstType.USDC_FUTURES
 
     @property
     def is_usdt_swap(self) -> bool:
-        return self == BitgetInstType.USDT_FUTURES
+        return self == BitgetUtaInstType.USDT_FUTURES
 
 
 class BitgetKlineInterval(Enum):
     MINUTE_1 = "1m"
+    MINUTE_3 = "3m"
     MINUTE_5 = "5m"
     MINUTE_15 = "15m"
     MINUTE_30 = "30m"
@@ -147,7 +157,7 @@ class BitgetOrderStatus(Enum):
     NEW = "new"
     FILLED = "filled"
     CANCELED = "canceled"
-    CANCELLED = "cancelled"  # Alias pointing to the same value
+    CANCELLED = "cancelled"  # Used by endpoints that spell canceled with two l's
     PARTIALLY_FILLED = "partially_filled"
 
 
@@ -216,6 +226,7 @@ class BitgetPositionSide(Enum):
 class BitgetEnumParser:
     _kline_interval_map = {
         BitgetKlineInterval.MINUTE_1: KlineInterval.MINUTE_1,
+        BitgetKlineInterval.MINUTE_3: KlineInterval.MINUTE_3,
         BitgetKlineInterval.MINUTE_5: KlineInterval.MINUTE_5,
         BitgetKlineInterval.MINUTE_15: KlineInterval.MINUTE_15,
         BitgetKlineInterval.MINUTE_30: KlineInterval.MINUTE_30,
@@ -231,7 +242,7 @@ class BitgetEnumParser:
         BitgetOrderStatus.NEW: OrderStatus.ACCEPTED,
         BitgetOrderStatus.FILLED: OrderStatus.FILLED,
         BitgetOrderStatus.CANCELED: OrderStatus.CANCELED,
-        BitgetOrderStatus.CANCELLED: OrderStatus.CANCELED,  # Alias pointing to the same value
+        BitgetOrderStatus.CANCELLED: OrderStatus.CANCELED,
         BitgetOrderStatus.PARTIALLY_FILLED: OrderStatus.PARTIALLY_FILLED,
     }
 
@@ -297,6 +308,14 @@ class BitgetEnumParser:
     def parse_order_type(cls, order_type: BitgetOrderType) -> OrderType:
         return cls._order_type_map[order_type]
 
+    @classmethod
+    def to_bitget_trigger_type(cls, trigger_type: TriggerType) -> str:
+        if trigger_type == TriggerType.LAST_PRICE:
+            return "market"
+        if trigger_type == TriggerType.MARK_PRICE:
+            return "mark"
+        raise ValueError(f"Unsupported Bitget trigger type: {trigger_type}")
+
 
 class BitgetRateLimiter(RateLimiter):
     def __init__(self, enable_rate_limit: bool = True):
@@ -332,6 +351,26 @@ class BitgetRateLimiter(RateLimiter):
                 timeout=-1,
                 using=RateLimiterType.FIXED_WINDOW.value,
             ),
+            "/api/v3/trade/place-batch": Throttled(
+                quota=rate_limiter.per_sec(5),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v3/trade/modify-order": Throttled(
+                quota=rate_limiter.per_sec(10),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v2/spot/trade/batch-orders": Throttled(
+                quota=rate_limiter.per_sec(5),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
+            "/api/v2/mix/order/batch-place-order": Throttled(
+                quota=rate_limiter.per_sec(5),
+                timeout=-1,
+                using=RateLimiterType.FIXED_WINDOW.value,
+            ),
             "/api/v3/trade/cancel-order": Throttled(
                 quota=rate_limiter.per_sec(10),
                 timeout=-1,