vnpy_okx 2025.6.17__py3-none-any.whl → 2025.10.5__py3-none-any.whl

vnpy_okx/okx_gateway.py

@@ -9,7 +9,7 @@ from urllib.parse import urlencode
 from types import TracebackType
 from collections.abc import Callable
 
-from vnpy.event import EventEngine
+from vnpy.event import EventEngine, Event, EVENT_TIMER
 from vnpy.trader.constant import (
     Direction,
     Exchange,
@@ -55,9 +55,9 @@ AWS_BUSINESS_HOST: str = "wss://wsaws.okx.com:8443/ws/v5/business"
 
 # Demo server hosts
 DEMO_REST_HOST: str = "https://www.okx.com"
-DEMO_PUBLIC_HOST: str = "wss://wspap.okx.com:8443/ws/v5/public?brokerId=9999"
-DEMO_PRIVATE_HOST: str = "wss://wspap.okx.com:8443/ws/v5/private?brokerId=9999"
-DEMO_BUSINESS_HOST: str = "wss://wspap.okx.com:8443/ws/v5/business?brokerId=9999"
+DEMO_PUBLIC_HOST: str = "wss://wspap.okx.com:8443/ws/v5/public"
+DEMO_PRIVATE_HOST: str = "wss://wspap.okx.com:8443/ws/v5/private"
+DEMO_BUSINESS_HOST: str = "wss://wspap.okx.com:8443/ws/v5/business"
 
 # Order status map
 STATUS_OKX2VT: dict[str, Status] = {
@@ -70,6 +70,7 @@ STATUS_OKX2VT: dict[str, Status] = {
 
 # Order type map
 ORDERTYPE_OKX2VT: dict[str, OrderType] = {
+    "market": OrderType.MARKET,
     "limit": OrderType.LIMIT,
     "fok": OrderType.FOK,
     "ioc": OrderType.FAK
@@ -115,6 +116,7 @@ class OkxGateway(BaseGateway):
         "Server": ["REAL", "AWS", "DEMO"],
         "Proxy Host": "",
         "Proxy Port": 0,
+        "Spread Trading": ["False", "True"],
     }
 
     exchanges: Exchange = [Exchange.GLOBAL]
@@ -134,6 +136,7 @@ class OkxGateway(BaseGateway):
         self.server: str = ""
         self.proxy_host: str = ""
         self.proxy_port: int = 0
+        self.spread_trading: bool = False
 
         self.orders: dict[str, OrderData] = {}
         self.local_orderids: set[str] = set()
@@ -144,6 +147,10 @@ class OkxGateway(BaseGateway):
         self.rest_api: RestApi = RestApi(self)
         self.public_api: PublicApi = PublicApi(self)
         self.private_api: PrivateApi = PrivateApi(self)
+        self.business_api: BusinessApi = BusinessApi(self)
+
+        self.ping_count: int = 0
+        self.ping_interval: int = 20
 
     def connect(self, setting: dict) -> None:
         """
@@ -154,7 +161,7 @@ class OkxGateway(BaseGateway):
 
         Parameters:
             setting: A dictionary containing connection parameters including
-                    API credentials, server selection, and proxy configuration
+                     API credentials, server selection, and proxy configuration.
         """
         self.key = setting["API Key"]
         self.secret = setting["Secret Key"]
@@ -162,6 +169,7 @@ class OkxGateway(BaseGateway):
         self.server = setting["Server"]
         self.proxy_host = setting["Proxy Host"]
         self.proxy_port = setting["Proxy Port"]
+        self.spread_trading = setting["Spread Trading"] == "True"
 
         self.rest_api.connect(
             self.key,
@@ -169,7 +177,8 @@ class OkxGateway(BaseGateway):
             self.passphrase,
             self.server,
             self.proxy_host,
-            self.proxy_port
+            self.proxy_port,
+            self.spread_trading
         )
 
     def connect_ws_api(self) -> None:
@@ -190,6 +199,18 @@ class OkxGateway(BaseGateway):
             self.proxy_port,
         )
 
+        if self.spread_trading:
+            self.business_api.connect(
+                self.key,
+                self.secret,
+                self.passphrase,
+                self.server,
+                self.proxy_host,
+                self.proxy_port,
+            )
+
+        self.event_engine.register(EVENT_TIMER, self.process_timer_event)
+
     def subscribe(self, req: SubscribeRequest) -> None:
         """
         Subscribe to market data.
@@ -197,7 +218,15 @@ class OkxGateway(BaseGateway):
         Parameters:
             req: Subscription request object containing symbol information
         """
-        self.public_api.subscribe(req)
+        contract: ContractData | None = self.symbol_contract_map.get(req.symbol, None)
+        if not contract:
+            self.write_log(f"Failed to subscribe data, symbol not found: {req.symbol}")
+            return
+
+        if contract.product == Product.SPREAD:
+            self.business_api.subscribe(req)
+        else:
+            self.public_api.subscribe(req)
 
     def send_order(self, req: OrderRequest) -> str:
         """
@@ -212,7 +241,15 @@ class OkxGateway(BaseGateway):
         Returns:
             str: The VeighNa order ID if successful, empty string otherwise
         """
-        return self.private_api.send_order(req)
+        contract: ContractData | None = self.symbol_contract_map.get(req.symbol, None)
+        if not contract:
+            self.write_log(f"Failed to send order, symbol not found: {req.symbol}")
+            return ""
+
+        if contract.product == Product.SPREAD:
+            return self.business_api.send_order(req)
+        else:
+            return self.private_api.send_order(req)
 
     def cancel_order(self, req: CancelRequest) -> None:
         """
@@ -224,17 +261,31 @@ class OkxGateway(BaseGateway):
         Parameters:
             req: Cancel request object containing order details
         """
-        self.private_api.cancel_order(req)
+        contract: ContractData | None = self.symbol_contract_map.get(req.symbol, None)
+        if not contract:
+            self.write_log(f"Failed to cancel order, symbol not found: {req.symbol}")
+            return
+
+        if contract.product == Product.SPREAD:
+            self.business_api.cancel_order(req)
+        else:
+            self.private_api.cancel_order(req)
 
     def query_account(self) -> None:
         """
-        Not required since OKX provides websocket update for account balances.
+        Query account balance.
+
+        This method is not implemented because OKX provides account balance
+        updates through the websocket API.
         """
         pass
 
     def query_position(self) -> None:
         """
-        Not required since OKX provides websocket update for positions.
+        Query asset positions.
+
+        This method is not implemented because OKX provides position updates
+        through the websocket API.
         """
         pass
 
@@ -248,7 +299,15 @@ class OkxGateway(BaseGateway):
         Returns:
             list[BarData]: List of historical kline data bars
         """
-        return self.rest_api.query_history(req)
+        contract: ContractData | None = self.symbol_contract_map.get(req.symbol, None)
+        if not contract:
+            self.write_log(f"Failed to query history, symbol not found: {req.symbol}")
+            return []
+
+        if contract.product == Product.SPREAD:
+            return self.rest_api.query_spread_history(req)
+        else:
+            return self.rest_api.query_history(req)
 
     def close(self) -> None:
         """
@@ -259,10 +318,11 @@ class OkxGateway(BaseGateway):
         self.rest_api.stop()
         self.public_api.stop()
         self.private_api.stop()
+        self.business_api.stop()
 
     def on_order(self, order: OrderData) -> None:
         """
-        Save a copy of order and then push to event engine.
+        Cache order data and push an order event.
 
         Parameters:
             order: Order data object
@@ -284,7 +344,7 @@ class OkxGateway(BaseGateway):
 
     def on_contract(self, contract: ContractData) -> None:
         """
-        Save a copy of contract and then push to event engine.
+        Cache contract data and push a contract event.
 
         Parameters:
             contract: Contract data object
@@ -356,6 +416,57 @@ class OkxGateway(BaseGateway):
         )
         return order
 
+    def parse_spread_order_data(self, data: dict, gateway_name: str) -> OrderData:
+        """
+        Parse dict to spread order data.
+
+        This function converts OKX order data into a VeighNa OrderData object.
+        It extracts and maps all relevant fields from the exchange response.
+
+        Parameters:
+            data: Order data from OKX
+            gateway_name: Gateway name for identification
+
+        Returns:
+            OrderData: VeighNa order object
+        """
+        contract: ContractData = self.get_contract_by_name(data["sprdId"])
+
+        order_id: str = data["clOrdId"]
+        if order_id:
+            self.local_orderids.add(order_id)
+        else:
+            order_id = data["ordId"]
+
+        order: OrderData = OrderData(
+            symbol=contract.symbol,
+            exchange=Exchange.GLOBAL,
+            type=ORDERTYPE_OKX2VT[data["ordType"]],
+            orderid=order_id,
+            direction=DIRECTION_OKX2VT[data["side"]],
+            offset=Offset.NONE,
+            traded=float(data["accFillSz"]),
+            price=float(data["px"]),
+            volume=float(data["sz"]),
+            datetime=parse_timestamp(data["cTime"]),
+            status=STATUS_OKX2VT[data["state"]],
+            gateway_name=gateway_name,
+        )
+        return order
+
+    def process_timer_event(self, event: Event) -> None:
+        """
+        Process timer events for sending heartbeat messages.
+        """
+        self.ping_count += 1
+        if self.ping_count < self.ping_interval:
+            return
+        self.ping_count = 0
+
+        self.private_api.send_ping()
+        self.public_api.send_ping()
+        self.business_api.send_ping()
+
 
 class RestApi(RestClient):
     """The REST API of OkxGateway"""
@@ -434,6 +545,7 @@ class RestApi(RestClient):
         server: str,
         proxy_host: str,
         proxy_port: int,
+        spread_trading: bool
     ) -> None:
         """
         Start server connection.
@@ -448,6 +560,7 @@ class RestApi(RestClient):
             server: Server type ("REAL", "AWS", or "DEMO")
             proxy_host: Proxy server hostname or IP
             proxy_port: Proxy server port
+            spread_trading: Whether to enable spread trading
         """
         self.key = key
         self.secret = secret.encode()
@@ -473,6 +586,9 @@ class RestApi(RestClient):
         self.query_time()
         self.query_contract()
 
+        if spread_trading:
+            self.query_spread()
+
     def query_time(self) -> None:
         """
         Query server time.
@@ -514,6 +630,34 @@ class RestApi(RestClient):
                 params={"instType": inst_type}
             )
 
+    def query_spread(self) -> None:
+        """
+        Query available spreads.
+
+        This function sends a request to get all available spread contracts.
+        """
+        self.add_request(
+            "GET",
+            "/api/v5/sprd/spreads",
+            callback=self.on_query_spread
+        )
+
+    def query_spread_order(self) -> None:
+        """
+        Query open spread orders.
+
+        This function sends a request to get all active orders
+        that have not been fully filled or cancelled.
+        """
+        if not self.key:
+            return
+
+        self.add_request(
+            "GET",
+            "/api/v5/sprd/orders-pending",
+            callback=self.on_query_spread_order,
+        )
+
     def on_query_time(self, packet: dict, request: Request) -> None:
         """
         Callback of server time query.
@@ -565,6 +709,9 @@ class RestApi(RestClient):
         """
         data: list = packet["data"]
 
+        if not data:
+            return
+
         for d in data:
             name: str = d["instId"]
             product: Product = PRODUCT_OKX2VT[d["instType"]]
@@ -610,16 +757,76 @@ class RestApi(RestClient):
 
             self.gateway.on_contract(contract)
 
-        self.gateway.write_log(f"{d['instType']} contract data received")
+        inst_type: str = request.params["instType"]
+        self.gateway.write_log(f"{inst_type} contract data received")
 
         # Connect to websocket API after all contract data received
-        self.product_ready.add(contract.product)
+        self.product_ready.add(PRODUCT_OKX2VT[inst_type])
 
         if len(self.product_ready) == len(PRODUCT_OKX2VT):
             self.query_order()
 
             self.gateway.connect_ws_api()
 
+    def on_query_spread(self, packet: dict, request: Request) -> None:
+        """
+        Callback of available contracts query.
+
+        This function processes the exchange info response and
+        creates ContractData objects for each spread contract.
+
+        Parameters:
+            packet: Response data from the server
+            request: Original request object
+        """
+        data: list = packet["data"]
+
+        for d in data:
+            leg_symbols: list[str] = []
+            for leg in d["legs"]:
+                leg_name: str = leg["instId"]
+                leg_contract: ContractData = self.gateway.get_contract_by_name(leg_name)
+                leg_symbols.append(leg_contract.symbol)
+
+            contract: ContractData = ContractData(
+                symbol="-".join(leg_symbols),
+                exchange=Exchange.GLOBAL,
+                name=d["sprdId"],
+                product=Product.SPREAD,
+                size=float(d["lotSz"]),
+                pricetick=float(d["tickSz"]),
+                min_volume=float(d["minSz"]),
+                history_data=True,
+                net_position=True,
+                gateway_name=self.gateway_name,
+            )
+
+            self.gateway.on_contract(contract)
+
+        self.gateway.write_log("Spread contract data received")
+
+        self.query_spread_order()
+
+    def on_query_spread_order(self, packet: dict, request: Request) -> None:
+        """
+        Callback of open spread orders query.
+
+        This function processes the open orders response and
+        creates OrderData objects for each active spread order.
+
+        Parameters:
+            packet: Response data from the server
+            request: Original request object
+        """
+        for order_info in packet["data"]:
+            order: OrderData = self.gateway.parse_spread_order_data(
+                order_info,
+                self.gateway_name
+            )
+            self.gateway.on_order(order)
+
+        self.gateway.write_log("Spread order data received")
+
     def on_error(
         self,
         exc: type,
@@ -644,18 +851,15 @@ class RestApi(RestClient):
         msg: str = f"Exception catched by REST API: {detail}"
         self.gateway.write_log(msg)
 
-    def query_history(self, req: HistoryRequest) -> list[BarData]:
+    def _query_history(
+        self,
+        req: HistoryRequest,
+        path: str,
+        id_key: str,
+        bar_parser: Callable[[list, HistoryRequest], BarData]
+    ) -> list[BarData]:
         """
-        Query kline history data.
-
-        This function sends requests to get historical kline data
-        for a specific trading instrument and time period.
-
-        Parameters:
-            req: History request object containing query parameters
-
-        Returns:
-            list[BarData]: List of historical kline data bars
+        Generic helper to query kline history data.
         """
         # Validate symbol exists in contract map
         contract: ContractData | None = self.gateway.get_contract_by_symbol(req.symbol)
@@ -665,8 +869,6 @@ class RestApi(RestClient):
 
         # Initialize buffer for storing bars
         buf: dict[datetime, BarData] = {}
-
-        path: str = "/api/v5/market/history-candles"
         limit: str = "100"
 
         if not req.end:
@@ -678,7 +880,7 @@ class RestApi(RestClient):
         while True:
             # Create query params
             params: dict = {
-                "instId": contract.name,
+                id_key: contract.name,
                 "bar": INTERVAL_VT2OKX[req.interval],
                 "limit": limit,
                 "after": after
@@ -701,28 +903,13 @@ class RestApi(RestClient):
                 bar_data: list = data.get("data", None)
 
                 if not bar_data:
-                    msg: str = data["msg"]
+                    msg: str = data.get("msg", "No data returned.")
                     log_msg = f"No kline history data received, {msg}"
+                    self.gateway.write_log(log_msg)
                     break
 
                 for row in bar_data:
-                    ts, op, hp, lp, cp, volume, turnover, _, _ = row
-
-                    dt: datetime = parse_timestamp(ts)
-
-                    bar: BarData = BarData(
-                        symbol=req.symbol,
-                        exchange=req.exchange,
-                        datetime=dt,
-                        interval=req.interval,
-                        volume=float(volume),
-                        turnover=float(turnover),
-                        open_price=float(op),
-                        high_price=float(hp),
-                        low_price=float(lp),
-                        close_price=float(cp),
-                        gateway_name=self.gateway_name
-                    )
+                    bar: BarData = bar_parser(row, req)
                     buf[bar.datetime] = bar
 
                 begin: str = bar_data[-1][0]
@@ -746,31 +933,100 @@ class RestApi(RestClient):
         history: list[BarData] = [buf[i] for i in index]
         return history
 
+    def query_history(self, req: HistoryRequest) -> list[BarData]:
+        """
+        Query kline history data.
+
+        This function sends requests to get historical kline data
+        for a specific trading instrument and time period. It queries
+        data iteratively until the start time is reached.
 
-class PublicApi(WebsocketClient):
-    """The public websocket API of OkxGateway"""
+        Parameters:
+            req: History request object containing query parameters
 
-    def __init__(self, gateway: OkxGateway) -> None:
+        Returns:
+            list[BarData]: List of historical kline data bars
         """
-        The init method of the api.
+        def parse_bar(row: list, req: HistoryRequest) -> BarData:
+            ts, op, hp, lp, cp, volume, turnover, _, _ = row
+            dt: datetime = parse_timestamp(ts)
+            return BarData(
+                symbol=req.symbol,
+                exchange=req.exchange,
+                datetime=dt,
+                interval=req.interval,
+                volume=float(volume),
+                turnover=float(turnover),
+                open_price=float(op),
+                high_price=float(hp),
+                low_price=float(lp),
+                close_price=float(cp),
+                gateway_name=self.gateway_name
+            )
+
+        return self._query_history(
+            req=req,
+            path="/api/v5/market/history-candles",
+            id_key="instId",
+            bar_parser=parse_bar
+        )
+
+    def query_spread_history(self, req: HistoryRequest) -> list[BarData]:
+        """
+        Query kline history data for spread contracts.
+
+        This function sends requests to get historical kline data
+        for a specific spread contract and time period. It queries
+        data iteratively until the start time is reached.
 
         Parameters:
