ccxt 4.3.68__py2.py3-none-any.whl → 4.3.70__py2.py3-none-any.whl

ccxt/pro/coinbaseinternational.py

@@ -4,9 +4,9 @@
 # https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 
 import ccxt.async_support
-from ccxt.async_support.base.ws.cache import ArrayCache
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Int, Market, OrderBook, Strings, Ticker, FundingRate, FundingRates, Trade
+from ccxt.base.types import Int, Market, OrderBook, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -27,12 +27,12 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
                 'watchTicker': True,
                 'watchBalance': False,
                 'watchMyTrades': False,
-                'watchOHLCV': False,
+                'watchOHLCV': True,
                 'watchOHLCVForSymbols': False,
                 'watchOrders': False,
                 'watchOrdersForSymbols': False,
                 'watchPositions': False,
-                'watchTickers': False,
+                'watchTickers': True,
                 'createOrderWs': False,
                 'editOrderWs': False,
                 'cancelOrderWs': False,
@@ -58,6 +58,14 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
                 'tradesLimit': 1000,
                 'ordersLimit': 1000,
                 'myTradesLimit': 1000,
+                'timeframes': {
+                    '1m': 'CANDLES_ONE_MINUTE',
+                    '5m': 'CANDLES_FIVE_MINUTES',
+                    '30m': 'CANDLES_THIRTY_MINUTES',
+                    '1h': 'CANDLES_ONE_HOUR',
+                    '2h': 'CANDLES_TWO_HOURS',
+                    '1d': 'CANDLES_ONE_DAY',
+                },
             },
             'exceptions': {
                 'exact': {
@@ -80,15 +88,18 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
         self.check_required_credentials()
         market = None
         messageHash = name
-        productIds = []
+        productIds = None
         if symbols is None:
-            symbols = self.symbols
+            symbols = self.get_active_symbols()
         symbolsLength = len(symbols)
+        messageHashes = []
         if symbolsLength > 1:
             parsedSymbols = self.market_symbols(symbols)
             marketIds = self.market_ids(parsedSymbols)
             productIds = marketIds
-            messageHash = messageHash + '::' + ','.join(parsedSymbols)
+            for i in range(0, len(parsedSymbols)):
+                messageHashes.append(name + '::' + parsedSymbols[i])
+            # messageHash = messageHash + '::' + ','.join(parsedSymbols)
         elif symbolsLength == 1:
             market = self.market(symbols[0])
             messageHash = name + '::' + market['symbol']
@@ -101,13 +112,17 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
         signature = self.hmac(self.encode(auth), self.base64_to_binary(self.secret), hashlib.sha256, 'base64')
         subscribe: dict = {
             'type': 'SUBSCRIBE',
-            'product_ids': productIds,
+            # 'product_ids': productIds,
             'channels': [name],
             'time': timestamp,
             'key': self.apiKey,
             'passphrase': self.password,
             'signature': signature,
         }
+        if productIds is not None:
+            subscribe['product_ids'] = productIds
+        if symbolsLength > 1:
+            return await self.watch_multiple(url, messageHashes, self.extend(subscribe, params), messageHashes)
         return await self.watch(url, messageHash, self.extend(subscribe, params), messageHash)
 
     async def subscribe_multiple(self, name: str, symbols: Strings = None, params={}):
@@ -184,6 +199,7 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
         :see: https://docs.cloud.coinbase.com/intx/docs/websocket-channels#instruments-channel
         :param str [symbol]: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to watch, 'LEVEL1' or 'INSTRUMENTS', default is 'LEVEL1'
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
@@ -191,6 +207,35 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
         channel, params = self.handle_option_and_params(params, 'watchTicker', 'channel', 'LEVEL1')
         return await self.subscribe(channel, [symbol], params)
 
+    def get_active_symbols(self):
+        symbols = self.symbols
+        output = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            market = self.markets[symbol]
+            if market['active']:
+                output.append(symbol)
+        return output
+
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://docs.cloud.coinbase.com/intx/docs/websocket-channels#instruments-channel
+        :param str[] [symbols]: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to watch, 'LEVEL1' or 'INSTRUMENTS', default is 'INSTLEVEL1UMENTS'
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        channel = None
+        channel, params = self.handle_option_and_params(params, 'watchTickers', 'channel', 'LEVEL1')
+        ticker = await self.subscribe(channel, symbols, params)
+        if self.newUpdates:
+            result: dict = {}
+            result[ticker['symbol']] = ticker
+            return result
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     def handle_instrument(self, client: Client, message):
         #
         #    {
@@ -248,6 +293,33 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
         #        "channel":"INSTRUMENTS",
         #        "type":"SNAPSHOT"
         #    }
+        # instruments
+        #   {
+        #       sequence: 0,
+        #       instrument_type: 'PERP',
+        #       instrument_mode: 'standard',
+        #       base_asset_name: 'BTC',
+        #       quote_asset_name: 'USDC',
+        #       base_increment: '0.0001',
+        #       quote_increment: '0.1',
+        #       avg_daily_quantity: '502.8845',
+        #       avg_daily_volume: '3.1495242961566668E7',
+        #       total30_day_quantity: '15086.535',
+        #       total30_day_volume: '9.44857288847E8',
+        #       total24_hour_quantity: '5.0',
+        #       total24_hour_volume: '337016.5',
+        #       base_imf: '0.1',
+        #       min_quantity: '0.0001',
+        #       position_size_limit: '800',
+        #       funding_interval: '3600000000000',
+        #       trading_state: 'trading',
+        #       last_updated_time: '2024-07-30T15:00:00Z',
+        #       default_initial_margin: '0.2',
+        #       base_asset_multiplier: '1.0',
+        #       channel: 'INSTRUMENTS',
+        #       type: 'SNAPSHOT',
+        #       time: '2024-07-30T15:26:56.766Z',
+        #   }
         #
         marketId = self.safe_string(ticker, 'product_id')
         datetime = self.safe_string(ticker, 'time')
@@ -270,8 +342,8 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
             'change': None,
             'percentage': None,
             'average': None,
-            'baseVolume': self.safe_string(ticker, 'total_24_hour_quantity'),
-            'quoteVolume': self.safe_string(ticker, 'total_24_hour_volume'),
+            'baseVolume': self.safe_string_2(ticker, 'total_24_hour_quantity', 'total24_hour_quantity'),
+            'quoteVolume': self.safe_string_2(ticker, 'total_24_hour_volume', 'total24_hour_volume'),
         })
 
     def handle_ticker(self, client: Client, message):
