ccxt 4.2.90__py2.py3-none-any.whl → 4.2.91__py2.py3-none-any.whl

ccxt/pro/bitmex.py

@@ -540,8 +540,8 @@ class bitmex(ccxt.async_support.bitmex):
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
             market = self.safe_market(marketId)
-            messageHash = table + ':' + marketId
             symbol = market['symbol']
+            messageHash = table + ':' + symbol
             trades = self.parse_trades(dataByMarketIds[marketId], market)
             stored = self.safe_value(self.trades, symbol)
             if stored is None:
@@ -561,22 +561,7 @@ class bitmex(ccxt.async_support.bitmex):
         :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()
-        market = self.market(symbol)
-        symbol = market['symbol']
-        table = 'trade'
-        messageHash = table + ':' + market['id']
-        url = self.urls['api']['ws']
-        request = {
-            'op': 'subscribe',
-            'args': [
-                messageHash,
-            ],
-        }
-        trades = await self.watch(url, messageHash, self.extend(request, params), messageHash)
-        if self.newUpdates:
-            limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+        return await self.watch_trades_for_symbols([symbol], since, limit, params)
 
     async def authenticate(self, params={}):
         url = self.urls['api']['ws']
@@ -1171,6 +1156,39 @@ class bitmex(ccxt.async_support.bitmex):
         orderbook = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), topics)
         return orderbook.limit()
 
+    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 list of symbols
+        :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()
+        symbols = self.market_symbols(symbols, None, False)
+        table = 'trade'
+        topics = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            market = self.market(symbol)
+            topic = table + ':' + market['id']
+            topics.append(topic)
+            messageHash = table + ':' + symbol
+            messageHashes.append(messageHash)
+        url = self.urls['api']['ws']
+        request = {
+            'op': 'subscribe',
+            'args': topics,
+        }
+        trades = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), topics)
+        if self.newUpdates:
+            first = self.safe_value(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_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

ccxt/pro/kucoin.py

@@ -25,6 +25,7 @@ class kucoin(ccxt.async_support.kucoin):
                 'cancelOrderWs': False,
                 'cancelOrdersWs': False,
                 'cancelAllOrdersWs': False,
+                'watchBidsAsks': True,
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchMyTrades': True,
@@ -273,6 +274,87 @@ class kucoin(ccxt.async_support.kucoin):
             if numTickers > 0:
                 client.resolve(tickers, currentMessageHash)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level1-bbo-market-data
+        watches best bid & ask for symbols
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        ticker = await self.watch_multi_helper('watchBidsAsks', '/spotMarket/level1:', symbols, params)
+        if self.newUpdates:
+            tickers = {}
+            tickers[ticker['symbol']] = ticker
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    async def watch_multi_helper(self, methodName, channelName: str, symbols: Strings = None, params={}):
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False, True, False)
+        length = len(symbols)
+        if length > 100:
+            raise ArgumentsRequired(self.id + ' ' + methodName + '() accepts a maximum of 100 symbols')
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            market = self.market(symbol)
+            messageHashes.append('bidask@' + market['symbol'])
+        url = await self.negotiate(False)
+        marketIds = self.market_ids(symbols)
+        joined = ','.join(marketIds)
+        requestId = str(self.request_id())
+        request = {
+            'id': requestId,
+            'type': 'subscribe',
+            'topic': channelName + joined,
+            'response': True,
+        }
+        message = self.extend(request, params)
+        return await self.watch_multiple(url, messageHashes, message, messageHashes)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        # arrives one symbol dict
+        #
+        #     {
+        #         topic: '/spotMarket/level1:ETH-USDT',
+        #         type: 'message',
+        #         data: {
+        #             asks: ['3347.42', '2.0778387'],
+        #             bids: ['3347.41', '6.0411697'],
+        #             timestamp: 1712231142085
+        #         },
+        #         subject: 'level1'
+        #     }
+        #
+        parsedTicker = self.parse_ws_bid_ask(message)
+        symbol = parsedTicker['symbol']
+        self.bidsasks[symbol] = parsedTicker
+        messageHash = 'bidask@' + symbol
+        client.resolve(parsedTicker, messageHash)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        topic = self.safe_string(ticker, 'topic')
+        parts = topic.split(':')
+        marketId = parts[1]
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        data = self.safe_dict(ticker, 'data', {})
+        ask = self.safe_list(data, 'asks', [])
+        bid = self.safe_list(data, 'bids', [])
+        timestamp = self.safe_integer(data, 'timestamp')
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_number(ask, 0),
+            'askVolume': self.safe_number(ask, 1),
+            'bid': self.safe_number(bid, 0),
+            'bidVolume': self.safe_number(bid, 1),
+            'info': ticker,
+        }, market)
+
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
@@ -625,6 +707,8 @@ class kucoin(ccxt.async_support.kucoin):
         #     }
         #
         id = self.safe_string(message, 'id')