-            gateway: the parent gateway object for pushing callback data.
+            req: History request object containing query parameters
+
+        Returns:
+            list[BarData]: List of historical kline data bars
+        """
+        def parse_spread_bar(row: list, req: HistoryRequest) -> BarData:
+            ts, op, hp, lp, cp, volume, _ = row
+            dt: datetime = parse_timestamp(ts)
+            return BarData(
+                symbol=req.symbol,
+                exchange=req.exchange,
+                datetime=dt,
+                interval=req.interval,
+                volume=float(volume),
+                open_price=float(op),
+                high_price=float(hp),
+                low_price=float(lp),
+                close_price=float(cp),
+                gateway_name=self.gateway_name
+            )
+
+        return self._query_history(
+            req=req,
+            path="/api/v5/market/sprd-history-candles",
+            id_key="sprdId",
+            bar_parser=parse_spread_bar
+        )
+
+
+class WebsocketApi(WebsocketClient):
+    """The base websocket API of OkxGateway"""
+
+    def __init__(self, gateway: OkxGateway, name: str) -> None:
+        """
+        The init method of the api.
         """
         super().__init__()
 
+        self.name: str = name
         self.gateway: OkxGateway = gateway
         self.gateway_name: str = gateway.gateway_name
 
-        self.subscribed: dict[str, SubscribeRequest] = {}
-        self.ticks: dict[str, TickData] = {}
-
-        self.callbacks: dict[str, Callable] = {
-            "tickers": self.on_ticker,
-            "books5": self.on_depth
-        }
+        self.connected: bool = False
+        self.callbacks: dict[str, Callable] = {}
+        self.server_hosts: dict[str, str] = {}
 
-    def connect(
+    def connect_(
         self,
         server: str,
         proxy_host: str,
@@ -778,24 +1034,94 @@ class PublicApi(WebsocketClient):
     ) -> None:
         """
         Start server connection.
+        """
+        host: str = self.server_hosts[server]
+        self.init(host, proxy_host, proxy_port, 20)
+        self.start()
+
+    def on_connected(self) -> None:
+        """
+        Callback when server is connected.
+        """
+        self.connected = True
+        self.gateway.write_log(f"{self.name} connected")
+
+    def on_disconnected(self) -> None:
+        """
+        Callback when server is disconnected.
+        """
+        self.connected = False
+        self.gateway.write_log(f"{self.name} disconnected")
+
+    def on_message(self, message: str) -> None:
+        """
+        Callback when websocket app receives new message.
+        """
+        if message == "pong":
+            return
+        self.on_packet(json.loads(message))
+
+    def on_packet(self, packet: dict) -> None:
+        """
+        Callback of data update.
+        """
+        if "event" in packet:
+            cb_name: str = packet["event"]
+        elif "op" in packet:
+            cb_name = packet["op"]
+        elif "arg" in packet and "channel" in packet["arg"]:
+            cb_name = packet["arg"]["channel"]
+        else:
+            return
+
+        callback: Callable | None = self.callbacks.get(cb_name, None)
+        if callback:
+            callback(packet)
+
+    def on_error(self, value: Exception) -> None:
+        """
+        General error callback.
+        """
+        self.gateway.write_log(f"Exception catched by {self.name}: {value}")
+
+    def send_ping(self) -> None:
+        """Send heartbeat ping to server"""
+        if self.connected:
+            self.wsapp.send("ping")
 
-        This method establishes a websocket connection to OKX public data stream.
+
+class PublicApi(WebsocketApi):
+    """The public websocket API of OkxGateway"""
+
+    def __init__(self, gateway: OkxGateway) -> None:
+        """
+        The init method of the api.
 
         Parameters:
-            server: Server type ("REAL", "AWS", or "DEMO")
-            proxy_host: Proxy server hostname or IP
-            proxy_port: Proxy server port
+            gateway: the parent gateway object for pushing callback data.
         """
-        server_hosts: dict[str, str] = {
+        super().__init__(gateway, "Public API")
+
+        self.subscribed: dict[str, SubscribeRequest] = {}
+        self.ticks: dict[str, TickData] = {}
+
+        self.callbacks: dict[str, Callable] = {
+            "tickers": self.on_ticker,
+            "books5": self.on_depth,
+            "error": self.on_api_error
+        }
+
+        self.server_hosts: dict[str, str] = {
             "REAL": REAL_PUBLIC_HOST,
             "AWS": AWS_PUBLIC_HOST,
             "DEMO": DEMO_PUBLIC_HOST,
         }
 
-        host: str = server_hosts[server]
-        self.init(host, proxy_host, proxy_port, 20)
-
-        self.start()
+    def connect(self, server: str, proxy_host: str, proxy_port: int) -> None:
+        """
+        Start server connection.
+        """
+        self.connect_(server, proxy_host, proxy_port)
 
     def subscribe(self, req: SubscribeRequest) -> None:
         """
@@ -848,76 +1174,31 @@ class PublicApi(WebsocketClient):
         is successfully established. It logs the connection status and
         resubscribes to previously subscribed market data channels.
         """
-        self.gateway.write_log("Public API connected")
+        super().on_connected()
 
         for req in list(self.subscribed.values()):
             self.subscribe(req)
 
-    def on_disconnected(self) -> None:
+    def on_api_error(self, packet: dict) -> None:
         """
-        Callback when server is disconnected.
-
-        This function is called when the websocket connection is closed.
-        It logs the disconnection status.
+        Callback of API error.
         """
-        self.gateway.write_log("Public API disconnected")
+        code: str = packet["code"]
+        msg: str = packet["msg"]
+        self.gateway.write_log(f"{self.name} request failed, status code: {code}, message: {msg}")
 
-    def on_packet(self, packet: dict) -> None:
+    def on_ticker(self, packet: dict) -> None:
         """
-        Callback of data update.
+        Callback of ticker update.
 
-        This function processes different types of market data updates,
-        including ticker and depth data. It routes the data to the
-        appropriate callback function based on the channel.
+        This function processes the ticker data updates and
+        updates the corresponding TickData objects.
 
         Parameters:
-            packet: JSON data received from websocket
+            packet: Ticker data from websocket
         """
-        if "event" in packet:
-            event: str = packet["event"]
-            if event == "subscribe":
-                return
-            elif event == "error":
-                code: str = packet["code"]
-                msg: str = packet["msg"]
-                self.gateway.write_log(f"Public API request failed, status code: {code}, message: {msg}")
-        else:
-            channel: str = packet["arg"]["channel"]
-            callback: Callable | None = self.callbacks.get(channel, None)
-
-            if callback:
-                data: list = packet["data"]
-                callback(data)
-
-    def on_error(self, exc: type, value: Exception, tb: TracebackType) -> None:
-        """
-        General error callback.
-
-        This function is called when an exception occurs in the websocket connection.
-        It logs the exception details for troubleshooting.
-
-        Parameters:
-            exc: Type of the exception
-            value: Exception instance
-            tb: Traceback object
-        """
-        detail: str = self.exception_detail(exc, value, tb)
-
-        msg: str = f"Exception catched by Public API: {detail}"
-        self.gateway.write_log(msg)
-
-    def on_ticker(self, data: list) -> None:
-        """
-        Callback of ticker update.
-
-        This function processes the ticker data updates and
-        updates the corresponding TickData objects.
-
-        Parameters:
-            data: Ticker data from websocket
-        """
-        for d in data:
-            tick: TickData = self.ticks[d["instId"]]
+        for d in packet["data"]:
+            tick: TickData = self.ticks[d["instId"]]
 
             tick.last_price = float(d["last"])
             tick.open_price = float(d["open24h"])
@@ -929,7 +1210,7 @@ class PublicApi(WebsocketClient):
             tick.datetime = parse_timestamp(d["ts"])
             self.gateway.on_tick(copy(tick))
 
-    def on_depth(self, data: list) -> None:
+    def on_depth(self, packet: dict) -> None:
         """
         Callback of depth update.
 
@@ -937,9 +1218,9 @@ class PublicApi(WebsocketClient):
         and updates the corresponding TickData objects.
 
         Parameters:
-            data: Depth data from websocket
+            packet: Depth data from websocket
         """
-        for d in data:
+        for d in packet["data"]:
             tick: TickData = self.ticks[d["instId"]]
             bids: list = d["bids"]
             asks: list = d["asks"]
@@ -958,7 +1239,7 @@ class PublicApi(WebsocketClient):
             self.gateway.on_tick(copy(tick))
 
 
-class PrivateApi(WebsocketClient):
+class PrivateApi(WebsocketApi):
     """The private websocket API of OkxGateway"""
 
     def __init__(self, gateway: OkxGateway) -> None:
@@ -968,10 +1249,8 @@ class PrivateApi(WebsocketClient):
         Parameters:
             gateway: the parent gateway object for pushing callback data.
         """
-        super().__init__()
+        super().__init__(gateway, "Private API")
 
-        self.gateway: OkxGateway = gateway
-        self.gateway_name: str = gateway.gateway_name
         self.local_orderids: set[str] = gateway.local_orderids
 
         self.key: str = ""
@@ -992,6 +1271,12 @@ class PrivateApi(WebsocketClient):
             "error": self.on_api_error
         }
 
