ccxt 4.2.76__py2.py3-none-any.whl → 4.4.48__py2.py3-none-any.whl

ccxt/pro/woo.py

@@ -21,26 +21,28 @@ class woo(ccxt.async_support.woo):
             'has': {
                 'ws': True,
                 'watchBalance': True,
-                'watchMyTrades': False,
+                'watchMyTrades': True,
                 'watchOHLCV': True,
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchTicker': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': False,
                 'watchPositions': True,
             },
             'urls': {
                 'api': {
                     'ws': {
-                        'public': 'wss://wss.woo.org/ws/stream',
-                        'private': 'wss://wss.woo.network/v2/ws/private/stream',
+                        'public': 'wss://wss.woox.io/ws/stream',
+                        'private': 'wss://wss.woox.io/v2/ws/private/stream',
                     },
                 },
                 'test': {
                     'ws': {
-                        'public': 'wss://wss.staging.woo.org/ws/stream',
-                        'private': 'wss://wss.staging.woo.org/v2/ws/private/stream',
+                        'public': 'wss://wss.staging.woox.io/ws/stream',
+                        'private': 'wss://wss.staging.woox.io/v2/ws/private/stream',
                     },
                 },
             },
@@ -60,7 +62,14 @@ class woo(ccxt.async_support.woo):
             },
             'streaming': {
                 'ping': self.ping,
-                'keepAlive': 10000,
+                'keepAlive': 9000,
+            },
+            'exceptions': {
+                'ws': {
+                    'exact': {
+                        'Auth is needed.': AuthenticationError,
+                    },
+                },
             },
         })
 
@@ -72,35 +81,61 @@ class woo(ccxt.async_support.woo):
         return newValue
 
     async def watch_public(self, messageHash, message):
-        self.check_required_uid()
-        url = self.urls['api']['ws']['public'] + '/' + self.uid
+        urlUid = '/' + self.uid if (self.uid) else ''
+        url = self.urls['api']['ws']['public'] + urlUid
         requestId = self.request_id(url)
