ccxt 4.3.2__py2.py3-none-any.whl → 4.3.4__py2.py3-none-any.whl

ccxt/hyperliquid.py

@@ -314,6 +314,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         #         ]
         #     ]
         #
+        #
         meta = self.safe_dict(response, 0, {})
         meta = self.safe_list(meta, 'universe', [])
         assetCtxs = self.safe_dict(response, 1, {})
@@ -372,10 +373,70 @@ class hyperliquid(Exchange, ImplicitAPI):
         #         },
         #     ],
         # ]
+        # mainnet
+        # [
+        #     {
+        #        "canonical_tokens2":[
+        #           0,
+        #           1
+        #        ],
+        #        "spot_infos":[
+        #           {
+        #              "name":"PURR/USDC",
+        #              "tokens":[
+        #                 1,
+        #                 0
+        #              ]
+        #           }
+        #        ],
+        #        "token_id_to_token":[
+        #           [
+        #              "0x6d1e7cde53ba9467b783cb7c530ce054",
+        #              0
+        #           ],
+        #           [
+        #              "0xc1fb593aeffbeb02f85e0308e9956a90",
+        #              1
+        #           ]
+        #        ],
+        #        "token_infos":[
+        #           {
+        #              "deployer":null,
+        #              "spec":{
+        #                 "name":"USDC",
+        #                 "szDecimals":"8",
+        #                 "weiDecimals":"8"
+        #              },
+        #              "spots":[
+        #              ]
+        #           },
+        #           {
+        #              "deployer":null,
+        #              "spec":{
+        #                 "name":"PURR",
+        #                 "szDecimals":"0",
+        #                 "weiDecimals":"5"
+        #              },
+        #              "spots":[
+        #                 0
+        #              ]
+        #           }
+        #        ]
+        #     },
+        #     [
+        #        {
+        #           "dayNtlVlm":"35001170.16631",
+        #           "markPx":"0.15743",
+        #           "midPx":"0.157555",
+        #           "prevDayPx":"0.158"
+        #        }
+        #     ]
+        # ]
         #
+        # response differs depending on the environment(mainnet vs sandbox)
         first = self.safe_dict(response, 0, {})
-        meta = self.safe_list(first, 'universe', [])
-        tokens = self.safe_list(first, 'tokens', [])
+        meta = self.safe_list_2(first, 'universe', 'spot_infos', [])
+        tokens = self.safe_list_2(first, 'tokens', 'token_infos', [])
         markets = []
         for i in range(0, len(meta)):
             market = self.safe_dict(meta, i, {})
@@ -391,14 +452,16 @@ class hyperliquid(Exchange, ImplicitAPI):
             maker = self.safe_number(fees, 'maker')
             tokensPos = self.safe_list(market, 'tokens', [])
             baseTokenPos = self.safe_integer(tokensPos, 0)
-            quoteTokenPos = self.safe_integer(tokensPos, 1)
+            # quoteTokenPos = self.safe_integer(tokensPos, 1)
             baseTokenInfo = self.safe_dict(tokens, baseTokenPos, {})
