ccxt 4.3.83__py2.py3-none-any.whl → 4.3.85__py2.py3-none-any.whl

ccxt/cryptocom.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.cryptocom import ImplicitAPI
 import hashlib
-from ccxt.base.types import Account, Balances, Currency, Int, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Account, Balances, Currency, Int, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -109,8 +109,8 @@ class cryptocom(Exchange, ImplicitAPI):
                 'fetchTickers': True,
                 'fetchTime': False,
                 'fetchTrades': True,
-                'fetchTradingFee': False,
-                'fetchTradingFees': False,
+                'fetchTradingFee': True,
+                'fetchTradingFees': True,
                 'fetchTransactionFees': False,
                 'fetchTransactions': False,
                 'fetchTransfers': False,
@@ -211,6 +211,8 @@ class cryptocom(Exchange, ImplicitAPI):
                             'private/get-accounts': 10 / 3,
                             'private/get-withdrawal-history': 10 / 3,
                             'private/get-deposit-history': 10 / 3,
+                            'private/get-fee-rate': 2,
+                            'private/get-instrument-fee-rate': 2,
                             'private/staking/stake': 2,
                             'private/staking/unstake': 2,
                             'private/staking/get-staking-position': 2,
@@ -2806,6 +2808,114 @@ class cryptocom(Exchange, ImplicitAPI):
         result = self.safe_dict(response, 'result')
         return self.parse_order(result, market)
 