-        subscribe = {
+        subscribe: dict = {
             'id': requestId,
         }
         request = self.extend(subscribe, message)
         return await self.watch(url, messageHash, request, messageHash, subscribe)
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
+        """
+
+        https://docs.woox.io/#orderbookupdate
+        https://docs.woox.io/#orderbook
+
+        watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :param str symbol: unified symbol of the market to fetch the order book for
+        :param int [limit]: the maximum amount of order book entries to return.
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.method]: either(default) 'orderbook' or 'orderbookupdate', default is 'orderbook'
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
         await self.load_markets()
-        name = 'orderbook'
+        method = None
+        method, params = self.handle_option_and_params(params, 'watchOrderBook', 'method', 'orderbook')
         market = self.market(symbol)
-        topic = market['id'] + '@' + name
-        request = {
+        topic = market['id'] + '@' + method
+        urlUid = '/' + self.uid if (self.uid) else ''
+        url = self.urls['api']['ws']['public'] + urlUid
+        requestId = self.request_id(url)
+        request: dict = {
             'event': 'subscribe',
             'topic': topic,
+            'id': requestId,
         }
-        message = self.extend(request, params)
-        orderbook = await self.watch_public(topic, message)
+        subscription: dict = {
+            'id': str(requestId),
+            'name': method,
+            'symbol': symbol,
+            'limit': limit,
+            'params': params,
+        }
+        if method == 'orderbookupdate':
+            subscription['method'] = self.handle_order_book_subscription
+        orderbook = await self.watch(url, topic, self.extend(request, params), topic, subscription)
         return orderbook.limit()
 
     def handle_order_book(self, client: Client, message):
         #
         #     {
-        #         "topic": "PERP_BTC_USDT@orderbook",
-        #         "ts": 1650121915308,
+        #         "topic": "PERP_BTC_USDT@orderbookupdate",
+        #         "ts": 1722500373999,
         #         "data": {
         #             "symbol": "PERP_BTC_USDT",
+        #             "prevTs": 1722500373799,
         #             "bids": [
         #                 [
         #                     0.30891,
@@ -116,25 +151,108 @@ class woo(ccxt.async_support.woo):
         #         }
         #     }
         #
-        data = self.safe_value(message, 'data')
+        data = self.safe_dict(message, 'data')
         marketId = self.safe_string(data, 'symbol')
         market = self.safe_market(marketId)
         symbol = market['symbol']
         topic = self.safe_string(message, 'topic')
-        orderbook = self.safe_value(self.orderbooks, symbol)
-        if orderbook is None:
-            orderbook = self.order_book({})
+        method = self.safe_string(topic.split('@'), 1)
+        if method == 'orderbookupdate':
+            if not (symbol in self.orderbooks):
+                return
+            orderbook = self.orderbooks[symbol]
+            timestamp = self.safe_integer(orderbook, 'timestamp')
+            if timestamp is None:
+                orderbook.cache.append(message)
+            else:
+                try:
+                    ts = self.safe_integer(message, 'ts')
+                    if ts > timestamp:
+                        self.handle_order_book_message(client, message, orderbook)
+                        client.resolve(orderbook, topic)
+                except Exception as e:
+                    del self.orderbooks[symbol]
+                    del client.subscriptions[topic]
+                    client.reject(e, topic)
+        else:
+            if not (symbol in self.orderbooks):
+                defaultLimit = self.safe_integer(self.options, 'watchOrderBookLimit', 1000)
+                subscription = client.subscriptions[topic]
+                limit = self.safe_integer(subscription, 'limit', defaultLimit)
+                self.orderbooks[symbol] = self.order_book({}, limit)
+            orderbook = self.orderbooks[symbol]
+            timestamp = self.safe_integer(message, 'ts')
+            snapshot = self.parse_order_book(data, symbol, timestamp, 'bids', 'asks')
+            orderbook.reset(snapshot)
+            client.resolve(orderbook, topic)
+
+    def handle_order_book_subscription(self, client: Client, message, subscription):
+        defaultLimit = self.safe_integer(self.options, 'watchOrderBookLimit', 1000)
+        limit = self.safe_integer(subscription, 'limit', defaultLimit)
+        symbol = self.safe_string(subscription, 'symbol')  # watchOrderBook
+        if symbol in self.orderbooks:
+            del self.orderbooks[symbol]
+        self.orderbooks[symbol] = self.order_book({}, limit)
+        self.spawn(self.fetch_order_book_snapshot, client, message, subscription)
+
+    async def fetch_order_book_snapshot(self, client, message, subscription):
+        symbol = self.safe_string(subscription, 'symbol')
+        messageHash = self.safe_string(message, 'topic')
+        try:
+            defaultLimit = self.safe_integer(self.options, 'watchOrderBookLimit', 1000)
+            limit = self.safe_integer(subscription, 'limit', defaultLimit)
+            params = self.safe_value(subscription, 'params')
+            snapshot = await self.fetch_rest_order_book_safe(symbol, limit, params)
+            if self.safe_value(self.orderbooks, symbol) is None:
+                # if the orderbook is dropped before the snapshot is received
+                return
+            orderbook = self.orderbooks[symbol]
+            orderbook.reset(snapshot)
+            messages = orderbook.cache
+            for i in range(0, len(messages)):
+                messageItem = messages[i]
+                ts = self.safe_integer(messageItem, 'ts')
+                if ts < orderbook['timestamp']:
+                    continue
+                else:
+                    self.handle_order_book_message(client, messageItem, orderbook)
+            self.orderbooks[symbol] = orderbook
+            client.resolve(orderbook, messageHash)
+        except Exception as e:
+            del client.subscriptions[messageHash]
+            client.reject(e, messageHash)
+
+    def handle_order_book_message(self, client: Client, message, orderbook):
+        data = self.safe_dict(message, 'data')
+        self.handle_deltas(orderbook['asks'], self.safe_value(data, 'asks', []))
+        self.handle_deltas(orderbook['bids'], self.safe_value(data, 'bids', []))
         timestamp = self.safe_integer(message, 'ts')
-        snapshot = self.parse_order_book(data, symbol, timestamp, 'bids', 'asks')
-        orderbook.reset(snapshot)
-        client.resolve(orderbook, topic)
+        orderbook['timestamp'] = timestamp
+        orderbook['datetime'] = self.iso8601(timestamp)
+        return orderbook
+
+    def handle_delta(self, bookside, delta):
+        price = self.safe_float_2(delta, 'price', 0)
+        amount = self.safe_float_2(delta, 'quantity', 1)
+        bookside.store(price, amount)
+
+    def handle_deltas(self, bookside, deltas):
+        for i in range(0, len(deltas)):
+            self.handle_delta(bookside, deltas[i])
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
+        """
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :param str symbol: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
         await self.load_markets()
         name = 'ticker'
         market = self.market(symbol)
+        symbol = market['symbol']
         topic = market['id'] + '@' + name
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'topic': topic,
         }
@@ -207,10 +325,20 @@ class woo(ccxt.async_support.woo):
         return message
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+
+        https://docs.woox.io/#24h-tickers
+
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
         await self.load_markets()
+        symbols = self.market_symbols(symbols)
         name = 'tickers'
         topic = name
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'topic': topic,
         }
@@ -260,7 +388,88 @@ class woo(ccxt.async_support.woo):
             result.append(ticker)
         client.resolve(result, topic)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+
+        https://docs.woox.io/#bbos
+
+        watches best bid & ask for symbols
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        name = 'bbos'
+        topic = name
+        request: dict = {
+            'event': 'subscribe',
+            'topic': topic,
+        }
+        message = self.extend(request, params)
+        tickers = await self.watch_public(topic, message)
+        if self.newUpdates:
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        #     {
+        #         "topic": "bbos",
+        #         "ts": 1618822376000,
+        #         "data": [
+        #             {
+        #                 "symbol": "SPOT_FIL_USDT",
+        #                 "ask": 159.0318,
+        #                 "askSize": 370.43,
+        #                 "bid": 158.9158,
+        #                 "bidSize": 16
+        #             }
+        #         ]
+        #     }
+        #
+        topic = self.safe_string(message, 'topic')
+        data = self.safe_list(message, 'data', [])
+        timestamp = self.safe_integer(message, 'ts')
+        result: dict = {}
+        for i in range(0, len(data)):
+            ticker = self.safe_dict(data, i)
+            ticker['ts'] = timestamp
+            parsedTicker = self.parse_ws_bid_ask(ticker)
+            symbol = parsedTicker['symbol']
+            self.bidsasks[symbol] = parsedTicker
+            result[symbol] = parsedTicker
+        client.resolve(result, topic)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        marketId = self.safe_string(ticker, 'symbol')
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        timestamp = self.safe_integer(ticker, 'ts')
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_string(ticker, 'ask'),
+            'askVolume': self.safe_string(ticker, 'askSize'),
+            'bid': self.safe_string(ticker, 'bid'),
+            'bidVolume': self.safe_string(ticker, 'bidSize'),
+            'info': ticker,
+        }, market)
+
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
+        """
+        watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+
+        https://docs.woox.io/#k-line
+
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
         await self.load_markets()
         if (timeframe != '1m') and (timeframe != '5m') and (timeframe != '15m') and (timeframe != '30m') and (timeframe != '1h') and (timeframe != '1d') and (timeframe != '1w') and (timeframe != '1M'):
             raise ExchangeError(self.id + ' watchOHLCV timeframe argument must be 1m, 5m, 15m, 30m, 1h, 1d, 1w, 1M')
@@ -268,7 +477,7 @@ class woo(ccxt.async_support.woo):
         interval = self.safe_string(self.timeframes, timeframe, timeframe)
         name = 'kline'
         topic = market['id'] + '@' + name + '_' + interval
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'topic': topic,
         }
@@ -322,10 +531,22 @@ class woo(ccxt.async_support.woo):
         client.resolve(stored, topic)
 
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+        watches information on multiple trades made in a market
+
+        https://docs.woox.io/#trade
+
+        :param str symbol: unified market symbol of the market trades were made in
+        :param int [since]: the earliest time in ms to fetch trades for
+        :param int [limit]: the maximum number of trade structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
+        """
         await self.load_markets()
         market = self.market(symbol)