@@ -343,6 +415,63 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
             'previousClose': None,
         })
 
+    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, close price, and the volume of a market
+        :see: https://docs.cdp.coinbase.com/intx/docs/websocket-channels#candles-channel
+        :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()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        options = self.safe_dict(self.options, 'timeframes', {})
+        interval = self.safe_string(options, timeframe, timeframe)
+        ohlcv = await self.subscribe(interval, [symbol], params)
+        if self.newUpdates:
+            limit = ohlcv.getLimit(symbol, limit)
+        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
+
+    def handle_ohlcv(self, client: Client, message):
+        #
+        # {
+        #     "sequence": 0,
+        #     "product_id": "BTC-PERP",
+        #     "channel": "CANDLES_ONE_MINUTE",
+        #     "type": "SNAPSHOT",
+        #     "candles": [
+        #       {
+        #           "time": "2023-05-10T14:58:47.000Z",
+        #           "low": "28787.8",
+        #           "high": "28788.8",
+        #           "open": "28788.8",
+        #           "close": "28787.8",
+        #           "volume": "0.466"
+        #        },
+        #     ]
+        #  }
+        #
+        messageHash = self.safe_string(message, 'channel')
+        marketId = self.safe_string(message, 'product_id')
+        market = self.safe_market(marketId)
+        symbol = market['symbol']
+        timeframe = self.find_timeframe(messageHash)
+        self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
+        if self.safe_value(self.ohlcvs[symbol], timeframe) is None:
+            limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
+            self.ohlcvs[symbol][timeframe] = ArrayCacheByTimestamp(limit)
+        stored = self.ohlcvs[symbol][timeframe]
+        data = self.safe_list(message, 'candles', [])
+        for i in range(0, len(data)):
+            tick = data[i]
+            parsed = self.parse_ohlcv(tick, market)
+            stored.append(parsed)
+        client.resolve(stored, messageHash + '::' + symbol)
+
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
@@ -606,7 +735,7 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
     def handle_message(self, client, message):
         if self.handle_error_message(client, message):
             return
-        channel = self.safe_string(message, 'channel')
+        channel = self.safe_string(message, 'channel', '')
         methods: dict = {
             'SUBSCRIPTIONS': self.handle_subscription_status,
             'INSTRUMENTS': self.handle_instrument,
@@ -620,6 +749,8 @@ class coinbaseinternational(ccxt.async_support.coinbaseinternational):
         if type == 'error':
             errorMessage = self.safe_string(message, 'message')
             raise ExchangeError(errorMessage)
+        if channel.find('CANDLES') > -1:
+            self.handle_ohlcv(client, message)
         method = self.safe_value(methods, channel)
         if method is not None:
             method(client, message)

ccxt/pro/cryptocom.py

@@ -9,6 +9,7 @@ import hashlib
 from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
+from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import NetworkError
 from ccxt.base.errors import ChecksumError
@@ -827,6 +828,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         #        "message": "invalid channel {"channels":["trade.BTCUSD-PERP"]}"
         #    }
         #
+        id = self.safe_string(message, 'id')
         errorCode = self.safe_string(message, 'code')
         try:
             if errorCode and errorCode != '0':
@@ -835,6 +837,7 @@ class cryptocom(ccxt.async_support.cryptocom):
                 messageString = self.safe_value(message, 'message')
                 if messageString is not None:
                     self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
+                raise ExchangeError(feedback)
             return False
         except Exception as e:
             if isinstance(e, AuthenticationError):
@@ -843,7 +846,7 @@ class cryptocom(ccxt.async_support.cryptocom):
                 if messageHash in client.subscriptions:
                     del client.subscriptions[messageHash]
             else:
-                client.reject(e)
+                client.reject(e, id)
             return True
 
     def handle_subscribe(self, client: Client, message):

ccxt/pro/hitbtc.py

@@ -1137,7 +1137,8 @@ class hitbtc(ccxt.async_support.hitbtc):
         return message
 
     def handle_message(self, client: Client, message):
-        self.handle_error(client, message)
+        if self.handle_error(client, message):
+            return
         channel = self.safe_string_2(message, 'ch', 'method')
         if channel is not None:
             splitChannel = channel.split('/')
@@ -1206,11 +1207,22 @@ class hitbtc(ccxt.async_support.hitbtc):
         #
         error = self.safe_value(message, 'error')
         if error is not None:
-            code = self.safe_value(error, 'code')
-            errorMessage = self.safe_string(error, 'message')
-            description = self.safe_string(error, 'description')
-            feedback = self.id + ' ' + description
-            self.throw_exactly_matched_exception(self.exceptions['exact'], code, feedback)
-            self.throw_broadly_matched_exception(self.exceptions['broad'], errorMessage, feedback)
-            raise ExchangeError(feedback)  # unknown message
+            try:
+                code = self.safe_value(error, 'code')
+                errorMessage = self.safe_string(error, 'message')
+                description = self.safe_string(error, 'description')
+                feedback = self.id + ' ' + description
+                self.throw_exactly_matched_exception(self.exceptions['exact'], code, feedback)
+                self.throw_broadly_matched_exception(self.exceptions['broad'], errorMessage, feedback)
+                raise ExchangeError(feedback)  # unknown message
+            except Exception as e:
+                if isinstance(e, AuthenticationError):
+                    messageHash = 'authenticated'
+                    client.reject(e, messageHash)
+                    if messageHash in client.subscriptions:
+                        del client.subscriptions[messageHash]
+                else:
+                    id = self.safe_string(message, 'id')
+                    client.reject(e, id)
+                return True
         return None

ccxt/pro/okx.py

@@ -1764,6 +1764,12 @@ class okx(ccxt.async_support.okx):
                     self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
                 raise ExchangeError(feedback)
         except Exception as e:
+            # if the message contains an id, it means it is a response to a request
+            # so we only reject that promise, instead of deleting all futures, destroying the authentication future
+            id = self.safe_string(message, 'id')
+            if id is not None:
+                client.reject(e, id)
+                return False
             client.reject(e)
             return False
         return message

ccxt/pro/poloniex.py

@@ -86,7 +86,7 @@ class poloniex(ccxt.async_support.poloniex):
         """
          * @ignore
         authenticates the user to access private web socket channels
-        :see: https://docs.poloniex.com/#authenticated-channels-market-data-authentication
+        :see: https://api-docs.poloniex.com/spot/websocket/authentication
         :returns dict: response from exchange
         """
         self.check_required_credentials()
@@ -184,7 +184,7 @@ class poloniex(ccxt.async_support.poloniex):
 
     async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}) -> Order:
         """
-        :see: https://docs.poloniex.com/#authenticated-channels-trade-requests-create-order
+        :see: https://api-docs.poloniex.com/spot/websocket/trade-request#create-order
         create a trade order
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
@@ -243,7 +243,7 @@ class poloniex(ccxt.async_support.poloniex):
 
     async def cancel_order_ws(self, id: str, symbol: Str = None, params={}):
         """
-        :see: https://docs.poloniex.com/#authenticated-channels-trade-requests-cancel-multiple-orders
+        :see: https://api-docs.poloniex.com/spot/websocket/trade-request#cancel-multiple-orders
         cancel multiple orders
         :param str id: order id
         :param str [symbol]: unified market symbol
@@ -259,7 +259,7 @@ class poloniex(ccxt.async_support.poloniex):
 
     async def cancel_orders_ws(self, ids: List[str], symbol: Str = None, params={}):
         """
-        :see: https://docs.poloniex.com/#authenticated-channels-trade-requests-cancel-multiple-orders
+        :see: https://api-docs.poloniex.com/spot/websocket/trade-request#cancel-multiple-orders
         cancel multiple orders
         :param str[] ids: order ids
         :param str symbol: unified market symbol, default is None
@@ -276,7 +276,7 @@ class poloniex(ccxt.async_support.poloniex):
 
     async def cancel_all_orders_ws(self, symbol: Str = None, params={}):
         """
-        :see: https://docs.poloniex.com/#authenticated-channels-trade-requests-cancel-all-orders
+        :see: https://api-docs.poloniex.com/spot/websocket/trade-request#cancel-all-orders
         cancel all open orders of a type. Only applicable to Option in Portfolio Margin mode, and MMP privilege is required.
         :param str symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
         :param dict [params]: extra parameters specific to the poloniex api endpoint
@@ -310,7 +310,7 @@ class poloniex(ccxt.async_support.poloniex):
     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
-        :see: https://docs.poloniex.com/#public-channels-market-data-candlesticks
+        :see: https://api-docs.poloniex.com/spot/websocket/market-data#candlesticks
         :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
@@ -331,7 +331,7 @@ class poloniex(ccxt.async_support.poloniex):
     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
-        :see: https://docs.poloniex.com/#public-channels-market-data-ticker
+        :see: https://api-docs.poloniex.com/spot/websocket/market-data#ticker
         :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>`
@@ -344,7 +344,7 @@ class poloniex(ccxt.async_support.poloniex):
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        :see: https://docs.poloniex.com/#public-channels-market-data-ticker
+        :see: https://api-docs.poloniex.com/spot/websocket/market-data#ticker
         :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>`
@@ -360,7 +360,7 @@ class poloniex(ccxt.async_support.poloniex):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :see: https://docs.poloniex.com/#public-channels-market-data-trades
+        :see: https://api-docs.poloniex.com/spot/websocket/market-data#trades
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -378,7 +378,7 @@ class poloniex(ccxt.async_support.poloniex):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
-        :see: https://docs.poloniex.com/#public-channels-market-data-book-level-2
+        :see: https://api-docs.poloniex.com/spot/websocket/market-data#book-level-2
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: not used by poloniex watchOrderBook
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -394,7 +394,7 @@ class poloniex(ccxt.async_support.poloniex):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
-        :see: https://docs.poloniex.com/#authenticated-channels-market-data-orders
+        :see: https://api-docs.poloniex.com/spot/websocket/order
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: not used by poloniex watchOrders
         :param int [limit]: not used by poloniex watchOrders
@@ -415,7 +415,7 @@ class poloniex(ccxt.async_support.poloniex):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         watches information on multiple trades made by the user using orders stream
-        :see: https://docs.poloniex.com/#authenticated-channels-market-data-orders
+        :see: https://api-docs.poloniex.com/spot/websocket/order
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: not used by poloniex watchMyTrades
         :param int [limit]: not used by poloniex watchMyTrades
@@ -437,7 +437,7 @@ class poloniex(ccxt.async_support.poloniex):
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders
-        :see: https://docs.poloniex.com/#authenticated-channels-market-data-balances
+        :see: https://api-docs.poloniex.com/spot/websocket/balance
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
@@ -1100,13 +1100,7 @@ class poloniex(ccxt.async_support.poloniex):
         if type == 'auth':
             self.handle_authenticate(client, message)
         elif type is None:
-            data = self.safe_value(message, 'data')
-            item = self.safe_value(data, 0)
-            orderId = self.safe_string(item, 'orderId')
-            if orderId == '0':
-                self.handle_error_message(client, item)
-            else:
-                self.handle_order_request(client, message)
+            self.handle_order_request(client, message)
         else:
             data = self.safe_value(message, 'data', [])
             dataLength = len(data)
@@ -1131,12 +1125,40 @@ class poloniex(ccxt.async_support.poloniex):
         #       "event": "error",
         #       "message": "Platform in maintenance mode"
         #    }
+        #    {
+        #       "id":"1722386782048",
+        #       "data":[
+        #          {
+        #             "orderId":0,
+        #             "clientOrderId":null,
+        #             "message":"available insufficient",
+        #             "code":21721
+        #          }
+        #       ]
+        #    }
         #
+        id = self.safe_string(message, 'id')
         event = self.safe_string(message, 'event')
-        orderId = self.safe_string(message, 'orderId')
+        data = self.safe_list(message, 'data')
+        first = self.safe_dict(data, 0)
+        orderId = self.safe_string(first, 'orderId')
         if (event == 'error') or (orderId == '0'):
-            error = self.safe_string(message, 'message')
-            raise ExchangeError(self.id + ' error: ' + self.json(error))
+            try:
+                error = self.safe_string(first, 'message')
+                code = self.safe_string(first, 'code')
+                feedback = self.id + ' ' + self.json(message)
+                self.throw_exactly_matched_exception(self.exceptions['exact'], code, feedback)
+                self.throw_broadly_matched_exception(self.exceptions['broad'], error, feedback)
+                raise ExchangeError(feedback)
+            except Exception as e:
+                if isinstance(e, AuthenticationError):
+                    messageHash = 'authenticated'
+                    client.reject(e, messageHash)
+                    if messageHash in client.subscriptions:
+                        del client.subscriptions[messageHash]
+                else:
+                    client.reject(e, id)
+                return True
         return False
 
     def handle_authenticate(self, client: Client, message):

ccxt/pro/poloniexfutures.py

@@ -234,7 +234,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
     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
-        :see: https://futures-docs.poloniex.com/#get-real-time-symbol-ticker
+        :see: https://api-docs.poloniex.com/futures/websocket/public#get-real-time-symbol-ticker
         :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>`
@@ -247,7 +247,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :see: https://futures-docs.poloniex.com/#full-matching-engine-data-level-3
+        :see: https://api-docs.poloniex.com/futures/websocket/public#full-matching-engine-datalevel-3
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -267,7 +267,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
-        :see: https://futures-docs.poloniex.com/#level-2-market-data
+        :see: https://api-docs.poloniex.com/futures/websocket/public#level-2-market-data
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: not used by poloniexfutures watchOrderBook
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -293,7 +293,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
-        :see: https://futures-docs.poloniex.com/#private-messages
+        :see: https://api-docs.poloniex.com/futures/websocket/user-messages#private-messages
         :param str symbol: filter by 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
@@ -316,7 +316,7 @@ class poloniexfutures(ccxt.async_support.poloniexfutures):
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders
-        :see: https://futures-docs.poloniex.com/#account-balance-events
+        :see: https://api-docs.poloniex.com/futures/websocket/user-messages#account-balance-events
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """

ccxt/pro/woo.py

@@ -34,7 +34,7 @@ class woo(ccxt.async_support.woo):
                 'api': {
                     'ws': {
                         'public': 'wss://wss.woo.org/ws/stream',
-                        'private': 'wss://wss.woo.network/v2/ws/private/stream',
+                        'private': 'wss://wss.woo.org/v2/ws/private/stream',
                     },
                 },
                 'test': {
@@ -79,7 +79,8 @@ class woo(ccxt.async_support.woo):
         return newValue
 
     async def watch_public(self, messageHash, message):
-        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: dict = {
             'id': requestId,
@@ -456,7 +457,7 @@ class woo(ccxt.async_support.woo):
         marketId = self.safe_string(trade, 'symbol')
         market = self.safe_market(marketId, market)
         symbol = market['symbol']
-        price = self.safe_string(trade, 'executedPrice', 'price')
+        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')
@@ -492,7 +493,7 @@ class woo(ccxt.async_support.woo):
     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

ccxt/woo.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.woo import ImplicitAPI
 import hashlib
-from ccxt.base.types import Account, Balances, Bool, Conversion, Currencies, Currency, Int, Leverage, MarginModification, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Trade, TradingFees, Transaction, TransferEntry, TransferEntries
+from ccxt.base.types import Account, Balances, Bool, Conversion, Currencies, Currency, Int, Leverage, MarginModification, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Trade, TradingFees, Transaction, TransferEntry
 from typing import List
 from typing import Any
 from ccxt.base.errors import ExchangeError
@@ -2184,7 +2184,7 @@ class woo(Exchange, ImplicitAPI):
             transfer['toAccount'] = toAccount
         return transfer
 
-    def fetch_transfers(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> TransferEntries:
+    def fetch_transfers(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[TransferEntry]:
         """
         fetch a history of internal transfers made on an account
         :see: https://docs.woo.org/#get-transfer-history