ccxt-ir 4.3.46.0.2__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/pro/cex.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Any, Balances, Bool, Int, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -17,7 +17,7 @@ from ccxt.base.precise import Precise
 
 class cex(ccxt.async_support.cex):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(cex, self).describe(), {
             'has': {
                 'ws': True,
@@ -25,6 +25,7 @@ class cex(ccxt.async_support.cex):
                 'watchTicker': True,
                 'watchTickers': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': False,
                 'watchMyTrades': True,
                 'watchOrders': True,
                 'watchOrderBook': True,
@@ -61,7 +62,9 @@ class cex(ccxt.async_support.cex):
     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://cex.io/websocket-api#get-balance
+
+        https://cex.io/websocket-api#get-balance
+
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
@@ -118,7 +121,9 @@ class cex(ccxt.async_support.cex):
     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. Note: can only watch one symbol at a time.
-        :see: https://cex.io/websocket-api#old-pair-room
+
+        https://cex.io/websocket-api#old-pair-room
+
         :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
@@ -235,7 +240,9 @@ class cex(ccxt.async_support.cex):
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
-        :see: https://cex.io/websocket-api#ticker-subscription
+
+        https://cex.io/websocket-api#ticker-subscription
+
         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
@@ -270,7 +277,9 @@ class cex(ccxt.async_support.cex):
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
-        :see: https://cex.io/websocket-api#ticker-subscription
+
+        https://cex.io/websocket-api#ticker-subscription
+
         watches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -299,7 +308,9 @@ class cex(ccxt.async_support.cex):
 
     async def fetch_ticker_ws(self, symbol: str, params={}) -> Ticker:
         """
-        :see: https://docs.cex.io/#ws-api-ticker-deprecated
+
+        https://docs.cex.io/#ws-api-ticker-deprecated
+
         fetches 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 cex api endpoint
@@ -404,7 +415,9 @@ class cex(ccxt.async_support.cex):
 
     async def fetch_balance_ws(self, params={}) -> Balances:
         """
-        :see: https://docs.cex.io/#ws-api-get-balance
+
+        https://docs.cex.io/#ws-api-get-balance
+
         query for balance and get the amount of funds available for trading or funds locked in orders
         :param dict [params]: extra parameters specific to the cex api endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
@@ -422,7 +435,9 @@ class cex(ccxt.async_support.cex):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         get the list of orders associated with the user. Note: In CEX.IO system, orders can be present in trade engine or in archive database. There can be time periods(~2 seconds or more), when order is done/canceled, but still not moved to archive database. That means, you cannot see it using calls: archived-orders/open-orders.
-        :see: https://docs.cex.io/#ws-api-open-orders
+
+        https://docs.cex.io/#ws-api-open-orders
+
         :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
@@ -456,7 +471,9 @@ class cex(ccxt.async_support.cex):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of trades associated with the user. Note: In CEX.IO system, orders can be present in trade engine or in archive database. There can be time periods(~2 seconds or more), when order is done/canceled, but still not moved to archive database. That means, you cannot see it using calls: archived-orders/open-orders.
-        :see: https://docs.cex.io/#ws-api-open-orders
+
+        https://docs.cex.io/#ws-api-open-orders
+
         :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
@@ -640,7 +657,7 @@ class cex(ccxt.async_support.cex):
         #             }
         #         }
         #     }
-        #  fullfilledOrder
+        #  fulfilledOrder
         #     {
         #         "e": "order",
         #         "data": {
@@ -868,7 +885,9 @@ class cex(ccxt.async_support.cex):
     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://cex.io/websocket-api#orderbook-subscribe
+
+        https://cex.io/websocket-api#orderbook-subscribe
+
         :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
@@ -961,7 +980,7 @@ class cex(ccxt.async_support.cex):
         #     }
         #
         data = self.safe_value(message, 'data', {})
-        incrementalId = self.safe_number(data, 'id')
+        incrementalId = self.safe_integer(data, 'id')
         pair = self.safe_string(data, 'pair', '')
         symbol = self.pair_to_symbol(pair)
         storedOrderBook = self.safe_value(self.orderbooks, symbol)
@@ -989,7 +1008,9 @@ class cex(ccxt.async_support.cex):
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
-        :see: https://cex.io/websocket-api#minute-data
+
+        https://cex.io/websocket-api#minute-data
+
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market. It will return the last 120 minutes with the selected timeframe and then 1m candle updates after that.
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents.
@@ -1128,7 +1149,10 @@ class cex(ccxt.async_support.cex):
     async def fetch_order_ws(self, id: str, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
-        :see: https://docs.cex.io/#ws-api-get-order
+
+        https://docs.cex.io/#ws-api-get-order
+
+        :param str id: the order id
         :param str symbol: not used by cex fetchOrder
         :param dict [params]: extra parameters specific to the cex api endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
@@ -1153,7 +1177,9 @@ class cex(ccxt.async_support.cex):
 
     async def fetch_open_orders_ws(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
-        :see: https://docs.cex.io/#ws-api-open-orders
+
+        https://docs.cex.io/#ws-api-open-orders
+
         fetch all unfilled currently open orders
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch open orders for
@@ -1162,7 +1188,7 @@ class cex(ccxt.async_support.cex):
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         if symbol is None:
-            raise ArgumentsRequired(self.id + 'fetchOpenOrdersWs requires a symbol.')
+            raise ArgumentsRequired(self.id + ' fetchOpenOrdersWs requires a symbol.')
         await self.load_markets()
         await self.authenticate()
         market = self.market(symbol)
@@ -1181,13 +1207,15 @@ class cex(ccxt.async_support.cex):
 
     async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}) -> Order:
         """
-        :see: https://docs.cex.io/#ws-api-order-placement
+
+        https://docs.cex.io/#ws-api-order-placement
+
         create a trade order
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of currency you want to trade in units of base currency
-        :param float price: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float price: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the kraken api endpoint
         :param boolean [params.maker_only]: Optional, maker only places an order only if offers best sell(<= max) or buy(>= max) price for self pair, if not order placement will be rejected with an error - "Order is not maker"
         :returns dict: an `order structure <https://docs.ccxt.com/en/latest/manual.html#order-structure>`
@@ -1216,13 +1244,15 @@ class cex(ccxt.async_support.cex):
     async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}) -> Order:
         """
         edit a trade order
-        :see: https://docs.cex.io/#ws-api-cancel-replace
+
+        https://docs.cex.io/#ws-api-cancel-replace
+
         :param str id: order id
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of the currency you want to trade in units of the base currency
-        :param float|None [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+        :param float|None [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the cex api endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/en/latest/manual.html#order-structure>`
         """
@@ -1252,7 +1282,9 @@ class cex(ccxt.async_support.cex):
 
     async def cancel_order_ws(self, id: str, symbol: Str = None, params={}):
         """
-        :see: https://docs.cex.io/#ws-api-order-cancel
+
+        https://docs.cex.io/#ws-api-order-cancel
+
         cancels an open order
         :param str id: order id
         :param str symbol: not used by cex cancelOrder()
@@ -1280,7 +1312,9 @@ class cex(ccxt.async_support.cex):
     async def cancel_orders_ws(self, ids: List[str], symbol: Str = None, params={}):
         """
         cancel multiple orders
-        :see: https://docs.cex.io/#ws-api-mass-cancel-place
+
+        https://docs.cex.io/#ws-api-mass-cancel-place
+
         :param str[] ids: order ids
         :param str symbol: not used by cex cancelOrders()
         :param dict [params]: extra parameters specific to the cex api endpoint
@@ -1344,7 +1378,7 @@ class cex(ccxt.async_support.cex):
         #
         return message
 
-    def handle_error_message(self, client: Client, message):
+    def handle_error_message(self, client: Client, message) -> Bool:
         #
         #     {
         #         "e": "get-balance",
@@ -1366,6 +1400,7 @@ class cex(ccxt.async_support.cex):
             future = self.safe_value(client['futures'], messageHash)
             if future is not None:
                 client.reject(error, messageHash)
+                return True
             else:
                 raise error
 

ccxt/pro/coinbase.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCacheBySymbolById
 import hashlib
-from ccxt.base.types import Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Any, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -14,7 +14,7 @@ from ccxt.base.errors import ArgumentsRequired
 
 class coinbase(ccxt.async_support.coinbase):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(coinbase, self).describe(), {
             'has': {
                 'ws': True,
@@ -56,11 +56,14 @@ class coinbase(ccxt.async_support.coinbase):
 
     async def subscribe(self, name: str, isPrivate: bool, symbol=None, params={}):
         """
-         * @ignore
+ @ignore
         subscribes to a websocket channel
-        :see: https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
+
         :param str name: the name of the channel
-        :param string|str[] [symbol]: unified market symbol
+        :param boolean isPrivate: whether the channel is private or not
+        :param str [symbol]: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: subscription to a websocket channel
         """
@@ -75,7 +78,7 @@ class coinbase(ccxt.async_support.coinbase):
             messageHash = messageHash + '::' + ','.join(symbol)
         elif symbol is not None:
             market = self.market(symbol)
-            messageHash = name + '::' + market['id']
+            messageHash = name + '::' + symbol
             productIds = [market['id']]
         url = self.urls['api']['ws']
         subscribe = {
@@ -92,10 +95,13 @@ class coinbase(ccxt.async_support.coinbase):
 
     async def subscribe_multiple(self, name: str, isPrivate: bool, symbols: Strings = None, params={}):
         """
-         * @ignore
+ @ignore
         subscribes to a websocket channel
-        :see: https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-overview#subscribe
+
         :param str name: the name of the channel
+        :param boolean isPrivate: whether the channel is private or not
         :param str[] [symbols]: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: subscription to a websocket channel
@@ -109,7 +115,7 @@ class coinbase(ccxt.async_support.coinbase):
             market = self.market(symbol)
             marketId = market['id']
             productIds.append(marketId)
-            messageHashes.append(name + '::' + marketId)
+            messageHashes.append(name + '::' + symbol)
         url = self.urls['api']['ws']
         subscribe = {
             'type': 'subscribe',
@@ -147,27 +153,36 @@ class coinbase(ccxt.async_support.coinbase):
     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.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#ticker-channel
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#ticker-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
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
+        await self.load_markets()
         name = 'ticker'
         return await self.subscribe(name, False, symbol, params)
 
     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/advanced-trade-api/docs/ws-channels#ticker-batch-channel
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#ticker-batch-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
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
+        await self.load_markets()
         if symbols is None:
             symbols = self.symbols
         name = 'ticker_batch'
-        tickers = await self.subscribe(name, False, symbols, params)
+        ticker = await self.subscribe_multiple(name, False, symbols, params)
         if self.newUpdates:
+            tickers = {}
+            symbol = ticker['symbol']
+            tickers[symbol] = ticker
             return tickers
         return self.tickers
 
@@ -262,7 +277,7 @@ class coinbase(ccxt.async_support.coinbase):
         #
         #
         channel = self.safe_string(message, 'channel')
-        events = self.safe_value(message, 'events', [])
+        events = self.safe_list(message, 'events', [])
         datetime = self.safe_string(message, 'timestamp')
         timestamp = self.parse8601(datetime)
         newTickers = []
@@ -271,31 +286,18 @@ class coinbase(ccxt.async_support.coinbase):
             tickers = self.safe_list(tickersObj, 'tickers', [])
             for j in range(0, len(tickers)):
                 ticker = tickers[j]
+                wsMarketId = self.safe_string(ticker, 'product_id')
+                if wsMarketId is None:
+                    continue
                 result = self.parse_ws_ticker(ticker)
                 result['timestamp'] = timestamp
                 result['datetime'] = datetime
                 symbol = result['symbol']
                 self.tickers[symbol] = result
-                wsMarketId = self.safe_string(ticker, 'product_id')
-                if wsMarketId is None:
-                    continue
-                messageHash = channel + '::' + wsMarketId
                 newTickers.append(result)
+                messageHash = channel + '::' + symbol
                 client.resolve(result, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(result, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-        messageHashes = self.find_message_hashes(client, 'ticker_batch::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            tickers = self.filter_by_array(newTickers, 'symbol', symbols)
-            if not self.is_empty(tickers):
-                client.resolve(tickers, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(tickers, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-        return message
+                self.try_resolve_usdc(client, messageHash, result)
 
     def parse_ws_ticker(self, ticker, market=None):
         #
@@ -345,7 +347,9 @@ class coinbase(ccxt.async_support.coinbase):
     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.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
+
         :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
@@ -363,7 +367,9 @@ class coinbase(ccxt.async_support.coinbase):
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
-        :see: https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#market-trades-channel
+
         :param str[] symbols: 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
@@ -382,7 +388,9 @@ class coinbase(ccxt.async_support.coinbase):
     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.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#user-channel
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#user-channel
+
         :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
@@ -399,7 +407,9 @@ class coinbase(ccxt.async_support.coinbase):
     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.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#level2-channel
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#level2-channel
+
         :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
@@ -415,7 +425,9 @@ class coinbase(ccxt.async_support.coinbase):
     async def watch_order_book_for_symbols(self, symbols: List[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.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#level2-channel
+
+        https://docs.cloud.coinbase.com/advanced-trade-api/docs/ws-channels#level2-channel
+
         :param str[] symbols: unified array of symbols
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -450,13 +462,13 @@ class coinbase(ccxt.async_support.coinbase):
         #        ]
         #    }
         #
-        events = self.safe_value(message, 'events')
+        events = self.safe_list(message, 'events')
         event = self.safe_value(events, 0)
-        trades = self.safe_value(event, 'trades')
-        trade = self.safe_value(trades, 0)
+        trades = self.safe_list(event, 'trades')
+        trade = self.safe_dict(trades, 0)
         marketId = self.safe_string(trade, 'product_id')
-        messageHash = 'market_trades::' + marketId
         symbol = self.safe_symbol(marketId)
+        messageHash = 'market_trades::' + symbol
         tradesArray = self.safe_value(self.trades, symbol)
         if tradesArray is None:
             tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
@@ -464,14 +476,12 @@ class coinbase(ccxt.async_support.coinbase):
             self.trades[symbol] = tradesArray
         for i in range(0, len(events)):
             currentEvent = events[i]
-            currentTrades = self.safe_value(currentEvent, 'trades')
+            currentTrades = self.safe_list(currentEvent, 'trades')
             for j in range(0, len(currentTrades)):
                 item = currentTrades[i]
                 tradesArray.append(self.parse_trade(item))
         client.resolve(tradesArray, messageHash)
-        if marketId.endswith('USD'):
-            client.resolve(tradesArray, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-        return message
+        self.try_resolve_usdc(client, messageHash, tradesArray)
 
     def handle_order(self, client, message):
         #
@@ -502,14 +512,14 @@ class coinbase(ccxt.async_support.coinbase):
         #        ]
         #    }
         #
-        events = self.safe_value(message, 'events')
+        events = self.safe_list(message, 'events')
         marketIds = []
         if self.orders is None:
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
             self.orders = ArrayCacheBySymbolById(limit)
         for i in range(0, len(events)):
             event = events[i]
-            responseOrders = self.safe_value(event, 'orders')
+            responseOrders = self.safe_list(event, 'orders')
             for j in range(0, len(responseOrders)):
                 responseOrder = responseOrders[j]
                 parsed = self.parse_ws_order(responseOrder)
@@ -520,12 +530,11 @@ class coinbase(ccxt.async_support.coinbase):
                 cachedOrders.append(parsed)
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
-            messageHash = 'user::' + marketId
+            symbol = self.safe_symbol(marketId)
+            messageHash = 'user::' + symbol
             client.resolve(self.orders, messageHash)
-            if messageHash.endswith('USD'):
-                client.resolve(self.orders, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
+            self.try_resolve_usdc(client, messageHash, self.orders)
         client.resolve(self.orders, 'user')
-        return message
 
     def parse_ws_order(self, order, market=None):
         #
@@ -601,7 +610,7 @@ class coinbase(ccxt.async_support.coinbase):
         #                    {
         #                        "side": "bid",
         #                        "event_time": "1970-01-01T00:00:00Z",
-        #                        "price_level": "21921.73",
+        #                        "price_level": "21921.74",
         #                        "new_quantity": "0.06317902"
         #                    },
         #                    {
@@ -615,36 +624,35 @@ class coinbase(ccxt.async_support.coinbase):
         #        ]
         #    }
         #
-        events = self.safe_value(message, 'events')
+        events = self.safe_list(message, 'events')
         datetime = self.safe_string(message, 'timestamp')
         for i in range(0, len(events)):
             event = events[i]
-            updates = self.safe_value(event, 'updates', [])
+            updates = self.safe_list(event, 'updates', [])
             marketId = self.safe_string(event, 'product_id')
-            messageHash = 'level2::' + marketId
+            # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD, are aliases
+            market = self.safe_market(marketId)
+            symbol = market['symbol']
+            messageHash = 'level2::' + symbol
             subscription = self.safe_value(client.subscriptions, messageHash, {})
             limit = self.safe_integer(subscription, 'limit')
-            symbol = self.safe_symbol(marketId)
             type = self.safe_string(event, 'type')
             if type == 'snapshot':
                 self.orderbooks[symbol] = self.order_book({}, limit)
-                orderbook = self.orderbooks[symbol]
-                self.handle_order_book_helper(orderbook, updates)
-                orderbook['timestamp'] = self.parse8601(datetime)
-                orderbook['datetime'] = datetime
-                orderbook['symbol'] = symbol
-                client.resolve(orderbook, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(orderbook, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
-            elif type == 'update':
-                orderbook = self.orderbooks[symbol]
-                self.handle_order_book_helper(orderbook, updates)
-                orderbook['datetime'] = datetime
-                orderbook['timestamp'] = self.parse8601(datetime)
-                orderbook['symbol'] = symbol
-                client.resolve(orderbook, messageHash)
-                if messageHash.endswith('USD'):
-                    client.resolve(orderbook, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
+            # unknown bug, can't reproduce, but sometimes orderbook is None
+            if not (symbol in self.orderbooks) and self.orderbooks[symbol] is None:
+                continue
+            orderbook = self.orderbooks[symbol]
+            self.handle_order_book_helper(orderbook, updates)
+            orderbook['timestamp'] = self.parse8601(datetime)
+            orderbook['datetime'] = datetime
+            orderbook['symbol'] = symbol
+            client.resolve(orderbook, messageHash)
+            self.try_resolve_usdc(client, messageHash, orderbook)
+
+    def try_resolve_usdc(self, client, messageHash, result):
+        if messageHash.endswith('/USD') or messageHash.endswith('-USD'):
+            client.resolve(result, messageHash + 'C')  # when subscribing to BTC/USDC and coinbase returns BTC/USD, so resolve USDC too
 
     def handle_subscription_status(self, client, message):
         #
@@ -660,6 +668,25 @@ class coinbase(ccxt.async_support.coinbase):
         #
         return message
 
+    def handle_heartbeats(self, client, message):
+        # although the subscription takes a product_ids parameter(i.e. symbol),
+        # there is no(clear) way of mapping the message back to the symbol.
+        #
+        #     {
+        #         "channel": "heartbeats",
+        #         "client_id": "",
+        #         "timestamp": "2023-06-23T20:31:26.122969572Z",
+        #         "sequence_num": 0,
+        #         "events": [
+        #           {
+        #               "current_time": "2023-06-23 20:31:56.121961769 +0000 UTC m=+91717.525857105",
+        #               "heartbeat_counter": "3049"
+        #           }
+        #         ]
+        #     }
+        #
+        return message
+
     def handle_message(self, client, message):
         channel = self.safe_string(message, 'channel')
         methods: dict = {
@@ -669,10 +696,12 @@ class coinbase(ccxt.async_support.coinbase):
             'market_trades': self.handle_trade,
             'user': self.handle_order,
             'l2_data': self.handle_order_book,
+            'heartbeats': self.handle_heartbeats,
         }
         type = self.safe_string(message, 'type')
         if type == 'error':
             errorMessage = self.safe_string(message, 'message')
             raise ExchangeError(errorMessage)
         method = self.safe_value(methods, channel)
-        method(client, message)
+        if method:
+            method(client, message)

ccxt/pro/coinbaseadvanced.py

@@ -4,11 +4,12 @@
 # https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 
 from ccxt.pro.coinbase import coinbase
+from ccxt.base.types import Any
 
 
 class coinbaseadvanced(coinbase):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(coinbaseadvanced, self).describe(), {
             'id': 'coinbaseadvanced',
             'name': 'Coinbase Advanced',