+        self.server_hosts: dict[str, str] = {
+            "REAL": REAL_PRIVATE_HOST,
+            "AWS": AWS_PRIVATE_HOST,
+            "DEMO": DEMO_PRIVATE_HOST,
+        }
+
         self.reqid_order_map: dict[str, OrderData] = {}
 
     def connect(
@@ -1022,16 +1307,7 @@ class PrivateApi(WebsocketClient):
 
         self.connect_time = int(datetime.now().strftime("%y%m%d%H%M%S"))
 
-        server_hosts: dict[str, str] = {
-            "REAL": REAL_PRIVATE_HOST,
-            "AWS": AWS_PRIVATE_HOST,
-            "DEMO": DEMO_PRIVATE_HOST,
-        }
-
-        host: str = server_hosts[server]
-        self.init(host, proxy_host, proxy_port, 20)
-
-        self.start()
+        self.connect_(server, proxy_host, proxy_port)
 
     def on_connected(self) -> None:
         """
@@ -1041,53 +1317,9 @@ class PrivateApi(WebsocketClient):
         is successfully established. It logs the connection status and
         initiates the login process.
         """
-        self.gateway.write_log("Private websocket API connected")
+        super().on_connected()
         self.login()
 
-    def on_disconnected(self) -> None:
-        """
-        Callback when server is disconnected.
-
-        This function is called when the websocket connection is closed.
-        It logs the disconnection status.
-        """
-        self.gateway.write_log("Private API disconnected")
-
-    def on_packet(self, packet: dict) -> None:
-        """
-        Callback of data update.
-
-        This function processes different types of private data updates,
-        including orders, account balance, and positions. It routes the data
-        to the appropriate callback function.
-
-        Parameters:
-            packet: JSON data received from websocket
-        """
-        if "event" in packet:
-            cb_name: str = packet["event"]
-        elif "op" in packet:
-            cb_name = packet["op"]
-        else:
-            cb_name = packet["arg"]["channel"]
-
-        callback: Callable | None = self.callbacks.get(cb_name, None)
-        if callback:
-            callback(packet)
-
-    def on_error(self, e: Exception) -> None:
-        """
-        General error callback.
-
-        This function is called when an exception occurs in the websocket connection.
-        It logs the exception details for troubleshooting.
-
-        Parameters:
-            e: The exception that was raised
-        """
-        msg: str = f"Private channel exception triggered: {e}"
-        self.gateway.write_log(msg)
-
     def on_api_error(self, packet: dict) -> None:
         """
         Callback of API error.
@@ -1103,7 +1335,7 @@ class PrivateApi(WebsocketClient):
         msg: str = packet["msg"]
 
         # Log the error with details for debugging
-        self.gateway.write_log(f"Private API request failed, status code: {code}, message: {msg}")
+        self.gateway.write_log(f"{self.name} request failed, status code: {code}, message: {msg}")
 
     def on_login(self, packet: dict) -> None:
         """
@@ -1116,10 +1348,10 @@ class PrivateApi(WebsocketClient):
             packet: Login response data from websocket
         """
         if packet["code"] == '0':
-            self.gateway.write_log("Private API login successful")
+            self.gateway.write_log(f"{self.name} login successful")
             self.subscribe_topic()
         else:
-            self.gateway.write_log("Private API login failed")
+            self.gateway.write_log(f"{self.name} login failed")
 
     def on_order(self, packet: dict) -> None:
         """
@@ -1288,6 +1520,9 @@ class PrivateApi(WebsocketClient):
         This function prepares and sends a login request to authenticate
         with the websocket API using API credentials.
         """
+        if not self.key:
+            return
+
         timestamp: str = str(time.time())
         msg: str = timestamp + "GET" + "/users/self/verify"
         signature: bytes = generate_signature(msg, self.secret)
@@ -1361,7 +1596,7 @@ class PrivateApi(WebsocketClient):
         orderid = f"{self.connect_time}{count_str}"
 
         # Prepare order parameters for OKX API
-        args: dict = {
+        arg: dict = {
             "instId": contract.name,
             "clOrdId": orderid,
             "side": DIRECTION_VT2OKX[req.direction],
@@ -1373,16 +1608,16 @@ class PrivateApi(WebsocketClient):
         # Set trading mode based on product type
         # "cash" for spot trading, "cross" for futures/swap with cross margin
         if contract.product == Product.SPOT:
-            args["tdMode"] = "cash"
+            arg["tdMode"] = "cash"
         else:
-            args["tdMode"] = "cross"
+            arg["tdMode"] = "cross"
 
         # Create websocket request with unique request ID
         self.reqid += 1
         packet: dict = {
             "id": str(self.reqid),
             "op": "order",
-            "args": [args]
+            "args": [arg]
         }
         self.send_packet(packet)
 
@@ -1409,24 +1644,510 @@ class PrivateApi(WebsocketClient):
             self.gateway.write_log(f"Cancel order failed, symbol not found: {req.symbol}")
             return
 
-        # Initialize cancel parameters with instrument ID
-        args: dict = {"instId": contract.name}
+        # Initialize cancel parameters
+        arg: dict = {}
 
         # Determine the type of order ID to use for cancellation
         # OKX supports both client order ID and exchange order ID for cancellation
         if req.orderid in self.local_orderids:
             # Use client order ID if it was created by this gateway instance
-            args["clOrdId"] = req.orderid
+            arg["clOrdId"] = req.orderid
         else:
             # Use exchange order ID if it came from another source
-            args["ordId"] = req.orderid
+            arg["ordId"] = req.orderid
 
         # Create websocket request with unique request ID
         self.reqid += 1
         packet: dict = {
             "id": str(self.reqid),
             "op": "cancel-order",
-            "args": [args]
+            "args": [arg]
+        }
+
+        # Send the cancellation request
+        self.send_packet(packet)
+
+
+class BusinessApi(WebsocketApi):
+    """The business websocket API of OkxGateway"""
+
+    def __init__(self, gateway: OkxGateway) -> None:
+        """
+        The init method of the api.
+
+        Parameters:
+            gateway: the parent gateway object for pushing callback data.
+        """
+        super().__init__(gateway, "Business API")
+
+        self.local_orderids: set[str] = gateway.local_orderids
+        self.subscribed: dict[str, SubscribeRequest] = {}
+        self.ticks: dict[str, TickData] = {}
+
+        self.key: str = ""
+        self.secret: bytes = b""
+        self.passphrase: str = ""
+
+        self.reqid: int = 0
+        self.order_count: int = 0
+        self.connect_time: int = 0
+
+        self.callbacks: dict[str, Callable] = {
+            "login": self.on_login,
+            "sprd-orders": self.on_order,
+            "sprd-trades": self.on_trade,
+            "sprd-tickers": self.on_ticker,
+            "sprd-books5": self.on_depth,
+            "order": self.on_send_order,
+            "cancel-order": self.on_cancel_order,
+            "error": self.on_api_error
+        }
+
+        self.server_hosts: dict[str, str] = {
+            "REAL": REAL_BUSINESS_HOST,
+            "AWS": AWS_BUSINESS_HOST,
+            "DEMO": DEMO_BUSINESS_HOST,
+        }
+
+        self.reqid_order_map: dict[str, OrderData] = {}
+
+    def connect(
+        self,
+        key: str,
+        secret: str,
+        passphrase: str,
+        server: str,
+        proxy_host: str,
+        proxy_port: int,
+    ) -> None:
+        """
+        Start server connection.
+
+        This method establishes a websocket connection to OKX private data stream.
+
+        Parameters:
+            key: API Key for authentication
+            secret: API Secret for request signing
+            passphrase: API Passphrase for authentication
+            server: Server type ("REAL", "AWS", or "DEMO")
+            proxy_host: Proxy server hostname or IP
+            proxy_port: Proxy server port
+        """
+        self.key = key
+        self.secret = secret.encode()
+        self.passphrase = passphrase
+
+        self.connect_time = int(datetime.now().strftime("%y%m%d%H%M%S"))
+
+        self.connect_(server, proxy_host, proxy_port)
+
+    def subscribe(self, req: SubscribeRequest) -> None:
+        """
+        Subscribe to market data.
+
+        This function sends subscription requests for ticker and depth data
+        for the specified trading instrument.
+
+        Parameters:
+            req: Subscription request object containing symbol information
+        """
+        # Get contract by VeighNa symbol
+        contract: ContractData | None = self.gateway.get_contract_by_symbol(req.symbol)
+        if not contract:
+            self.gateway.write_log(f"Failed to subscribe data, symbol not found: {req.symbol}")
+            return
+
+        # Add subscribe record
+        self.subscribed[req.vt_symbol] = req
+
+        # Create tick object
+        tick: TickData = TickData(
+            symbol=req.symbol,
+            exchange=req.exchange,
+            name=contract.name,
+            datetime=datetime.now(CHINA_TZ),
+            gateway_name=self.gateway_name,
+        )
+        self.ticks[contract.name] = tick
+
+        # Send request to subscribe
+        args: list = []
+        for channel in ["sprd-tickers", "sprd-books5"]:
+            args.append({
+                "channel": channel,
+                "sprdId": contract.name
+            })
+
+        packet: dict = {
+            "op": "subscribe",
+            "args": args
+        }
+
+        self.send_packet(packet)
+
+    def on_connected(self) -> None:
+        """
+        Callback when server is connected.
+
+        This function is called when the websocket connection to the server
+        is successfully established. It logs the connection status and
+        initiates the login process.
+        """
+        super().on_connected()
+
+        for req in list(self.subscribed.values()):
+            self.subscribe(req)
+
+        self.login()
+
+    def on_api_error(self, packet: dict) -> None:
+        """
+        Callback of API error.
+
+        This function processes error responses from the websocket API.
+        It logs the error details for troubleshooting.
+
+        Parameters:
+            packet: Error data from websocket
+        """
+        # Extract error code and message from the response
+        code: str = packet["code"]
+        msg: str = packet["msg"]
+
+        # Log the error with details for debugging
+        self.gateway.write_log(f"{self.name} request failed, status code: {code}, message: {msg}")
+
+    def on_login(self, packet: dict) -> None:
+        """
+        Callback of user login.
+
+        This function processes the login response and subscribes to
+        private data channels if login is successful.
+
+        Parameters:
+            packet: Login response data from websocket
+        """
+        if packet["code"] == '0':
+            self.gateway.write_log(f"{self.name} login successful")
+            self.subscribe_topic()
+        else:
+            self.gateway.write_log(f"{self.name} login failed")
+
+    def on_order(self, packet: dict) -> None:
+        """
+        Callback of order update.
+
+        This function processes order updates and trade executions.
+        It creates OrderData and TradeData objects and pushes them to the gateway.
+
+        Parameters:
+            packet: Order update data from websocket
+        """
+        # Extract order data from packet
+        data: list = packet["data"]
+        for d in data:
+            # Create order object from data
+            order: OrderData = self.gateway.parse_spread_order_data(d, self.gateway_name)
+            self.gateway.on_order(order)
+
+    def on_trade(self, packet: dict) -> None:
+        """
+        Callback of trade update.
+
+        This function processes trade updates and creates TradeData objects.
+
+        Parameters:
+            packet: Order update data from websocket
+        """
+        # Extract trade data from packet
+        for d in packet["data"]:
+            # Get order id
+            if d["clOrdId"]:
+                order_id: str = d["clOrdId"]
+            else:
+                order_id = d["ordId"]
+
+            dt: datetime = parse_timestamp(d["ts"])
+
+            for leg in d["legs"]:
+                name: str = leg["instId"]
+                contract: ContractData | None = self.gateway.get_contract_by_name(name)
+                if not contract:
+                    self.gateway.write_log(f"Failed to parse trade data, contract not found: {name}")
+                    continue
+
+                trade: TradeData = TradeData(
+                    symbol=contract.symbol,
+                    exchange=Exchange.GLOBAL,
+                    orderid=order_id,
+                    tradeid=leg["tradeId"],
+                    direction=DIRECTION_OKX2VT[leg["side"]],
+                    price=float(leg["px"]),
+                    volume=float(leg["sz"]),
+                    datetime=dt,
+                    gateway_name=self.gateway_name,
+                )
+                self.gateway.on_trade(trade)
+
+    def on_send_order(self, packet: dict) -> None:
+        """
+        Callback of send_order.
+
+        This function processes the response to an order placement request.
+        It handles errors and rejection cases.
+
+        Parameters:
+            packet: Order response data from websocket
+        """
+        data: list = packet["data"]
+
+        # Wrong parameters
+        if packet["code"] != "0":
+            if not data:
+                order: OrderData | None = self.reqid_order_map.get(packet["id"], None)
+                if order:
+                    order.status = Status.REJECTED
+                    self.gateway.on_order(order)
+
+                return
+
+        # Failed to process
+        for d in data:
+            code: str = d["sCode"]
+            if code == "0":
+                return
+
+            orderid: str = d["clOrdId"]
+            order = self.gateway.get_order(orderid)
+            if not order:
+                return
+
+            order.status = Status.REJECTED
+            self.gateway.on_order(copy(order))
+
+            msg: str = d["sMsg"]
+            self.gateway.write_log(f"Send order failed, status code: {code}, message: {msg}")
+
+    def on_cancel_order(self, packet: dict) -> None:
+        """
+        Callback of cancel_order.
+
+        This function processes the response to an order cancellation request.
+        It handles errors and logs appropriate messages.
+
+        Parameters:
+            packet: Cancel response data from websocket
+        """
+        # Wrong parameters
+        if packet["code"] != "0":
+            code: str = packet["code"]
+            msg: str = packet["msg"]
+            self.gateway.write_log(f"Cancel order failed, status code: {code}, message: {msg}")
+            return
+
+        # Failed to process
+        data: list = packet["data"]
+        for d in data:
+            code = d["sCode"]
+            if code == "0":
+                return
+
+            msg = d["sMsg"]
+            self.gateway.write_log(f"Cancel order failed, status code: {code}, message: {msg}")
+
+    def on_ticker(self, packet: dict) -> None:
+        """
+        Callback of ticker update.
+
+        This function processes the ticker data updates and
+        updates the corresponding TickData objects.
+
+        Parameters:
+            packet: Ticker data from websocket
+        """
+        for d in packet["data"]:
+            if not d["last"]:
+                return
+
+            tick: TickData = self.ticks[d["sprdId"]]
+
+            tick.last_price = float(d["last"])
+            tick.last_volume = float(d["lastSz"])
+            tick.open_price = float(d["open24h"])
+            tick.high_price = float(d["high24h"])
+            tick.low_price = float(d["low24h"])
+            tick.volume = float(d["vol24h"])
+            tick.datetime = parse_timestamp(d["ts"])
+
+            self.gateway.on_tick(copy(tick))
+
+    def on_depth(self, packet: dict) -> None:
+        """
+        Callback of depth update.
+
+        This function processes the order book depth data updates
+        and updates the corresponding TickData objects.
+
+        Parameters:
+            packet: Depth data from websocket
+        """
+        name: str = packet["arg"]["sprdId"]
+        tick: TickData = self.ticks[name]
+
+        for d in packet["data"]:
+            bids: list = d["bids"]
+            asks: list = d["asks"]
+
+            for n in range(min(5, len(bids))):
+                price, volume, _ = bids[n]
+                tick.__setattr__("bid_price_%s" % (n + 1), float(price))
+                tick.__setattr__("bid_volume_%s" % (n + 1), float(volume))
+
+            for n in range(min(5, len(asks))):
+                price, volume, _ = asks[n]
+                tick.__setattr__("ask_price_%s" % (n + 1), float(price))
+                tick.__setattr__("ask_volume_%s" % (n + 1), float(volume))
+
+            tick.datetime = parse_timestamp(d["ts"])
+            self.gateway.on_tick(copy(tick))
+
+    def login(self) -> None:
+        """
+        User login.
+
+        This function prepares and sends a login request to authenticate
+        with the websocket API using API credentials.
+        """
+        if not self.key:
+            return
+
+        timestamp: str = str(time.time())
+        msg: str = timestamp + "GET" + "/users/self/verify"
+        signature: bytes = generate_signature(msg, self.secret)
+
+        packet: dict = {
+            "op": "login",
+            "args":
+            [
+                {
+                    "apiKey": self.key,
+                    "passphrase": self.passphrase,
+                    "timestamp": timestamp,
+                    "sign": signature.decode("utf-8")
+                }
+            ]
+        }
+        self.send_packet(packet)
+
+    def subscribe_topic(self) -> None:
+        """
+        Subscribe to private data channels.
+
+        This function sends subscription requests for order, account, and
+        position updates after successful login.
+        """
+        packet: dict = {
+            "op": "subscribe",
+            "args": [
+                {
+                    "channel": "sprd-orders"
+                },
+                {
+                    "channel": "sprd-trades"
+                }
+            ]
+        }
+        self.send_packet(packet)
+
+    def send_order(self, req: OrderRequest) -> str:
+        """
+        Send new order to OKX.
+
+        This function creates and sends a new order request to the exchange.
+        It handles different order types and trading modes.
+
+        Parameters:
+            req: Order request object containing order details
+
+        Returns:
+            str: The VeighNa order ID if successful, empty string otherwise
+        """
+        # Validate order type is supported by OKX
+        if req.type not in ORDERTYPE_VT2OKX:
+            self.gateway.write_log(f"Send order failed, order type not supported: {req.type.value}")
+            return ""
+
+        # Validate symbol exists in contract map
+        contract: ContractData | None = self.gateway.get_contract_by_symbol(req.symbol)
+        if not contract:
+            self.gateway.write_log(f"Send order failed, symbol not found: {req.symbol}")
+            return ""
+
+        # Generate unique local order ID
+        self.order_count += 1
+        count_str = str(self.order_count).rjust(6, "0")
+        orderid = f"{self.connect_time}{count_str}"
+
+        # Prepare order parameters for OKX API
+        arg: dict = {
+            "sprdId": contract.name,
+            "clOrdId": orderid,
+            "side": DIRECTION_VT2OKX[req.direction],
+            "ordType": ORDERTYPE_VT2OKX[req.type],
+            "px": str(req.price),
+            "sz": str(req.volume)
+        }
+
+        # Create websocket request with unique request ID
+        self.reqid += 1
+        packet: dict = {
+            "id": str(self.reqid),
+            "op": "sprd-order",
+            "args": [arg]
+        }
+        self.send_packet(packet)
+
+        # Create order data object and push to gateway
+        order: OrderData = req.create_order_data(orderid, self.gateway_name)
+        self.gateway.on_order(order)
+
+        # Return VeighNa order ID (gateway_name.orderid)
+        return str(order.vt_orderid)
+
+    def cancel_order(self, req: CancelRequest) -> None:
+        """
+        Cancel existing order on OKX.
+
+        This function sends a request to cancel an existing order on the exchange.
+        It determines whether to use client order ID or exchange order ID.
+
+        Parameters:
+            req: Cancel request object containing order details
+        """
+        # Validate symbol exists in contract map
+        contract: ContractData | None = self.gateway.get_contract_by_symbol(req.symbol)
+        if not contract:
+            self.gateway.write_log(f"Cancel order failed, symbol not found: {req.symbol}")
+            return
+
+        # Initialize cancel parameters
+        arg: dict = {}
+
+        # Determine the type of order ID to use for cancellation
+        # OKX supports both client order ID and exchange order ID for cancellation
+        if req.orderid in self.local_orderids:
+            # Use client order ID if it was created by this gateway instance
+            arg["clOrdId"] = req.orderid
+        else:
+            # Use exchange order ID if it came from another source
+            arg["ordId"] = req.orderid
+
+        # Create websocket request with unique request ID
+        self.reqid += 1
+        packet: dict = {
+            "id": str(self.reqid),
+            "op": "sprd-cancel-order",
+            "args": [arg]
         }
 
         # Send the cancellation request