+        if not (id in client.subscriptions):
+            return
         subscriptionHash = self.safe_string(client.subscriptions, id)
         subscription = self.safe_value(client.subscriptions, subscriptionHash)
         del client.subscriptions[id]
@@ -978,6 +1062,7 @@ class kucoin(ccxt.async_support.kucoin):
             return
         subject = self.safe_string(message, 'subject')
         methods = {
+            'level1': self.handle_bid_ask,
             'level2': self.handle_order_book,
             'trade.l2update': self.handle_order_book,
             'trade.ticker': self.handle_ticker,

ccxt/pro/kucoinfutures.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById
-from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Ticker, Trade
+from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -19,6 +19,8 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             'has': {
                 'ws': True,
                 'watchTicker': True,
+                'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchTrades': True,
                 'watchOrderBook': True,
                 'watchOrders': True,
@@ -48,9 +50,6 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
                     'snapshotDelay': 20,
                     'snapshotMaxRetries': 3,
                 },
-                'watchTicker': {
-                    'name': 'contractMarket/tickerV2',  # market/ticker
-                },
                 'watchPosition': {
                     'fetchPositionSnapshot': True,  # or False
                     'awaitPositionSnapshot': True,  # whether to wait for the position snapshot before providing updates
@@ -146,7 +145,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             subscription = self.extend(subscriptionRequest, subscription)
         return await self.watch(url, messageHash, message, subscriptionHash, subscription)
 
-    async def subscribe_multiple(self, url, messageHashes, topic, subscriptionHashes, subscription, params={}):
+    async def subscribe_multiple(self, url, messageHashes, topic, subscriptionHashes, subscriptionArgs, params={}):
         requestId = str(self.request_id())
         request = {
             'id': requestId,
@@ -154,20 +153,12 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             'topic': topic,
             'response': True,
         }
-        message = self.extend(request, params)
-        subscriptionRequest = {
-            'id': requestId,
-        }
-        if subscription is None:
-            subscription = subscriptionRequest
-        else:
-            subscription = self.extend(subscriptionRequest, subscription)
-        return await self.watch_multiple(url, messageHashes, message, subscriptionHashes, subscription)
+        return await self.watch_multiple(url, messageHashes, self.extend(request, params), subscriptionHashes, subscriptionArgs)
 
     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.kucoin.com/futures/#get-real-time-symbol-ticker-v2
+        :see: https://www.kucoin.com/docs/websocket/futures-trading/public-channels/get-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>`
@@ -175,30 +166,45 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         await self.load_markets()
         market = self.market(symbol)
         symbol = market['symbol']
-        url = await self.negotiate(False)
-        options = self.safe_value(self.options, 'watchTicker', {})
-        channel = self.safe_string(options, 'name', 'contractMarket/tickerV2')
-        topic = '/' + channel + ':' + market['id']
-        messageHash = 'ticker:' + symbol
-        return await self.subscribe(url, messageHash, topic, None, params)
+        params['callerMethodName'] = 'watchTicker'
+        tickers = await self.watch_tickers([symbol], params)
+        return tickers[symbol]
+
+    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 all markets of a specific list
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        ticker = await self.watch_multi_request('watchTickers', '/contractMarket/ticker:', symbols, params)
+        if self.newUpdates:
+            tickers = {}
+            tickers[ticker['symbol']] = ticker
+            return tickers
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
 
     def handle_ticker(self, client: Client, message):
         #
-        # market/tickerV2
+        # ticker(v1)
         #
         #    {
-        #        "type": "message",
-        #        "topic": "/contractMarket/tickerV2:ADAUSDTM",
-        #        "subject": "tickerV2",
-        #        "data": {
-        #            "symbol": "ADAUSDTM",
-        #            "sequence": 1668007800439,
-        #            "bestBidSize": 178,
-        #            "bestBidPrice": "0.35959",
-        #            "bestAskPrice": "0.35981",
-        #            "ts": "1668141430037124460",
-        #            "bestAskSize": 134
-        #        }
+        #     "subject": "ticker",
+        #     "topic": "/contractMarket/ticker:XBTUSDM",
+        #     "data": {
+        #         "symbol": "XBTUSDM",  #Market of the symbol
+        #         "sequence": 45,  #Sequence number which is used to judge the continuity of the pushed messages
+        #         "side": "sell",  #Transaction side of the last traded taker order
+        #         "price": "3600.0",  #Filled price
+        #         "size": 16,  #Filled quantity
+        #         "tradeId": "5c9dcf4170744d6f5a3d32fb",  #Order ID
+        #         "bestBidSize": 795,  #Best bid size
+        #         "bestBidPrice": "3200.0",  #Best bid
+        #         "bestAskPrice": "3600.0",  #Best ask size
+        #         "bestAskSize": 284,  #Best ask
+        #         "ts": 1553846081210004941  #Filled time - nanosecond
+        #     }
         #    }
         #
         data = self.safe_value(message, 'data', {})
@@ -206,9 +212,90 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         market = self.safe_market(marketId, None, '-')
         ticker = self.parse_ticker(data, market)
         self.tickers[market['symbol']] = ticker
-        messageHash = 'ticker:' + market['symbol']
-        client.resolve(ticker, messageHash)
-        return message
+        client.resolve(ticker, self.get_message_hash('ticker', market['symbol']))
+
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://www.kucoin.com/docs/websocket/futures-trading/public-channels/get-ticker-v2
+        watches best bid & ask for symbols
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        ticker = await self.watch_multi_request('watchBidsAsks', '/contractMarket/tickerV2:', symbols, params)
+        if self.newUpdates:
+            tickers = {}
+            tickers[ticker['symbol']] = ticker
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    async def watch_multi_request(self, methodName, channelName: str, symbols: Strings = None, params={}):
+        await self.load_markets()
+        methodName, params = self.handle_param_string(params, 'callerMethodName', methodName)
+        isBidsAsks = (methodName == 'watchBidsAsks')
+        symbols = self.market_symbols(symbols, None, False, True, False)
+        length = len(symbols)
+        if length > 100:
+            raise ArgumentsRequired(self.id + ' ' + methodName + '() accepts a maximum of 100 symbols')
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            market = self.market(symbol)
+            prefix = 'bidask' if isBidsAsks else 'ticker'
+            messageHashes.append(self.get_message_hash(prefix, market['symbol']))
+        url = await self.negotiate(False)
+        marketIds = self.market_ids(symbols)
+        joined = ','.join(marketIds)
+        requestId = str(self.request_id())
+        request = {
+            'id': requestId,
+            'type': 'subscribe',
+            'topic': channelName + joined,
+            'response': True,
+        }
+        subscription = {
+            'id': requestId,
+        }
+        return await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes, subscription)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        # arrives one symbol dict
+        #
+        # {
+        #   "subject": "tickerV2",
+        #   "topic": "/contractMarket/tickerV2:XBTUSDM",
+        #   "data": {
+        #     "symbol": "XBTUSDM",  #Market of the symbol
+        #     "bestBidSize": 795,  # Best bid size
+        #     "bestBidPrice": 3200.0,  # Best bid
+        #     "bestAskPrice": 3600.0,  # Best ask
+        #     "bestAskSize": 284,  # Best ask size
+        #     "ts": 1553846081210004941  # Filled time - nanosecond
+        #   }
+        # }
+        #
+        parsedTicker = self.parse_ws_bid_ask(message)
+        symbol = parsedTicker['symbol']
+        self.bidsasks[symbol] = parsedTicker
+        client.resolve(parsedTicker, self.get_message_hash('bidask', symbol))
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        data = self.safe_dict(ticker, 'data', {})
+        marketId = self.safe_string(data, 'symbol')
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        timestamp = self.safe_integer_product(data, 'ts', 0.000001)
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_number(data, 'bestAskPrice'),
+            'askVolume': self.safe_number(data, 'bestAskSize'),
+            'bid': self.safe_number(data, 'bestBidPrice'),
+            'bidVolume': self.safe_number(data, 'bestBidSize'),
+            'info': ticker,
+        }, market)
 
     async def watch_position(self, symbol: Str = None, params={}) -> Position:
         """
@@ -412,7 +499,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             marketId = marketIds[i]
             messageHashes.append('trades:' + symbol)
             subscriptionHashes.append('/contractMarket/execution:' + marketId)
-        trades = await self.subscribe_multiple(url, messageHashes, topic, subscriptionHashes, params)
+        trades = await self.subscribe_multiple(url, messageHashes, topic, subscriptionHashes, None, params)
         if self.newUpdates:
             first = self.safe_value(trades, 0)
             tradeSymbol = self.safe_string(first, 'symbol')
@@ -489,9 +576,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         marketIds = self.market_ids(symbols)
         url = await self.negotiate(False)
         topic = '/contractMarket/level2:' + ','.join(marketIds)
-        subscription = {
-            'method': self.handle_order_book_subscription,
-            'symbols': symbols,
+        subscriptionArgs = {
             'limit': limit,
         }
         subscriptionHashes = []
@@ -501,7 +586,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             marketId = marketIds[i]
             messageHashes.append('orderbook:' + symbol)
             subscriptionHashes.append('/contractMarket/level2:' + marketId)
-        orderbook = await self.subscribe_multiple(url, messageHashes, topic, subscriptionHashes, subscription, params)
+        orderbook = await self.subscribe_multiple(url, messageHashes, topic, subscriptionHashes, subscriptionArgs, params)
         return orderbook.limit()
 
     def handle_delta(self, orderbook, delta):
@@ -549,10 +634,12 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         marketId = self.safe_string(topicParts, 1)
         symbol = self.safe_symbol(marketId, None, '-')
         messageHash = 'orderbook:' + symbol
-        storedOrderBook = self.safe_value(self.orderbooks, symbol)
+        if not (symbol in self.orderbooks):
+            subscriptionArgs = self.safe_dict(client.subscriptions, topic, {})
+            limit = self.safe_integer(subscriptionArgs, 'limit')
+            self.orderbooks[symbol] = self.order_book({}, limit)
+        storedOrderBook = self.orderbooks[symbol]
         nonce = self.safe_integer(storedOrderBook, 'nonce')
-        if storedOrderBook is None:
-            return  # self shouldn't be needed, but for some reason sometimes self runs before handleOrderBookSubscription in c#
         deltaEnd = self.safe_integer(data, 'sequence')
         if nonce is None:
             cacheLength = len(storedOrderBook.cache)
@@ -590,35 +677,6 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
                 return i
         return len(cache)
 
-    def handle_order_book_subscription(self, client: Client, message, subscription):
-        limit = self.safe_integer(subscription, 'limit')
-        symbols = self.safe_value(subscription, 'symbols')
-        if symbols is None:
-            symbol = self.safe_string(subscription, 'symbol')
-            self.orderbooks[symbol] = self.order_book({}, limit)
-        else:
-            for i in range(0, len(symbols)):
-                symbol = symbols[i]
-                self.orderbooks[symbol] = self.order_book({}, limit)
-        # moved snapshot initialization to handleOrderBook to fix
-        # https://github.com/ccxt/ccxt/issues/6820
-        # the general idea is to fetch the snapshot after the first delta
-        # but not before, because otherwise we cannot synchronize the feed
-
-    def handle_subscription_status(self, client: Client, message):
-        #
-        #     {
-        #         "id": "1578090438322",
-        #         "type": "ack"
-        #     }
-        #
-        id = self.safe_string(message, 'id')
-        subscriptionsById = self.index_by(client.subscriptions, 'id')
-        subscription = self.safe_value(subscriptionsById, id, {})
-        method = self.safe_value(subscription, 'method')
-        if method is not None:
-            method(client, message, subscription)
-
     def handle_system_status(self, client: Client, message):
         #
         # todo: answer the question whether handleSystemStatus should be renamed
@@ -864,7 +922,8 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         subject = self.safe_string(message, 'subject')
         methods = {
             'level2': self.handle_order_book,
-            'tickerV2': self.handle_ticker,
+            'ticker': self.handle_ticker,
+            'tickerV2': self.handle_bid_ask,
             'availableBalance.change': self.handle_balance,
             'match': self.handle_trade,
             'orderChange': self.handle_order,
@@ -877,6 +936,13 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         if method is not None:
             method(client, message)
 
+    def get_message_hash(self, elementName: str, symbol: Str = None):
+        # elementName can be 'ticker', 'bidask', ...
+        if symbol is not None:
+            return elementName + '@' + symbol
+        else:
+            return elementName + 's@all'
+
     def ping(self, client):
         # kucoin does not support built-in ws protocol-level ping-pong
         # instead it requires a custom json-based text ping-pong
@@ -914,7 +980,6 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         methods = {
             # 'heartbeat': self.handleHeartbeat,
             'welcome': self.handle_system_status,
-            'ack': self.handle_subscription_status,
             'message': self.handle_subject,
             'pong': self.handle_pong,
             'error': self.handle_error_message,

ccxt/test/test_async.py

@@ -1235,7 +1235,7 @@ class testMainClass(baseMainTestClass):
         #  -----------------------------------------------------------------------------
         #  --- Init of brokerId tests functions-----------------------------------------
         #  -----------------------------------------------------------------------------
-        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational()]
+        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced()]
         await asyncio.gather(*promises)
         success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
         dump('[INFO]' + success_message)
@@ -1534,6 +1534,20 @@ class testMainClass(baseMainTestClass):
         await close(exchange)
         return True
 
+    async def test_coinbase_advanced(self):
+        exchange = self.init_offline_exchange('coinbase')
+        id = 'ccxt'
+        assert exchange.options['brokerId'] == id, 'id not in options'
+        request = None
+        try:
+            await exchange.create_order('BTC/USDC', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            request = json_parse(exchange.last_request_body)
+        client_order_id = request['client_order_id']
+        assert client_order_id.startswith(str(id)), 'clientOrderId does not start with id'
+        await close(exchange)
+        return True
+
 # ***** AUTO-TRANSPILER-END *****
 # *******************************
 

ccxt/test/test_sync.py

@@ -1234,7 +1234,7 @@ class testMainClass(baseMainTestClass):
         #  -----------------------------------------------------------------------------
         #  --- Init of brokerId tests functions-----------------------------------------
         #  -----------------------------------------------------------------------------
-        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational()]
+        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced()]
         (promises)
         success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
         dump('[INFO]' + success_message)
@@ -1533,6 +1533,20 @@ class testMainClass(baseMainTestClass):
         close(exchange)
         return True
 
+    def test_coinbase_advanced(self):
+        exchange = self.init_offline_exchange('coinbase')
+        id = 'ccxt'
+        assert exchange.options['brokerId'] == id, 'id not in options'
+        request = None
+        try:
+            exchange.create_order('BTC/USDC', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            request = json_parse(exchange.last_request_body)
+        client_order_id = request['client_order_id']
+        assert client_order_id.startswith(str(id)), 'clientOrderId does not start with id'
+        close(exchange)
+        return True
+
 # ***** AUTO-TRANSPILER-END *****
 # *******************************
 

{ccxt-4.2.90.dist-info → ccxt-4.2.91.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.2.90
+Version: 4.2.91
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -261,13 +261,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.2.90/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@4.2.90/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.2.91/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@4.2.91/dist/ccxt.browser.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.2.90/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.2.91/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object: