walrasquant-lib 0.4.20__py3-none-any.whl

walrasquant/exchange/bybit/websockets.py

@@ -0,0 +1,307 @@
+import msgspec
+import asyncio
+import picows
+
+from typing import Any, Callable, List
+
+from walrasquant.base import WSClient
+from walrasquant.core.entity import TaskManager
+from walrasquant.core.nautilius_core import LiveClock, hmac_signature
+from walrasquant.exchange.bybit.schema import (
+    BybitWsMessageGeneral,
+    BybitWsApiGeneralMsg,
+)
+from walrasquant.exchange.bybit.constants import (
+    BybitAccountType,
+    BybitKlineInterval,
+    BybitRateLimiter,
+)
+
+_REQ_ID_MASK = (1 << 48) - 1
+
+
+def user_pong_callback(self, frame: picows.WSFrame) -> bool:
+    if frame.msg_type != picows.WSMsgType.TEXT:
+        self._log.debug(
+            f"Received non-text frame for pong callback. ws_frame: {self._decode_frame(frame)}"
+        )
+        return False
+
+    raw = frame.get_payload_as_bytes()
+    try:
+        message = msgspec.json.decode(raw, type=BybitWsMessageGeneral)
+        self._log.debug(f"Received pong message: {message}")
+        return message.is_pong
+    except msgspec.DecodeError:
+        self._log.error(
+            f"Failed to decode pong message. ws_frame: {self._decode_frame(frame)}"
+        )
+        return False
+
+
+def user_api_pong_callback(self, frame: picows.WSFrame) -> bool:
+    if frame.msg_type != picows.WSMsgType.TEXT:
+        self._log.debug(
+            f"Received non-text frame for pong callback. ws_frame: {self._decode_frame(frame)}"
+        )
+        return False
+
+    raw = frame.get_payload_as_bytes()
+    try:
+        message = msgspec.json.decode(raw, type=BybitWsApiGeneralMsg)
+        self._log.debug(f"Received pong message: {message}")
+        return message.is_pong
+    except msgspec.DecodeError:
+        self._log.error(
+            f"Failed to decode pong message. ws_frame: {self._decode_frame(frame)}"
+        )
+        return False
+
+
+class BybitWSClient(WSClient):
+    def __init__(
+        self,
+        account_type: BybitAccountType,
+        handler: Callable[..., Any],
+        task_manager: TaskManager,
+        clock: LiveClock,
+        api_key: str | None = None,
+        secret: str | None = None,
+        custom_url: str | None = None,
+        max_subscriptions_per_client: int | None = None,
+        max_clients: int | None = None,
+    ):
+        self._account_type = account_type
+        self._api_key = api_key
+        self._secret = secret
+
+        if self.is_private:
+            url = account_type.ws_private_url
+        else:
+            url = account_type.ws_public_url
+        if custom_url:
+            url = custom_url
+        # Bybit: do not exceed 500 requests per 5 minutes
+        super().__init__(
+            url,
+            handler=handler,
+            task_manager=task_manager,
+            clock=clock,
+            ping_idle_timeout=10,
+            ping_reply_timeout=2,
+            specific_ping_msg=msgspec.json.encode({"op": "ping"}),
+            auto_ping_strategy="ping_periodically",
+            user_pong_callback=user_pong_callback,
+            max_subscriptions_per_client=max_subscriptions_per_client,
+            max_clients=max_clients,
+        )
+
+    @property
+    def is_private(self):
+        return self._api_key is not None or self._secret is not None
+
+    def _generate_signature(self):
+        expires = self._clock.timestamp_ms() + 1_000
+        signature = hmac_signature(self._secret, f"GET/realtime{expires}")  # type: ignore
+        return signature, expires
+
+    def _get_auth_payload(self):
+        signature, expires = self._generate_signature()
+        return {"op": "auth", "args": [self._api_key, expires, signature]}
+
+    async def _auth(self, client_id: int | None = None):
+        self.send(self._get_auth_payload(), client_id=client_id)
+        await asyncio.sleep(5)
+
+    def _send_payload(
+        self,
+        params: List[str],
+        chunk_size: int = 100,
+        op: str = "subscribe",
+        client_id: int | None = None,
+    ):
+        # Split params into chunks of 100 if length exceeds 100
+        params_chunks = [
+            params[i : i + chunk_size] for i in range(0, len(params), chunk_size)
+        ]
+
+        for chunk in params_chunks:
+            payload = {"op": op, "args": chunk}
+            self.send(payload, client_id=client_id)
+
+    def _subscribe(self, topics: List[str]):
+        assigned = self._register_subscriptions(topics)
+        if not assigned:
+            return
+        for client_id, client_topics in assigned.items():
+            for topic in client_topics:
+                self._log.debug(f"Subscribing to {topic}...")
+            if self._is_client_connected(client_id):
+                self._send_payload(client_topics, op="subscribe", client_id=client_id)
+
+    def _unsubscribe(self, topics: List[str]):
+        removed = self._unregister_subscriptions(topics)
+        if not removed:
+            return
+        for client_id, client_topics in removed.items():
+            for topic in client_topics:
+                self._log.debug(f"Unsubscribing from {topic}...")
+            self._send_payload(client_topics, op="unsubscribe", client_id=client_id)
+
+    def subscribe_order_book(self, symbols: List[str], depth: int):
+        """subscribe to orderbook"""
+        topics = [f"orderbook.{depth}.{symbol}" for symbol in symbols]
+        self._subscribe(topics)
+
+    def subscribe_trade(self, symbols: List[str]):
+        """subscribe to trade"""
+        topics = [f"publicTrade.{symbol}" for symbol in symbols]
+        self._subscribe(topics)
+
+    def subscribe_ticker(self, symbols: List[str]):
+        """subscribe to ticker"""
+        topics = [f"tickers.{symbol}" for symbol in symbols]
+        self._subscribe(topics)
+
+    def subscribe_kline(self, symbols: List[str], interval: BybitKlineInterval):
+        """subscribe to kline"""
+        topics = [f"kline.{interval.value}.{symbol}" for symbol in symbols]
+        self._subscribe(topics)
+
+    def unsubscribe_order_book(self, symbols: List[str], depth: int):
+        """unsubscribe from orderbook"""
+        topics = [f"orderbook.{depth}.{symbol}" for symbol in symbols]
+        self._unsubscribe(topics)
+
+    def unsubscribe_trade(self, symbols: List[str]):
+        """unsubscribe from trade"""
+        topics = [f"publicTrade.{symbol}" for symbol in symbols]
+        self._unsubscribe(topics)
+
+    def unsubscribe_ticker(self, symbols: List[str]):
+        """unsubscribe from ticker"""
+        topics = [f"tickers.{symbol}" for symbol in symbols]
+        self._unsubscribe(topics)
+
+    def unsubscribe_kline(self, symbols: List[str], interval: BybitKlineInterval):
+        """unsubscribe from kline"""
+        topics = [f"kline.{interval.value}.{symbol}" for symbol in symbols]
+        self._unsubscribe(topics)
+
+    async def _resubscribe_for_client(self, client_id: int, subscriptions: List[str]):
+        if not subscriptions:
+            return
+        if self.is_private:
+            await self._auth(client_id=client_id)
+        self._send_payload(subscriptions, client_id=client_id)
+
+    def subscribe_order(self, topic: str = "order"):
+        """subscribe to order"""
+        self._subscribe([topic])
+
+    def subscribe_position(self, topic: str = "position"):
+        """subscribe to position"""
+        self._subscribe([topic])
+
+    def subscribe_wallet(self, topic: str = "wallet"):
+        """subscribe to wallet"""
+        self._subscribe([topic])
+
+
+class BybitWSApiClient(WSClient):
+    def __init__(
+        self,
+        account_type: BybitAccountType,
+        api_key: str,
+        secret: str,
+        handler: Callable[..., Any],
+        task_manager: TaskManager,
+        clock: LiveClock,
+        enable_rate_limit: bool,
+    ):
+        self._api_key = api_key
+        self._secret = secret
+        self._account_type = account_type
+
+        url = account_type.ws_api_url
+        self._limiter = BybitRateLimiter(
+            enable_rate_limit=enable_rate_limit,
+        )
+
+        super().__init__(
+            url,
+            handler=handler,
+            task_manager=task_manager,
+            clock=clock,
+            ping_idle_timeout=5,
+            ping_reply_timeout=2,
+            specific_ping_msg=msgspec.json.encode({"op": "ping"}),
+            user_pong_callback=user_api_pong_callback,
+        )
+        self._req_id_seq = clock.timestamp_ms() & _REQ_ID_MASK
+
+    def _generate_signature(self):
+        expires = self._clock.timestamp_ms() + 1_000
+        signature = hmac_signature(self._secret, f"GET/realtime{expires}")
+        return signature, expires
+
+    def _get_auth_payload(self):
+        signature, expires = self._generate_signature()
+        return {"op": "auth", "args": [self._api_key, expires, signature]}
+
+    async def _auth(self, client_id: int | None = None):
+        self.send(self._get_auth_payload(), client_id=client_id)
+        await asyncio.sleep(5)
+
+    def _next_req_id(self, prefix: str, oid: str) -> str:
+        self._req_id_seq = (self._req_id_seq + 1) & _REQ_ID_MASK
+        return f"{prefix}{oid}.{self._req_id_seq:012x}"
+
+    def _submit(self, reqId: str, op: str, args: list[dict]):
+        payload = {
+            "reqId": reqId,
+            "header": {
+                "X-BAPI-TIMESTAMP": self._clock.timestamp_ms(),
+            },
+            "op": op,
+            "args": args,
+        }
+        self.send(payload)
+
+    async def create_order(
+        self,
+        id: str,
+        symbol: str,
+        side: str,
+        orderType: str,
+        qty: str,
+        category: str,
+        **kwargs,
+    ):
+        arg = {
+            "symbol": symbol,
+            "side": side,
+            "orderType": orderType,
+            "qty": qty,
+            "category": category,
+            **kwargs,
+        }
+        op = "order.create"
+        await self._limiter.order_limit(category=category, endpoint=op)
+        self._submit(reqId=self._next_req_id("n", id), op=op, args=[arg])
+
+    async def cancel_order(
+        self, id: str, symbol: str, orderLinkId: str, category: str, **kwargs
+    ):
+        arg = {
+            "symbol": symbol,
+            "orderLinkId": orderLinkId,
+            "category": category,
+            **kwargs,
+        }
+        op = "order.cancel"
+        # await self._limiter.order_limit(category=category, endpoint=op)
+        self._submit(reqId=self._next_req_id("c", id), op=op, args=[arg])
+
+    async def _resubscribe_for_client(self, client_id: int, subscriptions: List[str]):
+        await self._auth(client_id=client_id)