+        symbol = market['symbol']
         topic = market['id'] + '@trade'
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'topic': topic,
         }
@@ -374,17 +595,58 @@ class woo(ccxt.async_support.woo):
         #         "side":"BUY",
         #         "source":0
         #     }
+        # private trade
+        #    {
+        #     "msgType": 0,  # execution report
+        #     "symbol": "SPOT_BTC_USDT",
+        #     "clientOrderId": 0,
+        #     "orderId": 54774393,
+        #     "type": "MARKET",
+        #     "side": "BUY",
+        #     "quantity": 0.0,
+        #     "price": 0.0,
+        #     "tradeId": 56201985,
+        #     "executedPrice": 23534.06,
+        #     "executedQuantity": 0.00040791,
+        #     "fee": 2.1E-7,
+        #     "feeAsset": "BTC",
+        #     "totalExecutedQuantity": 0.00040791,
+        #     "avgPrice": 23534.06,
+        #     "status": "FILLED",
+        #     "reason": "",
+        #     "orderTag": "default",
+        #     "totalFee": 2.1E-7,
+        #     "feeCurrency": "BTC",
+        #     "totalRebate": 0,
+        #     "rebateCurrency": "USDT",
+        #     "visible": 0.0,
+        #     "timestamp": 1675406261689,
+        #     "reduceOnly": False,
+        #     "maker": False
+        #   }
         #
         marketId = self.safe_string(trade, 'symbol')
         market = self.safe_market(marketId, market)
         symbol = market['symbol']
-        price = self.safe_string(trade, 'price')
-        amount = self.safe_string(trade, 'size')
+        price = self.safe_string_2(trade, 'executedPrice', 'price')
+        amount = self.safe_string_2(trade, 'executedQuantity', 'size')
         cost = Precise.string_mul(price, amount)
         side = self.safe_string_lower(trade, 'side')
         timestamp = self.safe_integer(trade, 'timestamp')
+        maker = self.safe_bool(trade, 'marker')
+        takerOrMaker = None
+        if maker is not None:
+            takerOrMaker = 'maker' if maker else 'taker'
+        type = self.safe_string_lower(trade, 'type')
+        fee = None
+        feeCost = self.safe_number(trade, 'fee')
+        if feeCost is not None:
+            fee = {
+                'cost': feeCost,
+                'currency': self.safe_currency_code(self.safe_string(trade, 'feeCurrency')),
+            }
         return self.safe_trade({
-            'id': None,
+            'id': self.safe_string(trade, 'tradeId'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'symbol': symbol,
@@ -392,17 +654,17 @@ class woo(ccxt.async_support.woo):
             'price': price,
             'amount': amount,
             'cost': cost,
-            'order': None,
-            'takerOrMaker': None,
-            'type': None,
-            'fee': None,
+            'order': self.safe_string(trade, 'orderId'),
+            'takerOrMaker': takerOrMaker,
+            'type': type,
+            'fee': fee,
             'info': trade,
         }, market)
 
     def check_required_uid(self, error=True):
         if not self.uid:
             if error:
-                raise AuthenticationError(self.id + ' requires `uid` credential')
+                raise AuthenticationError(self.id + ' requires `uid` credential(woox calls it `application_id`)')
             else:
                 return False
         return True
@@ -413,12 +675,13 @@ class woo(ccxt.async_support.woo):
         client = self.client(url)
         messageHash = 'authenticated'
         event = 'auth'
-        future = self.safe_value(client.subscriptions, messageHash)
-        if future is None:
+        future = client.future(messageHash)
+        authenticated = self.safe_value(client.subscriptions, messageHash)
+        if authenticated is None:
             ts = str(self.nonce())
             auth = '|' + ts
             signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
-            request = {
+            request: dict = {
                 'event': event,
                 'params': {
                     'apikey': self.apiKey,
@@ -427,29 +690,53 @@ class woo(ccxt.async_support.woo):
                 },
             }
             message = self.extend(request, params)
-            future = self.watch(url, messageHash, message)
-            client.subscriptions[messageHash] = future
-        return future
+            self.watch(url, messageHash, message, messageHash, message)
+        return await future
 
     async def watch_private(self, messageHash, message, params={}):
         await self.authenticate(params)
         url = self.urls['api']['ws']['private'] + '/' + self.uid
         requestId = self.request_id(url)
-        subscribe = {
+        subscribe: dict = {
             'id': requestId,
         }
         request = self.extend(subscribe, message)
         return await self.watch(url, messageHash, request, messageHash, subscribe)
 
+    async def watch_private_multiple(self, messageHashes, message, params={}):
+        await self.authenticate(params)
+        url = self.urls['api']['ws']['private'] + '/' + self.uid
+        requestId = self.request_id(url)
+        subscribe: dict = {
+            'id': requestId,
+        }
+        request = self.extend(subscribe, message)
+        return await self.watch_multiple(url, messageHashes, request, messageHashes, subscribe)
+
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+        """
+
+        https://docs.woox.io/#executionreport
+        https://docs.woox.io/#algoexecutionreportv2
+
+        watches information on multiple orders made by the user
+        :param str symbol: unified market symbol of the market orders were made in
+        :param int [since]: the earliest time in ms to fetch orders for
+        :param int [limit]: the maximum number of order structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param bool [params.trigger]: True if trigger order
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
         await self.load_markets()
-        topic = 'executionreport'
+        trigger = self.safe_bool_2(params, 'stop', 'trigger', False)
+        topic = 'algoexecutionreportv2' if (trigger) else 'executionreport'
+        params = self.omit(params, ['stop', 'trigger'])
         messageHash = topic
         if symbol is not None:
             market = self.market(symbol)
             symbol = market['symbol']
             messageHash += ':' + symbol
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'topic': topic,
         }
@@ -459,6 +746,39 @@ class woo(ccxt.async_support.woo):
             limit = orders.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(orders, symbol, since, limit, True)
 
+    async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
+        """
+
+        https://docs.woox.io/#executionreport
+        https://docs.woox.io/#algoexecutionreportv2
+
+        watches information on multiple trades made by the user
+        :param str symbol: unified market symbol of the market orders were made in
+        :param int [since]: the earliest time in ms to fetch orders for
+        :param int [limit]: the maximum number of order structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param bool [params.trigger]: True if trigger order
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
+        """
+        await self.load_markets()
+        trigger = self.safe_bool_2(params, 'stop', 'trigger', False)
+        topic = 'algoexecutionreportv2' if (trigger) else 'executionreport'
+        params = self.omit(params, ['stop', 'trigger'])
+        messageHash = 'myTrades'
+        if symbol is not None:
+            market = self.market(symbol)
+            symbol = market['symbol']
+            messageHash += ':' + symbol
+        request: dict = {
+            'event': 'subscribe',
+            'topic': topic,
+        }
+        message = self.extend(request, params)
+        trades = await self.watch_private(messageHash, message)
+        if self.newUpdates:
+            limit = trades.getLimit(symbol, limit)
+        return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
+
     def parse_ws_order(self, order, market=None):
         #
         #     {
@@ -494,9 +814,10 @@ class woo(ccxt.async_support.woo):
             'cost': self.safe_string(order, 'totalFee'),
             'currency': self.safe_string(order, 'feeAsset'),
         }
+        priceString = self.safe_string(order, 'price')
         price = self.safe_number(order, 'price')
         avgPrice = self.safe_number(order, 'avgPrice')
-        if (price == 0) and (avgPrice is not None):
+        if Precise.string_eq(priceString, '0') and (avgPrice is not None):
             price = avgPrice
         amount = self.safe_float(order, 'quantity')
         side = self.safe_string_lower(order, 'side')
@@ -527,7 +848,7 @@ class woo(ccxt.async_support.woo):
             'triggerPrice': None,
             'amount': amount,
             'cost': None,
-            'average': None,
+            'average': avgPrice,
             'filled': filled,
             'remaining': remaining,
             'status': status,
@@ -565,11 +886,24 @@ class woo(ccxt.async_support.woo):
         #         }
         #     }
         #
-        order = self.safe_value(message, 'data')
-        self.handle_order(client, order)
+        topic = self.safe_string(message, 'topic')
+        data = self.safe_value(message, 'data')
+        if isinstance(data, list):
+            # algoexecutionreportv2
+            for i in range(0, len(data)):
+                order = data[i]
+                tradeId = self.omit_zero(self.safe_string(data, 'tradeId'))
+                if tradeId is not None:
+                    self.handle_my_trade(client, order)
+                self.handle_order(client, order, topic)
+        else:
+            # executionreport
+            tradeId = self.omit_zero(self.safe_string(data, 'tradeId'))
+            if tradeId is not None:
+                self.handle_my_trade(client, data)
+            self.handle_order(client, data, topic)
 
-    def handle_order(self, client: Client, message):
-        topic = 'executionreport'
+    def handle_order(self, client: Client, message, topic):
         parsed = self.parse_ws_order(message)
         symbol = self.safe_string(parsed, 'symbol')
         orderId = self.safe_string(parsed, 'id')
@@ -595,33 +929,82 @@ class woo(ccxt.async_support.woo):
             messageHashSymbol = topic + ':' + symbol
             client.resolve(self.orders, messageHashSymbol)
 
+    def handle_my_trade(self, client: Client, message):
+        #
+        #    {
+        #     "msgType": 0,  # execution report
+        #     "symbol": "SPOT_BTC_USDT",
+        #     "clientOrderId": 0,
+        #     "orderId": 54774393,
+        #     "type": "MARKET",
+        #     "side": "BUY",
+        #     "quantity": 0.0,
+        #     "price": 0.0,
+        #     "tradeId": 56201985,
+        #     "executedPrice": 23534.06,
+        #     "executedQuantity": 0.00040791,
+        #     "fee": 2.1E-7,
+        #     "feeAsset": "BTC",
+        #     "totalExecutedQuantity": 0.00040791,
+        #     "avgPrice": 23534.06,
+        #     "status": "FILLED",
+        #     "reason": "",
+        #     "orderTag": "default",
+        #     "totalFee": 2.1E-7,
+        #     "feeCurrency": "BTC",
+        #     "totalRebate": 0,
+        #     "rebateCurrency": "USDT",
+        #     "visible": 0.0,
+        #     "timestamp": 1675406261689,
+        #     "reduceOnly": False,
+        #     "maker": False
+        #   }
+        #
+        myTrades = self.myTrades
+        if myTrades is None:
+            limit = self.safe_integer(self.options, 'tradesLimit', 1000)
+            myTrades = ArrayCacheBySymbolById(limit)
+        trade = self.parse_ws_trade(message)
+        myTrades.append(trade)
+        messageHash = 'myTrades:' + trade['symbol']
+        client.resolve(myTrades, messageHash)
+        messageHash = 'myTrades'
+        client.resolve(myTrades, messageHash)
+
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
         """
-        :see: https://docs.woo.org/#position-push
+
+        https://docs.woox.io/#position-push
+
         watch all open positions
         :param str[]|None symbols: list of unified market symbols
+ @param since
+ @param limit
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
         """
         await self.load_markets()
-        messageHash = ''
+        messageHashes = []
         symbols = self.market_symbols(symbols)
         if not self.is_empty(symbols):
-            messageHash = '::' + ','.join(symbols)
-        messageHash = 'positions' + messageHash
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHashes.append('positions::' + symbol)
+        else:
+            messageHashes.append('positions')
         url = self.urls['api']['ws']['private'] + '/' + self.uid
         client = self.client(url)
         self.set_positions_cache(client, symbols)
         fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
-        awaitPositionsSnapshot = self.safe_bool('watchPositions', 'awaitPositionsSnapshot', True)
+        awaitPositionsSnapshot = self.handle_option('watchPositions', 'awaitPositionsSnapshot', True)
         if fetchPositionsSnapshot and awaitPositionsSnapshot and self.positions is None:
             snapshot = await client.future('fetchPositionsSnapshot')
             return self.filter_by_symbols_since_limit(snapshot, symbols, since, limit, True)
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'topic': 'position',
         }
-        newPositions = await self.watch_private(messageHash, request, params)
+        newPositions = await self.watch_private_multiple(messageHashes, request, params)
         if self.newUpdates:
             return newPositions
         return self.filter_by_symbols_since_limit(self.positions, symbols, since, limit, True)
@@ -690,20 +1073,15 @@ class woo(ccxt.async_support.woo):
             position = self.parse_position(rawPosition, market)
             newPositions.append(position)
             cache.append(position)
-        messageHashes = self.find_message_hashes(client, 'positions::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            positions = self.filter_by_array(newPositions, 'symbol', symbols, False)
-            if not self.is_empty(positions):
-                client.resolve(positions, messageHash)
+            messageHash = 'positions::' + market['symbol']
+            client.resolve(position, messageHash)
         client.resolve(newPositions, 'positions')
 
     async def watch_balance(self, params={}) -> Balances:
         """
-        :see: https://docs.woo.org/#balance
+
+        https://docs.woox.io/#balance
+
         watch balance and get the amount of funds available for trading or funds locked in orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
@@ -711,7 +1089,7 @@ class woo(ccxt.async_support.woo):
         await self.load_markets()
         topic = 'balance'
         messageHash = topic
-        request = {
+        request: dict = {
             'event': 'subscribe',
             'topic': topic,
         }
@@ -768,20 +1146,50 @@ class woo(ccxt.async_support.woo):
         self.balance = self.safe_balance(self.balance)
         client.resolve(self.balance, 'balance')
 
+    def handle_error_message(self, client: Client, message):
+        #
+        # {"id":"1","event":"subscribe","success":false,"ts":1710780997216,"errorMsg":"Auth is needed."}
+        #
+        if not ('success' in message):
+            return False
+        success = self.safe_bool(message, 'success')
+        if success:
+            return False
+        errorMessage = self.safe_string(message, 'errorMsg')
+        try:
+            if errorMessage is not None:
+                feedback = self.id + ' ' + self.json(message)
+                self.throw_exactly_matched_exception(self.exceptions['exact'], errorMessage, feedback)
+            return False
+        except Exception as error:
+            if isinstance(error, AuthenticationError):
+                messageHash = 'authenticated'
+                client.reject(error, messageHash)
+                if messageHash in client.subscriptions:
+                    del client.subscriptions[messageHash]
+            else:
+                client.reject(error)
+            return True
+
     def handle_message(self, client: Client, message):
-        methods = {
+        if self.handle_error_message(client, message):
+            return
+        methods: dict = {
             'ping': self.handle_ping,
             'pong': self.handle_pong,
             'subscribe': self.handle_subscribe,
             'orderbook': self.handle_order_book,
+            'orderbookupdate': self.handle_order_book,
             'ticker': self.handle_ticker,
             'tickers': self.handle_tickers,
             'kline': self.handle_ohlcv,
             'auth': self.handle_auth,
             'executionreport': self.handle_order_update,
+            'algoexecutionreportv2': self.handle_order_update,
             'trade': self.handle_trade,
             'balance': self.handle_balance,
             'position': self.handle_positions,
+            'bbos': self.handle_bid_ask,
         }
         event = self.safe_string(message, 'event')
         method = self.safe_value(methods, event)
@@ -831,6 +1239,12 @@ class woo(ccxt.async_support.woo):
         #         "ts": 1657117712212
         #     }
         #
+        id = self.safe_string(message, 'id')
+        subscriptionsById = self.index_by(client.subscriptions, 'id')
+        subscription = self.safe_value(subscriptionsById, id, {})
+        method = self.safe_value(subscription, 'method')
+        if method is not None:
+            method(client, message, subscription)
         return message
 
     def handle_auth(self, client: Client, message):
@@ -844,7 +1258,9 @@ class woo(ccxt.async_support.woo):
         messageHash = 'authenticated'
         success = self.safe_value(message, 'success')
         if success:
-            client.resolve(message, messageHash)
+            # client.resolve(message, messageHash)
+            future = self.safe_value(client.futures, 'authenticated')
+            future.resolve(True)
         else:
             error = AuthenticationError(self.json(message))
             client.reject(error, messageHash)