-            quoteTokenInfo = self.safe_dict(tokens, quoteTokenPos, {})
-            baseDecimals = self.safe_string(baseTokenInfo, 'szDecimals')
-            quoteDecimals = self.safe_integer(quoteTokenInfo, 'szDecimals')
+            # quoteTokenInfo = self.safe_dict(tokens, quoteTokenPos, {})
+            innerBaseTokenInfo = self.safe_dict(baseTokenInfo, 'spec', baseTokenInfo)
+            # innerQuoteTokenInfo = self.safe_dict(quoteTokenInfo, 'spec', quoteTokenInfo)
+            amountPrecision = self.parse_number(self.parse_precision(self.safe_string(innerBaseTokenInfo, 'szDecimals')))
+            # quotePrecision = self.parse_number(self.parse_precision(self.safe_string(innerQuoteTokenInfo, 'szDecimals')))
             baseId = self.number_to_string(i + 10000)
             markets.append(self.safe_market_structure({
-                'id': baseId,
+                'id': marketName,
                 'symbol': symbol,
                 'base': base,
                 'quote': quote,
@@ -408,14 +471,15 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'settleId': None,
                 'type': 'spot',
                 'spot': True,
+                'subType': None,
                 'margin': None,
                 'swap': False,
                 'future': False,
                 'option': False,
                 'active': True,
                 'contract': False,
-                'linear': True,
-                'inverse': False,
+                'linear': None,
+                'inverse': None,
                 'taker': taker,
                 'maker': maker,
                 'contractSize': None,
@@ -424,8 +488,8 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'strike': None,
                 'optionType': None,
                 'precision': {
-                    'amount': self.parse_number(self.parse_precision(baseDecimals)),  # decimal places
-                    'price': quoteDecimals,  # significant digits
+                    'amount': amountPrecision,  # decimal places
+                    'price': 5,  # significant digits
                 },
                 'limits': {
                     'leverage': {
@@ -632,7 +696,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         market = self.market(symbol)
         request = {
             'type': 'l2Book',
-            'coin': market['base'],
+            'coin': market['base'] if market['swap'] else market['id'],
         }
         response = self.publicPostInfo(self.extend(request, params))
         #
@@ -688,7 +752,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         request = {
             'type': 'candleSnapshot',
             'req': {
-                'coin': market['base'],
+                'coin': market['base'] if market['swap'] else market['id'],
                 'interval': timeframe,
                 'startTime': since,
                 'endTime': until,
@@ -791,6 +855,9 @@ class hyperliquid(Exchange, ImplicitAPI):
         return self.parse_trades(response, market, since, limit)
 
     def amount_to_precision(self, symbol, amount):
+        market = self.market(symbol)
+        if market['spot']:
+            return super(hyperliquid, self).amount_to_precision(symbol, amount)
         return self.decimal_to_precision(amount, ROUND, self.markets[symbol]['precision']['amount'], self.precisionMode)
 
     def price_to_precision(self, symbol: str, price) -> str:
@@ -2221,6 +2288,11 @@ class hyperliquid(Exchange, ImplicitAPI):
             return [self.walletAddress, params]
         raise ArgumentsRequired(self.id + ' ' + methodName + '() requires a user parameter inside \'params\' or the wallet address set')
 
+    def coin_to_market_id(self, coin: Str):
+        if coin.find('/') > -1:
+            return coin  # spot
+        return coin + '/USDC:USDC'
+
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
         if not response:
             return None  # fallback to default error handler

ccxt/okx.py

@@ -86,6 +86,8 @@ class okx(Exchange, ImplicitAPI):
                 'fetchClosedOrders': True,
                 'fetchConvertCurrencies': True,
                 'fetchConvertQuote': True,
+                'fetchConvertTrade': True,
+                'fetchConvertTradeHistory': True,
                 'fetchCrossBorrowRate': True,
                 'fetchCrossBorrowRates': True,
                 'fetchCurrencies': True,
@@ -7202,6 +7204,96 @@ class okx(Exchange, ImplicitAPI):
         toCurrency = self.currency(toCurrencyId)
         return self.parse_conversion(result, fromCurrency, toCurrency)
 
+    def fetch_convert_trade(self, id: str, code: Str = None, params={}) -> Conversion:
+        """
+        fetch the data for a conversion trade
+        :see: https://www.okx.com/docs-v5/en/#funding-account-rest-api-get-convert-history
+        :param str id: the id of the trade that you want to fetch
+        :param str [code]: the unified currency code of the conversion trade
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `conversion structure <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        self.load_markets()
+        request = {
+            'clTReqId': id,
+        }
+        response = self.privateGetAssetConvertHistory(self.extend(request, params))
+        #
+        #     {
+        #         "code": "0",
+        #         "data": [
+        #             {
+        #                 "clTReqId": "",
+        #                 "instId": "ETH-USDT",
+        #                 "side": "buy",
+        #                 "fillPx": "2932.401044",
+        #                 "baseCcy": "ETH",
+        #                 "quoteCcy": "USDT",
+        #                 "fillBaseSz": "0.01023052",
+        #                 "state": "fullyFilled",
+        #                 "tradeId": "trader16461885203381437",
+        #                 "fillQuoteSz": "30",
+        #                 "ts": "1646188520000"
+        #             }
+        #         ],
+        #         "msg": ""
+        #     }
+        #
+        data = self.safe_list(response, 'data', [])
+        result = self.safe_dict(data, 0, {})
+        fromCurrencyId = self.safe_string(result, 'baseCcy')
+        toCurrencyId = self.safe_string(result, 'quoteCcy')
+        fromCurrency = None
+        toCurrency = None
+        if fromCurrencyId is not None:
+            fromCurrency = self.currency(fromCurrencyId)
+        if toCurrencyId is not None:
+            toCurrency = self.currency(toCurrencyId)
+        return self.parse_conversion(result, fromCurrency, toCurrency)
+
+    def fetch_convert_trade_history(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Conversion]:
+        """
+        fetch the users history of conversion trades
+        :see: https://www.okx.com/docs-v5/en/#funding-account-rest-api-get-convert-history
+        :param str [code]: the unified currency code
+        :param int [since]: the earliest time in ms to fetch conversions for
+        :param int [limit]: the maximum number of conversion structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: timestamp in ms of the latest conversion to fetch
+        :returns dict[]: a list of `conversion structures <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        self.load_markets()
+        request = {}
+        request, params = self.handle_until_option('after', request, params)
+        if since is not None:
+            request['before'] = since
+        if limit is not None:
+            request['limit'] = limit
+        response = self.privateGetAssetConvertHistory(self.extend(request, params))
+        #
+        #     {
+        #         "code": "0",
+        #         "data": [
+        #             {
+        #                 "clTReqId": "",
+        #                 "instId": "ETH-USDT",
+        #                 "side": "buy",
+        #                 "fillPx": "2932.401044",
+        #                 "baseCcy": "ETH",
+        #                 "quoteCcy": "USDT",
+        #                 "fillBaseSz": "0.01023052",
+        #                 "state": "fullyFilled",
+        #                 "tradeId": "trader16461885203381437",
+        #                 "fillQuoteSz": "30",
+        #                 "ts": "1646188520000"
+        #             }
+        #         ],
+        #         "msg": ""
+        #     }
+        #
+        rows = self.safe_list(response, 'data', [])
+        return self.parse_conversions(rows, 'baseCcy', 'quoteCcy', since, limit)
+
     def parse_conversion(self, conversion, fromCurrency: Currency = None, toCurrency: Currency = None) -> Conversion:
         #
         # fetchConvertQuote
@@ -7239,6 +7331,22 @@ class okx(Exchange, ImplicitAPI):
         #         "ts": "1646188520338"
         #     }
         #
+        # fetchConvertTrade, fetchConvertTradeHistory
+        #
+        #     {
+        #         "clTReqId": "",
+        #         "instId": "ETH-USDT",
+        #         "side": "buy",
+        #         "fillPx": "2932.401044",
+        #         "baseCcy": "ETH",
+        #         "quoteCcy": "USDT",
+        #         "fillBaseSz": "0.01023052",
+        #         "state": "fullyFilled",
+        #         "tradeId": "trader16461885203381437",
+        #         "fillQuoteSz": "30",
+        #         "ts": "1646188520000"
+        #     }
+        #
         timestamp = self.safe_integer_2(conversion, 'quoteTime', 'ts')
         fromCoin = self.safe_string(conversion, 'baseCcy')
         fromCode = self.safe_currency_code(fromCoin, fromCurrency)

ccxt/phemex.py

@@ -2699,11 +2699,15 @@ class phemex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' cancelAllOrders() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
+        stop = self.safe_value_2(params, 'stop', 'trigger', False)
+        params = self.omit(params, 'stop', 'trigger')
         request = {
             'symbol': market['id'],
             # 'untriggerred': False,  # False to cancel non-conditional orders, True to cancel conditional orders
             # 'text': 'up to 40 characters max',
         }
+        if stop:
+            request['untriggerred'] = stop
         response = None
         if market['settle'] == 'USDT':
             response = self.privateDeleteGOrdersAll(self.extend(request, params))

ccxt/poloniexfutures.py

@@ -383,8 +383,15 @@ class poloniexfutures(Exchange, ImplicitAPI):
         marketId = self.safe_string(ticker, 'symbol')
         symbol = self.safe_symbol(marketId, market)
         timestampString = self.safe_string(ticker, 'ts')
-        # check timestamp bcz bug: https://app.travis-ci.com/github/ccxt/ccxt/builds/269959181#L4011
-        multiplier = 0.00001 if (len(timestampString) == 18) else 0.000001
+        # check timestamp bcz bug: https://app.travis-ci.com/github/ccxt/ccxt/builds/269959181#L4011 and also 17 digits occured
+        multiplier = None
+        if len(timestampString) == 17:
+            multiplier = 0.0001
+        elif len(timestampString) == 18:
+            multiplier = 0.00001
+        else:
+            # 19 length default
+            multiplier = 0.000001
         timestamp = self.safe_integer_product(ticker, 'ts', multiplier)
         last = self.safe_string_2(ticker, 'price', 'lastPrice')
         percentage = Precise.string_mul(self.safe_string(ticker, 'priceChgPct'), '100')

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.2'
+__version__ = '4.3.4'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/hyperliquid.py

@@ -70,7 +70,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             'method': 'subscribe',
             'subscription': {
                 'type': 'l2Book',
-                'coin': market['base'],
+                'coin': market['base'] if market['swap'] else market['id'],
             },
         }
         message = self.extend(request, params)
@@ -105,7 +105,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         #
         entry = self.safe_dict(message, 'data', {})
         coin = self.safe_string(entry, 'coin')
-        marketId = coin + '/USDC:USDC'
+        marketId = self.coinToMarketId(coin)
         market = self.market(marketId)
         symbol = market['symbol']
         rawData = self.safe_list(entry, 'levels', [])
@@ -225,7 +225,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             'method': 'subscribe',
             'subscription': {
                 'type': 'trades',
-                'coin': market['base'],
+                'coin': market['base'] if market['swap'] else market['id'],
             },
         }
         message = self.extend(request, params)
@@ -254,7 +254,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         entry = self.safe_list(message, 'data', [])
         first = self.safe_dict(entry, 0, {})
         coin = self.safe_string(first, 'coin')
-        marketId = coin + '/USDC:USDC'
+        marketId = self.coinToMarketId(coin)
         market = self.market(marketId)
         symbol = market['symbol']
         if not (symbol in self.trades):
@@ -307,7 +307,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         price = self.safe_string(trade, 'px')
         amount = self.safe_string(trade, 'sz')
         coin = self.safe_string(trade, 'coin')
-        marketId = coin + '/USDC:USDC'
+        marketId = self.coinToMarketId(coin)
         market = self.safe_market(marketId, None)
         symbol = market['symbol']
         id = self.safe_string(trade, 'tid')
@@ -349,7 +349,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
             'method': 'subscribe',
             'subscription': {
                 'type': 'candle',
-                'coin': market['base'],
+                'coin': market['base'] if market['swap'] else market['id'],
                 'interval': timeframe,
             },
         }
@@ -380,7 +380,8 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         #
         data = self.safe_dict(message, 'data', {})
         base = self.safe_string(data, 's')
-        symbol = base + '/USDC:USDC'
+        marketId = self.coinToMarketId(base)
+        symbol = self.safe_symbol(marketId)
         timeframe = self.safe_string(data, 'i')
         if not (symbol in self.ohlcvs):
             self.ohlcvs[symbol] = {}

ccxt/pro/kraken.py

@@ -1242,7 +1242,7 @@ class kraken(ccxt.async_support.kraken):
             },
         }
         url = self.urls['api']['ws']['public']
-        return await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes, subscriptionArgs)
+        return await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), messageHashes, subscriptionArgs)
 
     def get_message_hash(self, unifiedElementName: str, subChannelName: Str = None, symbol: Str = None):
         # unifiedElementName can be : orderbook, trade, ticker, bidask ...

ccxt/pro/wazirx.py

@@ -722,7 +722,8 @@ class wazirx(ccxt.async_support.wazirx):
         }
         streams = list(streamHandlers.keys())
         for i in range(0, len(streams)):
-            if self.in_array(streams[i], stream):
+            streamContains = stream.find(streams[i]) > -1
+            if streamContains:
                 handler = streamHandlers[streams[i]]
                 handler(client, message)
                 return

ccxt/woo.py

@@ -69,6 +69,8 @@ class woo(Exchange, ImplicitAPI):
                 'fetchClosedOrders': True,
                 'fetchConvertCurrencies': True,
                 'fetchConvertQuote': True,
+                'fetchConvertTrade': True,
+                'fetchConvertTradeHistory': True,
                 'fetchCurrencies': True,
                 'fetchDepositAddress': True,
                 'fetchDeposits': True,
@@ -2853,6 +2855,88 @@ class woo(Exchange, ImplicitAPI):
         data = self.safe_dict(response, 'data', {})
         return self.parse_conversion(data)
 
+    def fetch_convert_trade(self, id: str, code: Str = None, params={}) -> Conversion:
+        """
+        fetch the data for a conversion trade
+        :see: https://docs.woo.org/#get-quote-trade
+        :param str id: the id of the trade that you want to fetch
+        :param str [code]: the unified currency code of the conversion trade
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `conversion structure <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        self.load_markets()
+        request = {
+            'quoteId': id,
+        }
+        response = self.v3PrivateGetConvertTrade(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "quoteId": 12,
+        #             "buyAsset": "",
+        #             "sellAsset": "",
+        #             "buyAmount": 12.11,
+        #             "sellAmount": 12.11,
+        #             "tradeStatus": 12,
+        #             "createdTime": ""
+        #         }
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        fromCurrencyId = self.safe_string(data, 'sellAsset')
+        toCurrencyId = self.safe_string(data, 'buyAsset')
+        fromCurrency = None
+        toCurrency = None
+        if fromCurrencyId is not None:
+            fromCurrency = self.currency(fromCurrencyId)
+        if toCurrencyId is not None:
+            toCurrency = self.currency(toCurrencyId)
+        return self.parse_conversion(data, fromCurrency, toCurrency)
+
+    def fetch_convert_trade_history(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Conversion]:
+        """
+        fetch the users history of conversion trades
+        :see: https://docs.woo.org/#get-quote-trades
+        :param str [code]: the unified currency code
+        :param int [since]: the earliest time in ms to fetch conversions for
+        :param int [limit]: the maximum number of conversion structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: timestamp in ms of the latest conversion to fetch
+        :returns dict[]: a list of `conversion structures <https://docs.ccxt.com/#/?id=conversion-structure>`
+        """
+        self.load_markets()
+        request = {}
+        request, params = self.handle_until_option('endTime', request, params)
+        if since is not None:
+            request['startTime'] = since
+        if limit is not None:
+            request['size'] = limit
+        response = self.v3PrivateGetConvertTrades(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "count": 12,
+        #             "tradeVos":[
+        #                 {
+        #                     "quoteId": 12,
+        #                     "buyAsset": "",
+        #                     "sellAsset": "",
+        #                     "buyAmount": 12.11,
+        #                     "sellAmount": 12.11,
+        #                     "tradeStatus": 12,
+        #                     "createdTime": ""
+        #                 }
+        #                 ...
+        #             ]
+        #         }
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'tradeVos', [])
+        return self.parse_conversions(rows, 'sellAsset', 'buyAsset', since, limit)
+
     def parse_conversion(self, conversion, fromCurrency: Currency = None, toCurrency: Currency = None) -> Conversion:
         #
         # fetchConvertQuote
@@ -2877,10 +2961,22 @@ class woo(Exchange, ImplicitAPI):
         #         "rftAccepted": 1  # 1 -> success; 2 -> processing; 3 -> fail
         #     }
         #
-        timestamp = self.safe_integer(conversion, 'expireTimestamp')
-        fromCoin = self.safe_string(conversion, 'sellToken')
-        fromCode = self.safe_currency_code(fromCoin, fromCurrency)
-        to = self.safe_string(conversion, 'buyToken')
+        # fetchConvertTrade, fetchConvertTradeHistory
+        #
+        #     {
+        #         "quoteId": 12,
+        #         "buyAsset": "",
+        #         "sellAsset": "",
+        #         "buyAmount": 12.11,
+        #         "sellAmount": 12.11,
+        #         "tradeStatus": 12,
+        #         "createdTime": ""
+        #     }
+        #
+        timestamp = self.safe_integer_2(conversion, 'expireTimestamp', 'createdTime')
+        fromCurr = self.safe_string_2(conversion, 'sellToken', 'buyAsset')
+        fromCode = self.safe_currency_code(fromCurr, fromCurrency)
+        to = self.safe_string_2(conversion, 'buyToken', 'sellAsset')
         toCode = self.safe_currency_code(to, toCurrency)
         return {
             'info': conversion,
@@ -2888,9 +2984,9 @@ class woo(Exchange, ImplicitAPI):
             'datetime': self.iso8601(timestamp),
             'id': self.safe_string(conversion, 'quoteId'),
             'fromCurrency': fromCode,
-            'fromAmount': self.safe_number(conversion, 'sellQuantity'),
+            'fromAmount': self.safe_number_2(conversion, 'sellQuantity', 'sellAmount'),
             'toCurrency': toCode,
-            'toAmount': self.safe_number(conversion, 'buyQuantity'),
+            'toAmount': self.safe_number_2(conversion, 'buyQuantity', 'buyAmount'),
             'price': self.safe_number(conversion, 'buyPrice'),
             'fee': None,
         }

{ccxt-4.3.2.dist-info → ccxt-4.3.4.dist-info}/METADATA

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