walrasquant/exchange/hyperliquid/__init__.py

@@ -0,0 +1,28 @@
+from walrasquant.exchange.hyperliquid.exchange import HyperLiquidExchangeManager
+from walrasquant.exchange.hyperliquid.constants import HyperLiquidAccountType
+from walrasquant.exchange.hyperliquid.connector import (
+    HyperLiquidPublicConnector,
+    HyperLiquidPrivateConnector,
+)
+from walrasquant.exchange.hyperliquid.oms import HyperLiquidOrderManagementSystem
+from walrasquant.exchange.hyperliquid.ems import HyperLiquidExecutionManagementSystem
+from walrasquant.exchange.hyperliquid.factory import HyperLiquidFactory
+
+# Auto-register factory on import
+try:
+    from walrasquant.exchange.registry import register_factory
+
+    register_factory(HyperLiquidFactory())
+except ImportError:
+    # Registry not available yet during bootstrap
+    pass
+
+__all__ = [
+    "HyperLiquidExchangeManager",
+    "HyperLiquidAccountType",
+    "HyperLiquidPublicConnector",
+    "HyperLiquidPrivateConnector",
+    "HyperLiquidOrderManagementSystem",
+    "HyperLiquidExecutionManagementSystem",
+    "HyperLiquidFactory",
+]

walrasquant/exchange/hyperliquid/connector.py

@@ -0,0 +1,370 @@
+import msgspec
+from typing import Dict, List
+from walrasquant.constants import (
+    KlineInterval,
+    BookLevel,
+    OrderSide,
+)
+from walrasquant.config import OrderQueryConfig
+from walrasquant.core.nautilius_core import (
+    MessageBus,
+    LiveClock,
+)
+from walrasquant.base import PublicConnector, PrivateConnector
+from walrasquant.core.registry import OrderRegistry
+from walrasquant.core.entity import TaskManager
+from walrasquant.core.cache import AsyncCache
+from walrasquant.schema import (
+    KlineList,
+    Ticker,
+    BookL1,
+    Trade,
+    Kline,
+)
+from walrasquant.exchange.hyperliquid.schema import (
+    HyperLiquidMarket,
+    HyperLiquidWsMessageGeneral,
+    HyperLiquidWsBboMsg,
+    HyperLiquidWsTradeMsg,
+    HyperLiquidWsCandleMsg,
+)
+from walrasquant.exchange.hyperliquid.oms import HyperLiquidOrderManagementSystem
+from walrasquant.exchange.hyperliquid.exchange import HyperLiquidExchangeManager
+from walrasquant.exchange.hyperliquid.websockets import HyperLiquidWSClient
+from walrasquant.exchange.hyperliquid.constants import (
+    HyperLiquidAccountType,
+    HyperLiquidEnumParser,
+)
+from walrasquant.exchange.hyperliquid.rest_api import HyperLiquidApiClient
+
+
+class HyperLiquidPublicConnector(PublicConnector):
+    _ws_client: HyperLiquidWSClient
+    _account_type: HyperLiquidAccountType
+    _market: Dict[str, HyperLiquidMarket]
+
+    def __init__(
+        self,
+        account_type: HyperLiquidAccountType,
+        exchange: HyperLiquidExchangeManager,
+        msgbus: MessageBus,
+        clock: LiveClock,
+        task_manager: TaskManager,
+        custom_url: str | None = None,
+        enable_rate_limit: bool = True,
+        max_subscriptions_per_client: int | None = None,
+        max_clients: int | None = None,
+    ):
+        super().__init__(
+            account_type=account_type,
+            market=exchange.market,
+            market_id=exchange.market_id,
+            exchange_id=exchange.exchange_id,
+            ws_client=HyperLiquidWSClient(
+                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,
+            ),
+            api_client=HyperLiquidApiClient(
+                clock=clock,
+                testnet=account_type.is_testnet,
+                enable_rate_limit=enable_rate_limit,
+            ),
+            msgbus=msgbus,
+            clock=clock,
+            task_manager=task_manager,
+        )
+
+        self._ws_msg_general_decoder = msgspec.json.Decoder(HyperLiquidWsMessageGeneral)
+        self._ws_msg_bbo_decoder = msgspec.json.Decoder(HyperLiquidWsBboMsg)
+        self._ws_msg_trade_decoder = msgspec.json.Decoder(HyperLiquidWsTradeMsg)
+        self._ws_msg_candle_decoder = msgspec.json.Decoder(HyperLiquidWsCandleMsg)
+
+    async def request_klines(
+        self,
+        symbol: str,
+        interval: KlineInterval,
+        limit: int | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> KlineList:
+        """Request klines"""
+        raise NotImplementedError
+
+    async def request_ticker(
+        self,
+        symbol: str,
+    ) -> Ticker:
+        """Request 24hr ticker data"""
+        raise NotImplementedError
+
+    async def request_all_tickers(
+        self,
+    ) -> Dict[str, Ticker]:
+        """Request 24hr ticker data for multiple symbols"""
+        raise NotImplementedError
+
+    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:
+        """Request index klines"""
+        raise NotImplementedError
+
+    def _ws_msg_handler(self, raw: bytes):
+        try:
+            ws_msg: HyperLiquidWsMessageGeneral = self._ws_msg_general_decoder.decode(
+                raw
+            )
+            # if ws_msg.channel == "pong":
+            #     self._ws_client._transport.notify_user_specific_pong_received()
+            #     self._log.debug("Pong received")
+            #     return
+
+            if ws_msg.channel == "bbo":
+                self._parse_bbo_update(raw)
+            elif ws_msg.channel == "trades":
+                self._parse_trades_update(raw)
+            elif ws_msg.channel == "candle":
+                self._parse_candle_update(raw)
+        except msgspec.DecodeError as e:
+            self._log.error(f"Failed to decode WebSocket message: {e}")
+            return
+
+    def _parse_candle_update(self, raw: bytes):
+        candle_msg: HyperLiquidWsCandleMsg = self._ws_msg_candle_decoder.decode(raw)
+        candle_data = candle_msg.data
+        id = candle_data.s
+        symbol = self._market_id[id]
+        interval = HyperLiquidEnumParser.parse_kline_interval(candle_data.i)
+        ts = self._clock.timestamp_ms()
+        kline = Kline(
+            exchange=self._exchange_id,
+            symbol=symbol,
+            start=candle_data.t,
+            timestamp=ts,
+            open=float(candle_data.o),
+            high=float(candle_data.h),
+            low=float(candle_data.l),
+            close=float(candle_data.c),
+            volume=float(candle_data.v),
+            interval=interval,
+            confirm=False,  # NOTE: you should define how to handle confirmation in HyperLiquid
+        )
+        self._msgbus.publish(topic="kline", msg=kline)
+
+    def _parse_trades_update(self, raw: bytes):
+        trade_msg: HyperLiquidWsTradeMsg = self._ws_msg_trade_decoder.decode(raw)
+        for data in trade_msg.data:
+            id = data.coin
+            symbol = self._market_id[id]
+            trade = Trade(
+                exchange=self._exchange_id,
+                symbol=symbol,
+                timestamp=data.time,
+                price=float(data.px),
+                size=float(data.sz),
+                side=OrderSide.BUY if data.side.is_buy else OrderSide.SELL,
+            )
+            self._msgbus.publish(topic="trade", msg=trade)
+
+    def _parse_bbo_update(self, raw: bytes):
+        bbo_msg: HyperLiquidWsBboMsg = self._ws_msg_bbo_decoder.decode(raw)
+        id = bbo_msg.data.coin
+        symbol = self._market_id[id]
+        bid_data = bbo_msg.data.bbo[0]
+        ask_data = bbo_msg.data.bbo[1]
+        bookl1 = BookL1(
+            exchange=self._exchange_id,
+            symbol=symbol,
+            timestamp=bbo_msg.data.time,
+            bid=float(bid_data.px),
+            bid_size=float(bid_data.sz),
+            ask=float(ask_data.px),
+            ask_size=float(ask_data.sz),
+        )
+        self._msgbus.publish(topic="bookl1", msg=bookl1)
+
+    def subscribe_bookl1(self, symbol: str | List[str]):
+        symbol = [symbol] if isinstance(symbol, str) else symbol
+        symbols = []
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(
+                    f"Market {sym} not found in exchange {self._exchange_id}"
+                )
+            symbols.append(market.baseName if market.swap else market.id)
+        self._ws_client.subscribe_bbo(symbols)
+
+    def unsubscribe_bookl1(self, symbol: str | List[str]):
+        symbol = [symbol] if isinstance(symbol, str) else symbol
+        symbols = []
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(
+                    f"Market {sym} not found in exchange {self._exchange_id}"
+                )
+            symbols.append(market.baseName if market.swap else market.id)
+        self._ws_client.unsubscribe_bbo(symbols)
+
+    def subscribe_trade(self, symbol):
+        symbol = [symbol] if isinstance(symbol, str) else symbol
+        symbols = []
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(
+                    f"Market {sym} not found in exchange {self._exchange_id}"
+                )
+            symbols.append(market.baseName if market.swap else market.id)
+        self._ws_client.subscribe_trades(symbols)
+
+    def unsubscribe_trade(self, symbol):
+        symbol = [symbol] if isinstance(symbol, str) else symbol
+        symbols = []
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(
+                    f"Market {sym} not found in exchange {self._exchange_id}"
+                )
+            symbols.append(market.baseName if market.swap else market.id)
+        self._ws_client.unsubscribe_trades(symbols)
+
+    def subscribe_kline(self, symbol: str | List[str], interval: KlineInterval):
+        """Subscribe to the kline data"""
+        symbol = [symbol] if isinstance(symbol, str) else symbol
+        symbols = []
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(
+                    f"Market {sym} not found in exchange {self._exchange_id}"
+                )
+            symbols.append(market.baseName if market.swap else market.id)
+        hyper_interval = HyperLiquidEnumParser.to_hyperliquid_kline_interval(interval)
+        self._ws_client.subscribe_candle(symbols, hyper_interval)
+
+    def unsubscribe_kline(self, symbol: str | List[str], interval: KlineInterval):
+        """Unsubscribe from the kline data"""
+        symbol = [symbol] if isinstance(symbol, str) else symbol
+        symbols = []
+        for sym in symbol:
+            market = self._market.get(sym)
+            if not market:
+                raise ValueError(
+                    f"Market {sym} not found in exchange {self._exchange_id}"
+                )
+            symbols.append(market.baseName if market.swap else market.id)
+        hyper_interval = HyperLiquidEnumParser.to_hyperliquid_kline_interval(interval)
+        self._ws_client.unsubscribe_candle(symbols, hyper_interval)
+
+    def subscribe_bookl2(self, symbol: str | List[str], level: BookLevel):
+        """Subscribe to the bookl2 data"""
+        raise NotImplementedError
+
+    def unsubscribe_bookl2(self, symbol: str | List[str], level: BookLevel):
+        """Unsubscribe from the bookl2 data"""
+        raise NotImplementedError
+
+    def subscribe_funding_rate(self, symbol: str | List[str]):
+        """Subscribe to the funding rate data"""
+        raise NotImplementedError
+
+    def unsubscribe_funding_rate(self, symbol: str | List[str]):
+        """Unsubscribe from the funding rate data"""
+        raise NotImplementedError
+
+    def subscribe_index_price(self, symbol: str | List[str]):
+        """Subscribe to the index price data"""
+        raise NotImplementedError
+
+    def unsubscribe_index_price(self, symbol: str | List[str]):
+        """Unsubscribe from the index price data"""
+        raise NotImplementedError
+
+    def subscribe_mark_price(self, symbol: str | List[str]):
+        """Subscribe to the mark price data"""
+        raise NotImplementedError
+
+    def unsubscribe_mark_price(self, symbol: str | List[str]):
+        """Unsubscribe from the mark price data"""
+        raise NotImplementedError
+
+
+class HyperLiquidPrivateConnector(PrivateConnector):
+    _api_client: HyperLiquidApiClient
+    _market: Dict[str, HyperLiquidMarket]
+    _oms: HyperLiquidOrderManagementSystem
+
+    def __init__(
+        self,
+        account_type: HyperLiquidAccountType,
+        exchange: HyperLiquidExchangeManager,
+        cache: AsyncCache,
+        registry: OrderRegistry,
+        clock: LiveClock,
+        msgbus: MessageBus,
+        task_manager: TaskManager,
+        order_query_config: OrderQueryConfig,
+        enable_rate_limit: bool = True,
+        max_subscriptions_per_client: int | None = None,
+        max_clients: int | None = None,
+        **kwargs,
+    ):
+        if not exchange.api_key or not exchange.secret:
+            raise ValueError(
+                "API key and secret must be provided for private connector"
+            )
+
+        api_client = HyperLiquidApiClient(
+            clock=clock,
+            api_key=exchange.api_key,
+            secret=exchange.secret,
+            testnet=account_type.is_testnet,
+            enable_rate_limit=enable_rate_limit,
+        )
+
+        oms = HyperLiquidOrderManagementSystem(
+            account_type=account_type,
+            api_key=exchange.api_key,
+            secret=exchange.secret,
+            market=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,
+            max_slippage=kwargs.get("max_slippage", 0.02),
+            max_subscriptions_per_client=max_subscriptions_per_client,
+            max_clients=max_clients,
+            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):
+        """Connect to the exchange"""
+        self._oms._ws_client.subscribe_order_updates()
+        self._oms._ws_client.subscribe_user_events()
+        await self._oms._ws_client.connect()
+        await self._oms._ws_api_client.connect()