ccxt 4.3.47__py2.py3-none-any.whl → 4.3.48__py2.py3-none-any.whl

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.47'
+__version__ = '4.3.48'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bingx.py

@@ -693,14 +693,14 @@ class bingx(ccxt.async_support.bingx):
         #        ]
         #    }
         #
-        data = self.safe_list(message, 'data', [])
+        isSwap = client.url.find('swap') >= 0
         candles = None
-        if isinstance(data, list):
-            candles = data
+        if isSwap:
+            candles = self.safe_list(message, 'data', [])
         else:
-            candles = [self.safe_list(data, 'K', [])]
+            data = self.safe_dict(message, 'data', {})
+            candles = [self.safe_dict(data, 'K', {})]
         dataType = self.safe_string(message, 'dataType')
-        isSwap = client.url.find('swap') >= 0
         parts = dataType.split('@')
         firstPart = parts[0]
         isAllEndpoint = (firstPart == 'all')

ccxt/pro/gate.py

@@ -6,12 +6,14 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Liquidation, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Int, Liquidation, Market, MarketType, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, 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
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
+from ccxt.base.errors import NotSupported
 from ccxt.base.errors import InvalidNonce
 from ccxt.base.precise import Precise
 
@@ -22,6 +24,27 @@ class gate(ccxt.async_support.gate):
         return self.deep_extend(super(gate, self).describe(), {
             'has': {
                 'ws': True,
+                'cancelAllOrdersWs': True,
+                'cancelOrderWs': True,
+                'createMarketBuyOrderWithCostWs': True,
+                'createMarketOrderWs': True,
+                'createMarketOrderWithCostWs': False,
+                'createMarketSellOrderWithCostWs': False,
+                'createOrderWs': True,
+                'createOrdersWs': True,
+                'createPostOnlyOrderWs': True,
+                'createReduceOnlyOrderWs': True,
+                'createStopLimitOrderWs': True,
+                'createStopLossOrderWs': True,
+                'createStopMarketOrderWs': False,
+                'createStopOrderWs': True,
+                'createTakeProfitOrderWs': True,
+                'createTriggerOrderWs': True,
+                'editOrderWs': True,
+                'fetchOrderWs': True,
+                'fetchOrdersWs': False,
+                'fetchOpenOrdersWs': True,
+                'fetchClosedOrdersWs': True,
                 'watchOrderBook': True,
                 'watchTicker': True,
                 'watchTickers': True,
@@ -95,15 +118,228 @@ class gate(ccxt.async_support.gate):
             'exceptions': {
                 'ws': {
                     'exact': {
+                        '1': BadRequest,
                         '2': BadRequest,
                         '4': AuthenticationError,
                         '6': AuthenticationError,
                         '11': AuthenticationError,
                     },
+                    'broad': {},
                 },
             },
         })
 
+    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
+        """
+        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#order-place
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#order-place
+        Create an order on the exchange
+        :param str symbol: Unified CCXT market symbol
+        :param str type: 'limit' or 'market' *"market" is contract only*
+        :param str side: 'buy' or 'sell'
+        :param float amount: the amount of currency to trade
+        :param float [price]: *ignored in "market" orders* the price at which the order is to be fullfilled at in units of the quote currency
+        :param dict [params]:  extra parameters specific to the exchange API endpoint
+        :param float [params.stopPrice]: The price at which a trigger order is triggered at
+        :param str [params.timeInForce]: "GTC", "IOC", or "PO"
+        :param float [params.stopLossPrice]: The price at which a stop loss order is triggered at
+        :param float [params.takeProfitPrice]: The price at which a take profit order is triggered at
+        :param str [params.marginMode]: 'cross' or 'isolated' - marginMode for margin trading if not provided self.options['defaultMarginMode'] is used
+        :param int [params.iceberg]: Amount to display for the iceberg order, Null or 0 for normal orders, Set to -1 to hide the order completely
+        :param str [params.text]: User defined information
+        :param str [params.account]: *spot and margin only* "spot", "margin" or "cross_margin"
+        :param bool [params.auto_borrow]: *margin only* Used in margin or cross margin trading to allow automatic loan of insufficient amount if balance is not enough
+        :param str [params.settle]: *contract only* Unified Currency Code for settle currency
+        :param bool [params.reduceOnly]: *contract only* Indicates if self order is to reduce the size of a position
+        :param bool [params.close]: *contract only* Set to close the position, with size set to 0
+        :param bool [params.auto_size]: *contract only* Set side to close dual-mode position, close_long closes the long side, while close_short the short one, size also needs to be set to 0
+        :param int [params.price_type]: *contract only* 0 latest deal price, 1 mark price, 2 index price
+        :param float [params.cost]: *spot market buy only* the quote quantity that can be used alternative for the amount
+        :returns dict|None: `An order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_place'
+        url = self.get_url_by_market(market)
+        params['textIsRequired'] = True
+        request = self.create_order_request(symbol, type, side, amount, price, params)
+        await self.authenticate(url, messageType)
+        rawOrder = await self.request_private(url, request, channel)
+        order = self.parse_order(rawOrder, market)
+        return order
+
+    async def create_orders_ws(self, orders: List[OrderRequest], params={}):
+        """
+        create a list of trade orders
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#order-batch-place
+        :param Array orders: list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        request = self.createOrdersRequest(orders, params)
+        firstOrder = orders[0]
+        market = self.market(firstOrder['symbol'])
+        if market['swap'] is not True:
+            raise NotSupported(self.id + ' createOrdersWs is not supported for swap markets')
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_batch_place'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        rawOrders = await self.request_private(url, request, channel)
+        return self.parse_orders(rawOrders, market)
+
+    async def cancel_all_orders_ws(self, symbol: Str = None, params={}):
+        """
+        cancel all open orders
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#cancel-all-open-orders-matched
+        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#order-cancel-all-with-specified-currency-pair
+        :param str symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to use, defaults to spot.order_cancel_cp or futures.order_cancel_cp
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = None if (symbol is None) else self.market(symbol)
+        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_cancel_cp'
+        channel, params = self.handle_option_and_params(params, 'cancelAllOrdersWs', 'channel', channel)
+        url = self.get_url_by_market(market)
+        params = self.omit(params, ['stop', 'trigger'])
+        type, query = self.handle_market_type_and_params('cancelAllOrders', market, params)
+        request, requestParams = self.multiOrderSpotPrepareRequest(market, stop, query) if (type == 'spot') else self.prepareRequest(market, type, query)
+        await self.authenticate(url, messageType)
+        rawOrders = await self.request_private(url, self.extend(request, requestParams), channel)
+        return self.parse_orders(rawOrders, market)
+
+    async def cancel_order_ws(self, id: str, symbol: Str = None, params={}):
+        """
+        Cancels an open order
+        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#order-cancel
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#order-cancel
+        :param str id: Order id
+        :param str symbol: Unified market symbol
+        :param dict [params]: Parameters specified by the exchange api
+        :param bool [params.stop]: True if the order to be cancelled is a trigger order
+        :returns: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = None if (symbol is None) else self.market(symbol)
+        stop = self.safe_value_2(params, 'is_stop_order', 'stop', False)
+        params = self.omit(params, ['is_stop_order', 'stop'])
+        type, query = self.handle_market_type_and_params('cancelOrder', market, params)
+        request, requestParams = self.spotOrderPrepareRequest(market, stop, query) if (type == 'spot' or type == 'margin') else self.prepareRequest(market, type, query)
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_cancel'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        request['order_id'] = str(id)
+        res = await self.request_private(url, self.extend(request, requestParams), channel)
+        return self.parse_order(res, market)
+
+    async def edit_order_ws(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
+        """
+        edit a trade order, gate currently only supports the modification of the price or amount fields
+        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#order-amend
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#order-amend
+        :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 [price]: the price at which the order is to be fullfilled, in units of the base currency, ignored in market orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        extendedRequest = self.edit_order_request(id, symbol, type, side, amount, price, params)
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_amend'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        rawOrder = await self.request_private(url, extendedRequest, channel)
+        return self.parse_order(rawOrder, market)
+
+    async def fetch_order_ws(self, id: str, symbol: Str = None, params={}):
+        """
+        Retrieves information on an order
+        :see: https://www.gate.io/docs/developers/apiv4/ws/en/#order-status
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#order-status
+        :param str id: Order id
+        :param str symbol: Unified market symbol, *required for spot and margin*
+        :param dict [params]: Parameters specified by the exchange api
+        :param bool [params.stop]: True if the order being fetched is a trigger order
+        :param str [params.marginMode]: 'cross' or 'isolated' - marginMode for margin trading if not provided self.options['defaultMarginMode'] is used
+        :param str [params.type]: 'spot', 'swap', or 'future', if not provided self.options['defaultMarginMode'] is used
+        :param str [params.settle]: 'btc' or 'usdt' - settle currency for perpetual swap and future - market settle currency is used if symbol is not None, default="usdt" for swap and "btc" for future
+        :returns: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = None if (symbol is None) else self.market(symbol)
+        request, requestParams = self.fetchOrderRequest(id, symbol, params)
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_status'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        rawOrder = await self.request_private(url, self.extend(request, requestParams), channel)
+        return self.parse_order(rawOrder, market)
+
+    async def fetch_open_orders_ws(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+        """
+        fetch all unfilled currently open orders
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#order-list
+        :param str symbol: unified market symbol
+        :param int [since]: the earliest time in ms to fetch open orders for
+        :param int [limit]: the maximum number of  open orders structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        return await self.fetch_orders_by_status_ws('open', symbol, since, limit, params)
+
+    async def fetch_closed_orders_ws(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+        """
+        fetches information on multiple closed orders made by the user
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#order-list
+        :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
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        return await self.fetch_orders_by_status_ws('finished', symbol, since, limit, params)
+
+    async def fetch_orders_by_status_ws(self, status: str, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
+        """
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#order-list
+        fetches information on multiple orders made by the user by status
+        :param str symbol: unified market symbol of the market orders were made in
+        :param int|None [since]: the earliest time in ms to fetch orders for
+        :param int|None [limit]: the maximum number of order structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.orderId]: order id to begin at
+        :param int [params.limit]: the maximum number of order structures to retrieve
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
+            symbol = market['symbol']
+            if market['swap'] is not True:
+                raise NotSupported(self.id + ' fetchOrdersByStatusWs is only supported by swap markets. Use rest API for other markets')
+        request, requestParams = self.fetchOrdersByStatusRequest(status, symbol, since, limit, params)
+        newRequest = self.omit(request, ['settle'])
+        messageType = self.get_type_by_market(market)
+        channel = messageType + '.order_list'
+        url = self.get_url_by_market(market)
+        await self.authenticate(url, messageType)
+        rawOrders = await self.request_private(url, self.extend(newRequest, requestParams), channel)
+        orders = self.parse_orders(rawOrders, market)
+        return self.filter_by_symbol_since_limit(orders, symbol, since, limit)
+
     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
@@ -1135,37 +1371,55 @@ class gate(ccxt.async_support.gate):
         })
 
     def handle_error_message(self, client: Client, message):
-        # {
-        #     "time": 1647274664,
-        #     "channel": "futures.orders",
-        #     "event": "subscribe",
-        #     "error": {code: 2, message: "unknown contract BTC_USDT_20220318"},
-        # }
-        # {
-        #     "time": 1647276473,
-        #     "channel": "futures.orders",
-        #     "event": "subscribe",
-        #     "error": {
-        #       "code": 4,
-        #       "message": "{"label":"INVALID_KEY","message":"Invalid key provided"}\n"
-        #     },
-        #     "result": null
-        #   }
-        error = self.safe_value(message, 'error')
-        code = self.safe_integer(error, 'code')
-        id = self.safe_string(message, 'id')
-        if id is None:
-            return False
-        if code is not None:
+        #
+        #    {
+        #        "time": 1647274664,
+        #        "channel": "futures.orders",
+        #        "event": "subscribe",
+        #        "error": {code: 2, message: "unknown contract BTC_USDT_20220318"},
+        #    }
+        #    {
+        #      "time": 1647276473,
+        #      "channel": "futures.orders",
+        #      "event": "subscribe",
+        #      "error": {
+        #        "code": 4,
+        #        "message": "{"label":"INVALID_KEY","message":"Invalid key provided"}\n"
+        #      },
+        #      "result": null
+        #    }
+        #    {
+        #       header: {
+        #         response_time: '1718551891329',
+        #         status: '400',
+        #         channel: 'spot.order_place',
+        #         event: 'api',
+        #         client_id: '81.34.68.6-0xc16375e2c0',
+        #         conn_id: '9539116e0e09678f'
+        #       },
+        #       data: {errs: {label: 'AUTHENTICATION_FAILED', message: 'Not login'}},
+        #       request_id: '10406147'
+        #     }
+        #
+        data = self.safe_dict(message, 'data')
+        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')
+        if error is not None:
             messageHash = self.safe_string(client.subscriptions, id)
-            if messageHash is not None:
-                try:
-                    self.throw_exactly_matched_exception(self.exceptions['ws']['exact'], code, self.json(message))
-                except Exception as e:
-                    client.reject(e, messageHash)
-                    if messageHash in client.subscriptions:
-                        del client.subscriptions[messageHash]
-            del client.subscriptions[id]
+            try:
+                self.throw_exactly_matched_exception(self.exceptions['ws']['exact'], code, self.json(message))
+                self.throw_exactly_matched_exception(self.exceptions['exact'], code, self.json(errs))
+                errorMessage = self.safe_string(error, 'message', self.safe_string(errs, 'message'))
+                self.throw_broadly_matched_exception(self.exceptions['ws']['broad'], errorMessage, self.json(message))
+                raise ExchangeError(self.json(message))
+            except Exception as e:
+                client.reject(e, messageHash)
+                if (messageHash is not None) and (messageHash in client.subscriptions):
+                    del client.subscriptions[messageHash]
+            if id is not None:
+                del client.subscriptions[id]
             return True
         return False
 
@@ -1302,6 +1556,17 @@ class gate(ccxt.async_support.gate):
         method = self.safe_value(v4Methods, channelType)
         if method is not None:
             method(client, message)
+        requestId = self.safe_string(message, 'request_id')
+        if requestId == 'authenticated':
+            self.handle_authentication_message(client, message)
+            return
+        if requestId is not None:
+            data = self.safe_dict(message, 'data')
+            # use safeValue may be Array or an Object
+            result = self.safe_value(data, 'result')
+            ack = self.safe_bool(message, 'ack')
+            if ack is not True:
+                client.resolve(result, requestId)
 
     def get_url_by_market(self, market):
         baseUrl = self.urls['api'][market['type']]
@@ -1310,7 +1575,7 @@ class gate(ccxt.async_support.gate):
         else:
             return baseUrl
 
-    def get_type_by_market(self, market):
+    def get_type_by_market(self, market: Market):
         if market['spot']:
             return 'spot'
         elif market['option']:
@@ -1318,7 +1583,7 @@ class gate(ccxt.async_support.gate):
         else:
             return 'futures'
 
-    def get_url_by_market_type(self, type, isInverse=False):
+    def get_url_by_market_type(self, type: MarketType, isInverse=False):
         api = self.urls['api']
         url = api[type]
         if (type == 'swap') or (type == 'future'):
@@ -1377,6 +1642,49 @@ class gate(ccxt.async_support.gate):
         message = self.extend(request, params)
         return await self.watch_multiple(url, messageHashes, message, messageHashes)
 
+    async def authenticate(self, url, messageType):
+        channel = messageType + '.login'
+        client = self.client(url)
+        messageHash = 'authenticated'
+        future = client.future(messageHash)
+        authenticated = self.safe_value(client.subscriptions, messageHash)
+        if authenticated is None:
+            return await self.request_private(url, {}, channel, messageHash)
+        return future
+
+    def handle_authentication_message(self, client: Client, message):
+        messageHash = 'authenticated'
+        future = self.safe_value(client.futures, messageHash)
+        future.resolve(True)
+
+    async def request_private(self, url, reqParams, channel, requestId: Str = None):
+        self.check_required_credentials()
+        # uid is required for some subscriptions only so it's not a part of required credentials
+        event = 'api'
+        if requestId is None:
+            reqId = self.request_id()
+            requestId = str(reqId)
+        messageHash = requestId
+        time = self.seconds()
+        # unfortunately, PHP demands double quotes for the escaped newline symbol
+        signatureString = "\n".join([event, channel, self.json(reqParams), str(time)])  # eslint-disable-line quotes
+        signature = self.hmac(self.encode(signatureString), self.encode(self.secret), hashlib.sha512, 'hex')
+        payload: dict = {
+            'req_id': requestId,
+            'timestamp': str(time),
+            'api_key': self.apiKey,
+            'signature': signature,
+            'req_param': reqParams,
+        }
+        request: dict = {
+            'id': requestId,
+            'time': time,
+            'channel': channel,
+            'event': event,
+            'payload': payload,
+        }
+        return await self.watch(url, messageHash, request, messageHash)
+
     async def subscribe_private(self, url, messageHash, payload, channel, params, requiresUid=False):
         self.check_required_credentials()
         # uid is required for some subscriptions only so it's not a part of required credentials
@@ -1402,7 +1710,7 @@ class gate(ccxt.async_support.gate):
             'id': requestId,
             'time': time,
             'channel': channel,
-            'event': 'subscribe',
+            'event': event,
             'auth': auth,
         }
         if payload is not None:

ccxt/test/base/test_order_book.py

@@ -66,4 +66,4 @@ def test_order_book(exchange, skipped_properties, method, orderbook, symbol):
             first_bid = exchange.safe_string(bids[0], 0)
             first_ask = exchange.safe_string(asks[0], 0)
             # check bid-ask spread
-            assert Precise.string_lt(first_bid, first_ask), 'bids[0][0] (' + first_ask + ') should be < than asks[0][0] (' + first_ask + ')' + log_text
+            assert Precise.string_lt(first_bid, first_ask), 'bids[0][0] (' + first_bid + ') should be < than asks[0][0] (' + first_ask + ')' + log_text

ccxt/woo.py

@@ -2361,6 +2361,10 @@ class woo(Exchange, ImplicitAPI):
             url += access + '/' + pathWithParams
             if params:
                 url += '?' + self.urlencode(params)
+        elif access == 'pub':
+            url += pathWithParams
+            if params:
+                url += '?' + self.urlencode(params)
         else:
             self.check_required_credentials()
             if method == 'POST' and (path == 'algo/order' or path == 'order'):

{ccxt-4.3.47.dist-info → ccxt-4.3.48.dist-info}/METADATA

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