+    def fetch_trading_fee(self, symbol: str, params={}) -> TradingFeeInterface:
+        """
+        fetch the trading fees for a market
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#private-get-instrument-fee-rate
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `fee structure <https://docs.ccxt.com/#/?id=fee-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'instrument_name': market['id'],
+        }
+        response = self.v1PrivatePostPrivateGetInstrumentFeeRate(self.extend(request, params))
+        #
+        #    {
+        #        "id": 1,
+        #        "code": 0,
+        #        "method": "private/staking/unstake",
+        #        "result": {
+        #          "staking_id": "1",
+        #          "instrument_name": "SOL.staked",
+        #          "status": "NEW",
+        #          "quantity": "1",
+        #          "underlying_inst_name": "SOL",
+        #          "reason": "NO_ERROR"
+        #        }
+        #    }
+        #
+        data = self.safe_dict(response, 'result', {})
+        return self.parse_trading_fee(data, market)
+
+    def fetch_trading_fees(self, params={}) -> TradingFees:
+        """
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#private-get-fee-rate
+        fetch the trading fees for multiple markets
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a dictionary of `fee structures <https://docs.ccxt.com/#/?id=fee-structure>` indexed by market symbols
+        """
+        self.load_markets()
+        response = self.v1PrivatePostPrivateGetFeeRate(params)
+        #
+        #   {
+        #       "id": 1,
+        #       "method": "/private/get-fee-rate",
+        #       "code": 0,
+        #       "result": {
+        #         "spot_tier": "3",
+        #         "deriv_tier": "3",
+        #         "effective_spot_maker_rate_bps": "6.5",
+        #         "effective_spot_taker_rate_bps": "6.9",
+        #         "effective_deriv_maker_rate_bps": "1.1",
+        #         "effective_deriv_taker_rate_bps": "3"
+        #       }
+        #   }
+        #
+        result = self.safe_dict(response, 'result', {})
+        return self.parse_trading_fees(result)
+
+    def parse_trading_fees(self, response):
+        #
+        # {
+        #         "spot_tier": "3",
+        #         "deriv_tier": "3",
+        #         "effective_spot_maker_rate_bps": "6.5",
+        #         "effective_spot_taker_rate_bps": "6.9",
+        #         "effective_deriv_maker_rate_bps": "1.1",
+        #         "effective_deriv_taker_rate_bps": "3"
+        #  }
+        #
+        result: dict = {}
+        result['info'] = response
+        for i in range(0, len(self.symbols)):
+            symbol = self.symbols[i]
+            market = self.market(symbol)
+            isSwap = market['swap']
+            takerFeeKey = 'effective_deriv_taker_rate_bps' if isSwap else 'effective_spot_taker_rate_bps'
+            makerFeeKey = 'effective_deriv_maker_rate_bps' if isSwap else 'effective_spot_maker_rate_bps'
+            tradingFee = {
+                'info': response,
+                'symbol': symbol,
+                'maker': self.parse_number(Precise.string_div(self.safe_string(response, makerFeeKey), '10000')),
+                'taker': self.parse_number(Precise.string_div(self.safe_string(response, takerFeeKey), '10000')),
+                'percentage': None,
+                'tierBased': None,
+            }
+            result[symbol] = tradingFee
+        return result
+
+    def parse_trading_fee(self, fee: dict, market: Market = None) -> TradingFeeInterface:
+        #
+        # {
+        #      "instrument_name": "BTC_USD",
+        #      "effective_maker_rate_bps": "6.5",
+        #      "effective_taker_rate_bps": "6.9"
+        # }
+        #
+        marketId = self.safe_string(fee, 'instrument_name')
+        symbol = self.safe_symbol(marketId, market)
+        return {
+            'info': fee,
+            'symbol': symbol,
+            'maker': self.parse_number(Precise.string_div(self.safe_string(fee, 'effective_maker_rate_bps'), '10000')),
+            'taker': self.parse_number(Precise.string_div(self.safe_string(fee, 'effective_taker_rate_bps'), '10000')),
+            'percentage': None,
+            'tierBased': None,
+        }
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         type = self.safe_string(api, 0)
         access = self.safe_string(api, 1)

ccxt/kraken.py

@@ -1181,6 +1181,26 @@ class kraken(Exchange, ImplicitAPI):
         #         "misc": ''
         #     }
         #
+        # fetchMyTrades
+        #
+        #     {
+        #         "ordertxid": "OSJVN7-A2AE-63WZV",
+        #         "postxid": "TBP7O6-PNXI-CONU",
+        #         "pair": "XXBTZUSD",
+        #         "time": 1710429248.3052235,
+        #         "type": "sell",
+        #         "ordertype": "liquidation market",
+        #         "price": "72026.50000",
+        #         "cost": "7.20265",
+        #         "fee": "0.01873",
+        #         "vol": "0.00010000",
+        #         "margin": "1.44053",
+        #         "leverage": "5",
+        #         "misc": "closing",
+        #         "trade_id": 68230622,
+        #         "maker": False
+        #     }
+        #
         timestamp = None
         side = None
         type = None
@@ -1227,6 +1247,10 @@ class kraken(Exchange, ImplicitAPI):
         if market is not None:
             symbol = market['symbol']
         cost = self.safe_string(trade, 'cost')
+        maker = self.safe_bool(trade, 'maker')
+        takerOrMaker = None
+        if maker is not None:
+            takerOrMaker = 'maker' if maker else 'taker'
         return self.safe_trade({
             'id': id,
             'order': orderId,
@@ -1236,7 +1260,7 @@ class kraken(Exchange, ImplicitAPI):
             'symbol': symbol,
             'type': type,
             'side': side,
-            'takerOrMaker': None,
+            'takerOrMaker': takerOrMaker,
             'price': price,
             'amount': amount,
             'cost': cost,
@@ -2001,7 +2025,10 @@ class kraken(Exchange, ImplicitAPI):
         #                     "fee": "0.000026",
         #                     "vol": "16.00000000",
         #                     "margin": "0.000000",
+        #                     "leverage": "5",
         #                     "misc": ""
+        #                     "trade_id": 68230622,
+        #                     "maker": False
         #                 },
         #                 ...
         #             },
@@ -2367,13 +2394,11 @@ class kraken(Exchange, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         # https://www.kraken.com/en-us/help/api#deposit-status
-        if code is None:
-            raise ArgumentsRequired(self.id + ' fetchDeposits() requires a currency code argument')
         self.load_markets()
-        currency = self.currency(code)
-        request: dict = {
-            'asset': currency['id'],
-        }
+        request: dict = {}
+        if code is not None:
+            currency = self.currency(code)
+            request['asset'] = currency['id']
         if since is not None:
             request['start'] = since
         response = self.privatePostDepositStatus(self.extend(request, params))

ccxt/kucoinfutures.py

@@ -137,6 +137,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
                         'contracts/{symbol}': 1,
                         'contracts/risk-limit/{symbol}': 1,
                         'ticker': 1,
+                        'allTickers': 1,
                         'level2/snapshot': 1.33,
                         'level2/depth{limit}': 1,
                         'level2/message/query': 1,
@@ -180,6 +181,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
                         'trade-statistics': 1,
                         'trade-fees': 1,
                         'history-positions': 1,
+                        'getMaxOpenSize': 1,
                     },
                     'post': {
                         'withdrawals': 1,
@@ -325,6 +327,9 @@ class kucoinfutures(kucoin, ImplicitAPI):
                 # endpoint versions
                 'versions': {
                     'futuresPrivate': {
+                        'GET': {
+                            'getMaxOpenSize': 'v2',
+                        },
                         'POST': {
                             'transfer-out': 'v2',
                         },

ccxt/mexc.py

@@ -1158,7 +1158,7 @@ class mexc(Exchange, ImplicitAPI):
         #         "symbols": [
         #           {
         #                "symbol": "OGNUSDT",
-        #                "status": "ENABLED",
+        #                "status": "1",
         #                "baseAsset": "OGN",
         #                "baseAssetPrecision": "2",
         #                "quoteAsset": "USDT",
@@ -1203,7 +1203,7 @@ class mexc(Exchange, ImplicitAPI):
             status = self.safe_string(market, 'status')
             isSpotTradingAllowed = self.safe_value(market, 'isSpotTradingAllowed')
             active = False
-            if (status == 'ENABLED') and (isSpotTradingAllowed):
+            if (status == '1') and (isSpotTradingAllowed):
                 active = True
             isMarginTradingAllowed = self.safe_value(market, 'isMarginTradingAllowed')
             makerCommission = self.safe_number(market, 'makerCommission')

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.83'
+__version__ = '4.3.85'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -228,7 +228,7 @@ class binance(ccxt.async_support.binance):
         else:
             for i in range(0, len(symbols)):
                 market = self.market(symbols[i])
-                subscriptionHashes.append(market['id'] + '@forceOrder')
+                subscriptionHashes.append(market['lowercaseId'] + '@forceOrder')
                 messageHashes.append('liquidations::' + symbols[i])
             streamHash += '::' + ','.join(symbols)
         firstMarket = self.get_market_from_symbols(symbols)
@@ -1133,6 +1133,9 @@ class binance(ccxt.async_support.binance):
         :param dict [params.timezone]: if provided, kline intervals are interpreted in that timezone instead of UTC, example '+08:00'
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
         params['callerMethodName'] = 'watchOHLCV'
         result = await self.watch_ohlcv_for_symbols([[symbol, timeframe]], since, limit, params)
         return result[symbol][timeframe]
@@ -1179,7 +1182,7 @@ class binance(ccxt.async_support.binance):
             suffix = '@+08:00'
             utcSuffix = suffix if shouldUseUTC8 else ''
             rawHashes.append(marketId + '@' + klineType + '_' + interval + utcSuffix)
-            messageHashes.append('ohlcv::' + symbolString + '::' + timeframeString)
+            messageHashes.append('ohlcv::' + market['symbol'] + '::' + timeframeString)
         url = self.urls['api']['ws'][type] + '/' + self.stream(type, 'multipleOHLCV')
         requestId = self.request_id(url)
         request = {
@@ -1434,6 +1437,8 @@ class binance(ccxt.async_support.binance):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True, False, True)
         result = await self.watch_multi_ticker_helper('watchBidsAsks', 'bookTicker', symbols, params)
         if self.newUpdates:
             return result

ccxt/pro/bitget.py

@@ -9,6 +9,7 @@ import hashlib
 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 typing import Any
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
@@ -429,6 +430,32 @@ class bitget(ccxt.async_support.bitget):
         """
         return await self.watch_order_book_for_symbols([symbol], limit, params)
 
+    async def un_watch_order_book(self, symbol: str, params={}) -> Any:
+        """
+        unsubscribe from the orderbook channel
+        :see: https://www.bitget.com/api-doc/spot/websocket/public/Depth-Channel
+        :see: https://www.bitget.com/api-doc/contract/websocket/public/Order-Book-Channel
+        :param str symbol: unified symbol of the market to fetch the order book for
+        :param int [params.limit]: orderbook limit, default is None
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        messageHash = 'unsubscribe:orderbook:' + market['symbol']
+        channel = 'books'
+        limit = self.safe_integer(params, 'limit')
+        if (limit == 1) or (limit == 5) or (limit == 15):
+            params = self.omit(params, 'limit')
+            channel += str(limit)
+        instType = None
+        instType, params = self.get_inst_type(market, params)
+        args: dict = {
+            'instType': instType,
+            'channel': channel,
+            'instId': market['id'],
+        }
+        return await self.un_watch_public(messageHash, args, params)
+
     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
@@ -542,10 +569,11 @@ class bitget(ccxt.async_support.bitget):
                 calculatedChecksum = self.crc32(payload, True)
                 responseChecksum = self.safe_integer(rawOrderBook, 'checksum')
                 if calculatedChecksum != responseChecksum:
-                    del client.subscriptions[messageHash]
-                    del self.orderbooks[symbol]
-                    error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
-                    client.reject(error, messageHash)
+                    # if messageHash in client.subscriptions:
+                    #     # del client.subscriptions[messageHash]
+                    #     # del self.orderbooks[symbol]
+                    # }
+                    self.spawn(self.handle_check_sum_error, client, symbol, messageHash)
                     return
         else:
             orderbook = self.order_book({})
@@ -554,6 +582,11 @@ class bitget(ccxt.async_support.bitget):
             self.orderbooks[symbol] = orderbook
         client.resolve(self.orderbooks[symbol], messageHash)
 
+    async def handle_check_sum_error(self, client: Client, symbol: str, messageHash: str):
+        await self.un_watch_order_book(symbol)
+        error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
+        client.reject(error, messageHash)
+
     def handle_delta(self, bookside, delta):
         bidAsk = self.parse_bid_ask(delta, 0, 1)
         # we store the string representations in the orderbook for checksum calculation
@@ -1524,6 +1557,15 @@ class bitget(ccxt.async_support.bitget):
         message = self.extend(request, params)
         return await self.watch(url, messageHash, message, messageHash)
 
+    async def un_watch_public(self, messageHash, args, params={}):
+        url = self.urls['api']['ws']['public']
+        request: dict = {
+            'op': 'unsubscribe',
+            'args': [args],
+        }
+        message = self.extend(request, params)
+        return await self.watch(url, messageHash, message, messageHash)
+
     async def watch_public_multiple(self, messageHashes, argsArray, params={}):
         url = self.urls['api']['ws']['public']
         request: dict = {
@@ -1637,6 +1679,17 @@ class bitget(ccxt.async_support.bitget):
         #        "event": "subscribe",
         #        "arg": {instType: 'SPOT', channel: "account", instId: "default"}
         #    }
+        # unsubscribe
+        #    {
+        #        "op":"unsubscribe",
+        #        "args":[
+        #          {
+        #            "instType":"USDT-FUTURES",
+        #            "channel":"ticker",
+        #            "instId":"BTCUSDT"
+        #          }
+        #        ]
+        #    }
         #
         if self.handle_error_message(client, message):
             return
@@ -1654,6 +1707,9 @@ class bitget(ccxt.async_support.bitget):
         if event == 'subscribe':
             self.handle_subscription_status(client, message)
             return
+        if event == 'unsubscribe':
+            self.handle_un_subscription_status(client, message)
+            return
         methods: dict = {
             'ticker': self.handle_ticker,
             'trade': self.handle_trades,
@@ -1693,3 +1749,47 @@ class bitget(ccxt.async_support.bitget):
         #    }
         #
         return message
+
+    def handle_un_subscription_status(self, client: Client, message):
+        #
+        #  {
+        #      "op":"unsubscribe",
+        #      "args":[
+        #        {
+        #          "instType":"USDT-FUTURES",
+        #          "channel":"ticker",
+        #          "instId":"BTCUSDT"
+        #        },
+        #        {
+        #          "instType":"USDT-FUTURES",
+        #          "channel":"candle1m",
+        #          "instId":"BTCUSDT"
+        #        }
+        #      ]
+        #  }
+        #  or
+        # {"event":"unsubscribe","arg":{"instType":"SPOT","channel":"books","instId":"BTCUSDT"}}
+        #
+        argsList = self.safe_list(message, 'args')
+        if argsList is None:
+            argsList = [self.safe_dict(message, 'arg', {})]
+        for i in range(0, len(argsList)):
+            arg = argsList[i]
+            channel = self.safe_string(arg, 'channel')
+            if channel == 'books':
+                # for now only unWatchOrderBook is supporteod
+                instType = self.safe_string_lower(arg, 'instType')
+                type = 'spot' if (instType == 'spot') else 'contract'
+                instId = self.safe_string(arg, 'instId')
+                market = self.safe_market(instId, None, None, type)
+                symbol = market['symbol']
+                messageHash = 'unsubscribe:orderbook:' + market['symbol']
+                subMessageHash = 'orderbook:' + symbol
+                if symbol in self.orderbooks:
+                    del self.orderbooks[symbol]
+                if subMessageHash in client.subscriptions:
+                    del client.subscriptions[subMessageHash]
+                if messageHash in client.subscriptions:
+                    del client.subscriptions[messageHash]
+                client.resolve(True, messageHash)
+        return message

ccxt/pro/bitrue.py

@@ -401,13 +401,7 @@ class bitrue(ccxt.async_support.bitrue):
     async def authenticate(self, params={}):
         listenKey = self.safe_value(self.options, 'listenKey')
         if listenKey is None:
-            response = None
-            try:
-                response = await self.openPrivatePostPoseidonApiV1ListenKey(params)
-            except Exception as error:
-                self.options['listenKey'] = None
-                self.options['listenKeyUrl'] = None
-                return None
+            response = await self.openPrivatePostPoseidonApiV1ListenKey(params)
             #
             #     {
             #         "msg": "succ",

ccxt/pro/gate.py

@@ -1408,7 +1408,7 @@ class gate(ccxt.async_support.gate):
         errs = self.safe_dict(data, 'errs')
         error = self.safe_dict(message, 'error', errs)
         code = self.safe_string_2(error, 'code', 'label')
-        id = self.safe_string_2(message, 'id', 'requestId')
+        id = self.safe_string_n(message, ['id', 'requestId', 'request_id'])
         if error is not None:
             messageHash = self.safe_string(client.subscriptions, id)
             try:
@@ -1421,7 +1421,7 @@ class gate(ccxt.async_support.gate):
                 client.reject(e, messageHash)
                 if (messageHash is not None) and (messageHash in client.subscriptions):
                     del client.subscriptions[messageHash]
-            if id is not None:
+            if (id is not None) and (id in client.subscriptions):
                 del client.subscriptions[id]
             return True
         return False
@@ -1686,7 +1686,7 @@ class gate(ccxt.async_support.gate):
             'event': event,
             'payload': payload,
         }
-        return await self.watch(url, messageHash, request, messageHash)
+        return await self.watch(url, messageHash, request, messageHash, requestId)
 
     async def subscribe_private(self, url, messageHash, payload, channel, params, requiresUid=False):
         self.check_required_credentials()
@@ -1724,4 +1724,4 @@ class gate(ccxt.async_support.gate):
             # in case of authenticationError we will throw
             client.subscriptions[tempSubscriptionHash] = messageHash
         message = self.extend(request, params)
-        return await self.watch(url, messageHash, message, messageHash)
+        return await self.watch(url, messageHash, message, messageHash, messageHash)

ccxt/pro/okx.py

@@ -419,8 +419,13 @@ class okx(ccxt.async_support.okx):
         await self.load_markets()
         symbols = self.market_symbols(symbols, None, True, True)
         messageHash = 'liquidations'
+        messageHashes = []
         if symbols is not None:
-            messageHash += '::' + ','.join(symbols)
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHashes.append(messageHash + '::' + symbol)
+        else:
+            messageHashes.append(messageHash)
         market = self.get_market_from_symbols(symbols)
         type = None
         type, params = self.handle_market_type_and_params('watchliquidationsForSymbols', market, params)
@@ -431,9 +436,16 @@ class okx(ccxt.async_support.okx):
             type = 'futures'
         uppercaseType = type.upper()
         request = {
-            'instType': uppercaseType,
+            'op': 'subscribe',
+            'args': [
+                {
+                    'channel': channel,
+                    'instType': uppercaseType,
+                },
+            ],
         }
-        newLiquidations = await self.subscribe('public', messageHash, channel, None, self.extend(request, params))
+        url = self.get_url(channel, 'public')
+        newLiquidations = await self.watch_multiple(url, messageHashes, request, messageHashes)
         if self.newUpdates:
             return newLiquidations
         return self.filter_by_symbols_since_limit(self.liquidations, symbols, since, limit, True)
@@ -1305,6 +1317,12 @@ class okx(ccxt.async_support.okx):
         for i in range(0, len(data)):
             rawPosition = data[i]
             position = self.parse_position(rawPosition)
+            if position['contracts'] == 0:
+                position['side'] = 'long'
+                shortPosition = self.clone(position)
+                shortPosition['side'] = 'short'
+                cache.append(shortPosition)
+                newPositions.append(shortPosition)
             newPositions.append(position)
             cache.append(position)
         messageHashes = self.find_message_hashes(client, channel + '::')

{ccxt-4.3.83.dist-info → ccxt-4.3.85.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.3.83
+Version: 4.3.85
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -269,13 +269,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.3.83/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.3.83/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.3.85/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.3.85/dist/ccxt.browser.min.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.3.83/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.3.85/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object: