ccxt 4.2.77__py2.py3-none-any.whl → 4.4.49__py2.py3-none-any.whl

ccxt/pro/coinbase.py

@@ -9,6 +9,7 @@ import hashlib
 from ccxt.base.types import Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import ArgumentsRequired
 
 
 class coinbase(ccxt.async_support.coinbase):
@@ -30,10 +31,12 @@ class coinbase(ccxt.async_support.coinbase):
                 'watchMyTrades': False,
                 'watchOHLCV': False,
                 'watchOrderBook': True,
+                'watchOrderBookForSymbols': True,
                 'watchOrders': True,
                 'watchTicker': True,
                 'watchTickers': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': True,
             },
             'urls': {
                 'api': {
@@ -51,18 +54,20 @@ class coinbase(ccxt.async_support.coinbase):
             },
         })
 
-    async def subscribe(self, name, symbol=None, params={}):
+    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
         """
         await self.load_markets()
-        self.check_required_credentials()
         market = None
         messageHash = name
         productIds = []
@@ -76,33 +81,94 @@ class coinbase(ccxt.async_support.coinbase):
             messageHash = name + '::' + market['id']
             productIds = [market['id']]
         url = self.urls['api']['ws']
-        timestamp = self.number_to_string(self.seconds())
-        auth = timestamp + name + ','.join(productIds)
         subscribe = {
             'type': 'subscribe',
             'product_ids': productIds,
             'channel': name,
-            'api_key': self.apiKey,
-            'timestamp': timestamp,
-            'signature': self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256),
+            # 'api_key': self.apiKey,
+            # 'timestamp': timestamp,
+            # 'signature': self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256),
         }
+        if isPrivate:
+            subscribe = self.extend(subscribe, self.create_ws_auth(name, productIds))
         return await self.watch(url, messageHash, subscribe, messageHash)
 
+    async def subscribe_multiple(self, name: str, isPrivate: bool, symbols: Strings = None, params={}):
+        """
+ @ignore
+        subscribes to a websocket channel
+
+        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
+        """
+        await self.load_markets()
+        productIds = []
+        messageHashes = []
+        symbols = self.market_symbols(symbols, None, False)
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            market = self.market(symbol)
+            marketId = market['id']
+            productIds.append(marketId)
+            messageHashes.append(name + '::' + marketId)
+        url = self.urls['api']['ws']
+        subscribe = {
+            'type': 'subscribe',
+            'product_ids': productIds,
+            'channel': name,
+        }
+        if isPrivate:
+            subscribe = self.extend(subscribe, self.create_ws_auth(name, productIds))
+        return await self.watch_multiple(url, messageHashes, subscribe, messageHashes)
+
+    def create_ws_auth(self, name: str, productIds: List[str]):
+        subscribe: dict = {}
+        timestamp = self.number_to_string(self.seconds())
+        self.check_required_credentials()
+        isCloudAPiKey = (self.apiKey.find('organizations/') >= 0) or (self.secret.startswith('-----BEGIN'))
+        auth = timestamp + name + ','.join(productIds)
+        if not isCloudAPiKey:
+            subscribe['api_key'] = self.apiKey
+            subscribe['timestamp'] = timestamp
+            subscribe['signature'] = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
+        else:
+            if self.apiKey.startswith('-----BEGIN'):
+                raise ArgumentsRequired(self.id + ' apiKey should contain the name(eg: organizations/3b910e93....) and not the public key')
+            currentToken = self.safe_string(self.options, 'wsToken')
+            tokenTimestamp = self.safe_integer(self.options, 'wsTokenTimestamp', 0)
+            seconds = self.seconds()
+            if currentToken is None or tokenTimestamp + 120 < seconds:
+                # we should generate new token
+                token = self.create_auth_token(seconds)
+                self.options['wsToken'] = token
+                self.options['wsTokenTimestamp'] = seconds
+            subscribe['jwt'] = self.safe_string(self.options, 'wsToken')
+        return subscribe
+
     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>`
         """
         name = 'ticker'
-        return await self.subscribe(name, symbol, params)
+        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>`
@@ -110,7 +176,7 @@ class coinbase(ccxt.async_support.coinbase):
         if symbols is None:
             symbols = self.symbols
         name = 'ticker_batch'
-        tickers = await self.subscribe(name, symbols, params)
+        tickers = await self.subscribe(name, False, symbols, params)
         if self.newUpdates:
             return tickers
         return self.tickers
@@ -136,6 +202,11 @@ class coinbase(ccxt.async_support.coinbase):
         #                        "low_52_w": "15460",
         #                        "high_52_w": "48240",
         #                        "price_percent_chg_24_h": "-4.15775596190603"
+        # new 2024-04-12
+        #                        "best_bid":"21835.29",
+        #                        "best_bid_quantity": "0.02000000",
+        #                        "best_ask":"23011.18",
+        #                        "best_ask_quantity": "0.01500000"
         #                    }
         #                ]
         #            }
@@ -161,27 +232,68 @@ class coinbase(ccxt.async_support.coinbase):
         #                        "low_52_w": "0.04908",
         #                        "high_52_w": "0.1801",
         #                        "price_percent_chg_24_h": "0.50177456859626"
+        # new 2024-04-12
+        #                        "best_bid":"0.07989",
+        #                        "best_bid_quantity": "500.0",
+        #                        "best_ask":"0.08308",
+        #                        "best_ask_quantity": "300.0"
+        #                    }
+        #                ]
+        #            }
+        #        ]
+        #    }
+        #
+        # note! seems coinbase might also send empty data like:
+        #
+        #    {
+        #        "channel": "ticker_batch",
+        #        "client_id": "",
+        #        "timestamp": "2024-05-24T18:22:24.546809523Z",
+        #        "sequence_num": 1,
+        #        "events": [
+        #            {
+        #                "type": "snapshot",
+        #                "tickers": [
+        #                    {
+        #                        "type": "ticker",
+        #                        "product_id": "",
+        #                        "price": "",
+        #                        "volume_24_h": "",
+        #                        "low_24_h": "",
+        #                        "high_24_h": "",
+        #                        "low_52_w": "",
+        #                        "high_52_w": "",
+        #                        "price_percent_chg_24_h": ""
         #                    }
         #                ]
         #            }
         #        ]
         #    }
         #
+        #
         channel = self.safe_string(message, 'channel')
         events = self.safe_value(message, 'events', [])
+        datetime = self.safe_string(message, 'timestamp')
+        timestamp = self.parse8601(datetime)
         newTickers = []
         for i in range(0, len(events)):
             tickersObj = events[i]
-            tickers = self.safe_value(tickersObj, 'tickers', [])
+            tickers = self.safe_list(tickersObj, 'tickers', [])
             for j in range(0, len(tickers)):
                 ticker = tickers[j]
                 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)
                 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]
@@ -191,6 +303,8 @@ class coinbase(ccxt.async_support.coinbase):
             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
 
     def parse_ws_ticker(self, ticker, market=None):
@@ -205,6 +319,11 @@ class coinbase(ccxt.async_support.coinbase):
         #         "low_52_w": "0.04908",
         #         "high_52_w": "0.1801",
         #         "price_percent_chg_24_h": "0.50177456859626"
+        # new 2024-04-12
+        #         "best_bid":"0.07989",
+        #         "best_bid_quantity": "500.0",
+        #         "best_ask":"0.08308",
+        #         "best_ask_quantity": "300.0"
         #     }
         #
         marketId = self.safe_string(ticker, 'product_id')
@@ -217,10 +336,10 @@ class coinbase(ccxt.async_support.coinbase):
             'datetime': self.iso8601(timestamp),
             'high': self.safe_string(ticker, 'high_24_h'),
             'low': self.safe_string(ticker, 'low_24_h'),
-            'bid': None,
-            'bidVolume': None,
-            'ask': None,
-            'askVolume': None,
+            'bid': self.safe_string(ticker, 'best_bid'),
+            'bidVolume': self.safe_string(ticker, 'best_bid_quantity'),
+            'ask': self.safe_string(ticker, 'best_ask'),
+            'askVolume': self.safe_string(ticker, 'best_ask_quantity'),
             'vwap': None,
             'open': None,
             'close': last,
@@ -236,7 +355,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
@@ -246,15 +367,38 @@ class coinbase(ccxt.async_support.coinbase):
         await self.load_markets()
         symbol = self.symbol(symbol)
         name = 'market_trades'
-        trades = await self.subscribe(name, symbol, params)
+        trades = await self.subscribe(name, False, symbol, params)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    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
+
+        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
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        await self.load_markets()
+        name = 'market_trades'
+        trades = await self.subscribe_multiple(name, False, symbols, params)
+        if self.newUpdates:
+            first = self.safe_dict(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
+        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+
     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
@@ -263,7 +407,7 @@ class coinbase(ccxt.async_support.coinbase):
         """
         await self.load_markets()
         name = 'user'
-        orders = await self.subscribe(name, symbol, params)
+        orders = await self.subscribe(name, True, symbol, params)
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
         return self.filter_by_since_limit(orders, since, limit, 'timestamp', True)
@@ -271,7 +415,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
@@ -281,7 +427,23 @@ class coinbase(ccxt.async_support.coinbase):
         name = 'level2'
         market = self.market(symbol)
         symbol = market['symbol']
-        orderbook = await self.subscribe(name, symbol, params)
+        orderbook = await self.subscribe(name, False, symbol, params)
+        return orderbook.limit()
+
+    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
+
+        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
+        :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 = 'level2'
+        orderbook = await self.subscribe_multiple(name, False, symbols, params)
         return orderbook.limit()
 
     def handle_trade(self, client, message):
@@ -327,6 +489,8 @@ class coinbase(ccxt.async_support.coinbase):
                 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
 
     def handle_order(self, client, message):
@@ -378,6 +542,8 @@ class coinbase(ccxt.async_support.coinbase):
             marketId = marketIds[i]
             messageHash = 'user::' + marketId
             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
         client.resolve(self.orders, 'user')
         return message
 
@@ -484,10 +650,12 @@ class coinbase(ccxt.async_support.coinbase):
                 self.orderbooks[symbol] = self.order_book({}, limit)
                 orderbook = self.orderbooks[symbol]
                 self.handle_order_book_helper(orderbook, updates)
-                orderbook['timestamp'] = None
-                orderbook['datetime'] = None
+                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)
@@ -495,7 +663,8 @@ class coinbase(ccxt.async_support.coinbase):
                 orderbook['timestamp'] = self.parse8601(datetime)
                 orderbook['symbol'] = symbol
                 client.resolve(orderbook, messageHash)
-        return message
+                if messageHash.endswith('USD'):
+                    client.resolve(orderbook, messageHash + 'C')  # sometimes we subscribe to BTC/USDC and coinbase returns BTC/USD
 
     def handle_subscription_status(self, client, message):
         #
@@ -511,19 +680,40 @@ 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 = {
+        methods: dict = {
             'subscriptions': self.handle_subscription_status,
             'ticker': self.handle_tickers,
             'ticker_batch': self.handle_tickers,
             '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/{async_support/hitbtc3.py → pro/coinbaseadvanced.py}

@@ -3,14 +3,14 @@
 # PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
 # https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 
-from ccxt.async_support.hitbtc import hitbtc
-from ccxt.abstract.hitbtc3 import ImplicitAPI
+from ccxt.pro.coinbase import coinbase
 
 
-class hitbtc3(hitbtc, ImplicitAPI):
+class coinbaseadvanced(coinbase):
 
     def describe(self):
-        return self.deep_extend(super(hitbtc3, self).describe(), {
-            'id': 'hitbtc3',
+        return self.deep_extend(super(coinbaseadvanced, self).describe(), {
+            'id': 'coinbaseadvanced',
+            'name': 'Coinbase Advanced',
             'alias': True,
         })

ccxt/pro/{coinbasepro.py → coinbaseexchange.py}

@@ -10,16 +10,16 @@ from ccxt.base.types import Int, Order, OrderBook, Str, Strings, Ticker, Tickers
 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 ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
-from ccxt.base.errors import AuthenticationError
 
 
-class coinbasepro(ccxt.async_support.coinbasepro):
+class coinbaseexchange(ccxt.async_support.coinbaseexchange):
 
     def describe(self):
-        return self.deep_extend(super(coinbasepro, self).describe(), {
+        return self.deep_extend(super(coinbaseexchange, self).describe(), {
             'has': {
                 'ws': True,
                 'watchOHLCV': False,  # missing on the exchange side
@@ -38,7 +38,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             },
             'urls': {
                 'api': {
-                    'ws': 'wss://ws-feed.pro.coinbase.com',
+                    'ws': 'wss://ws-feed.exchange.coinbase.com',
                 },
                 'test': {
                     'ws': 'wss://ws-feed-public.sandbox.exchange.coinbase.com',
@@ -77,7 +77,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         if 'signature' in params:
             # need to distinguish between public trades and user trades
             url = url + '?'
-        subscribe = {
+        subscribe: dict = {
             'type': 'subscribe',
             'product_ids': productIds,
             'channels': [
@@ -102,7 +102,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         if 'signature' in params:
             # need to distinguish between public trades and user trades
             url = url + '?'
-        subscribe = {
+        subscribe: dict = {
             'type': 'subscribe',
             'product_ids': productIds,
             'channels': [
@@ -138,7 +138,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         messageHash = 'ticker'
         ticker = await self.subscribe_multiple(channel, symbols, messageHash, params)
         if self.newUpdates:
-            result = {}
+            result: dict = {}
             result[ticker['symbol']] = ticker
             return result
         return self.filter_by_array(self.tickers, 'symbol', symbols)
@@ -163,7 +163,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
     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
-        :param str symbol: unified symbol of the market to fetch trades for
+        :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
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -189,7 +189,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         :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]{@link https://docs.ccxt.com/#/?id=trade-structure
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         if symbol is None:
             raise ArgumentsRequired(self.id + ' watchMyTrades() requires a symbol argument')
@@ -210,7 +210,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         :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]{@link https://docs.ccxt.com/#/?id=trade-structure
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         symbols = self.market_symbols(symbols, None, False)
         await self.load_markets()
@@ -286,7 +286,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             marketId = marketIds[i]
             messageHashes.append(name + ':' + marketId)
         url = self.urls['api']['ws']
-        subscribe = {
+        subscribe: dict = {
             'type': 'subscribe',
             'product_ids': marketIds,
             'channels': [
@@ -294,7 +294,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             ],
         }
         request = self.extend(subscribe, params)
-        subscription = {
+        subscription: dict = {
             'messageHash': name,
             'symbols': symbols,
             'marketIds': marketIds,
@@ -318,7 +318,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         symbol = market['symbol']
         messageHash = name + ':' + market['id']
         url = self.urls['api']['ws']
-        subscribe = {
+        subscribe: dict = {
             'type': 'subscribe',
             'product_ids': [
                 market['id'],
@@ -328,7 +328,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             ],
         }
         request = self.extend(subscribe, params)
-        subscription = {
+        subscription: dict = {
             'messageHash': messageHash,
             'symbol': symbol,
             'marketId': market['id'],
@@ -437,7 +437,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         #     "side": "buy",
         #     "order_type": "limit"
         # }
-        parsed = super(coinbasepro, self).parse_trade(trade)
+        parsed = super(coinbaseexchange, self).parse_trade(trade)
         feeRate = None
         isMaker = False
         if 'maker_fee_rate' in trade:
@@ -470,7 +470,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         return parsed
 
     def parse_ws_order_status(self, status):
-        statuses = {
+        statuses: dict = {
             'filled': 'closed',
             'canceled': 'canceled',
         }
@@ -727,7 +727,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         #
         type = self.safe_string(ticker, 'type')
         if type is None:
-            return super(coinbasepro, self).parse_ticker(ticker, market)
+            return super(coinbaseexchange, self).parse_ticker(ticker, market)
         marketId = self.safe_string(ticker, 'product_id')
         symbol = self.safe_symbol(marketId, market, '-')
         timestamp = self.parse8601(self.safe_string(ticker, 'time'))
@@ -811,7 +811,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             orderbook = self.orderbooks[symbol]
             timestamp = self.parse8601(self.safe_string(message, 'time'))
             changes = self.safe_value(message, 'changes', [])
-            sides = {
+            sides: dict = {
                 'sell': 'asks',
                 'buy': 'bids',
             }
@@ -870,7 +870,7 @@ class coinbasepro(ccxt.async_support.coinbasepro):
 
     def handle_message(self, client: Client, message):
         type = self.safe_string(message, 'type')
-        methods = {
+        methods: dict = {
             'snapshot': self.handle_order_book,
             'l2update': self.handle_order_book,
             'subscribe': self.handle_subscription_status,