ccxt 4.3.66__py2.py3-none-any.whl → 4.3.68__py2.py3-none-any.whl

ccxt/bitget.py

@@ -4867,8 +4867,9 @@ class bitget(Exchange, ImplicitAPI):
         if isinstance(response, str):
             response = json.loads(response)
         data = self.safe_dict(response, 'data')
-        if (data is not None) and not isinstance(data, list):
-            return self.parse_order(data, market)
+        if (data is not None):
+            if not isinstance(data, list):
+                return self.parse_order(data, market)
         dataList = self.safe_list(response, 'data', [])
         first = self.safe_dict(dataList, 0, {})
         return self.parse_order(first, market)

ccxt/bithumb.py

@@ -212,17 +212,56 @@ class bithumb(Exchange, ImplicitAPI):
         :returns dict[]: an array of objects representing market data
         """
         result = []
-        quoteCurrencies = self.safe_value(self.options, 'quoteCurrencies', {})
+        quoteCurrencies = self.safe_dict(self.options, 'quoteCurrencies', {})
         quotes = list(quoteCurrencies.keys())
+        promises = []
+        for i in range(0, len(quotes)):
+            request = {
+                'quoteId': quotes[i],
+            }
+            promises.append(self.publicGetTickerALLQuoteId(self.extend(request, params)))
+            #
+            #    {
+            #        "status": "0000",
+            #        "data": {
+            #            "ETH": {
+            #                "opening_price": "0.05153399",
+            #                "closing_price": "0.05145144",
+            #                "min_price": "0.05145144",
+            #                "max_price": "0.05160781",
+            #                "units_traded": "6.541124172077830855",
+            #                "acc_trade_value": "0.33705472498492329997697755",
+            #                "prev_closing_price": "0.0515943",
+            #                "units_traded_24H": "43.368879902677400513",
+            #                "acc_trade_value_24H": "2.24165339555398079994373342",
+            #                "fluctate_24H": "-0.00018203",
+            #                "fluctate_rate_24H": "-0.35"
+            #            },
+            #            "XRP": {
+            #                "opening_price": "0.00000918",
+            #                "closing_price": "0.0000092",
+            #                "min_price": "0.00000918",
+            #                "max_price": "0.0000092",
+            #                "units_traded": "6516.949363",
+            #                "acc_trade_value": "0.0598792533602796",
+            #                "prev_closing_price": "0.00000916",
+            #                "units_traded_24H": "229161.50354738",
+            #                "acc_trade_value_24H": "2.0446589371637117",
+            #                "fluctate_24H": "0.00000049",
+            #                "fluctate_rate_24H": "5.63"
+            #            },
+            #            ...
+            #            "date": "1721675913145"
+            #        }
+            #    }
+            #
+        results = promises
         for i in range(0, len(quotes)):
             quote = quotes[i]
             quoteId = quote
-            extension = self.safe_value(quoteCurrencies, quote, {})
-            request: dict = {
-                'quoteId': quoteId,
-            }
-            response = self.publicGetTickerALLQuoteId(self.extend(request, params))
-            data = self.safe_value(response, 'data')
+            response = results[i]
+            data = self.safe_dict(response, 'data')
+            extension = self.safe_dict(quoteCurrencies, quote, {})
             currencyIds = list(data.keys())
             for j in range(0, len(currencyIds)):
                 currencyId = currencyIds[j]
@@ -286,7 +325,7 @@ class bithumb(Exchange, ImplicitAPI):
 
     def parse_balance(self, response) -> Balances:
         result: dict = {'info': response}
-        balances = self.safe_value(response, 'data')
+        balances = self.safe_dict(response, 'data')
         codes = list(self.currencies.keys())
         for i in range(0, len(codes)):
             code = codes[i]
@@ -351,7 +390,7 @@ class bithumb(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         timestamp = self.safe_integer(data, 'timestamp')
         return self.parse_order_book(data, symbol, timestamp, 'bids', 'asks', 'price', 'quantity')
 
@@ -413,15 +452,18 @@ class bithumb(Exchange, ImplicitAPI):
         """
         self.load_markets()
         result: dict = {}
-        quoteCurrencies = self.safe_value(self.options, 'quoteCurrencies', {})
+        quoteCurrencies = self.safe_dict(self.options, 'quoteCurrencies', {})
         quotes = list(quoteCurrencies.keys())
+        promises = []
         for i in range(0, len(quotes)):
-            quote = quotes[i]
-            quoteId = quote
             request: dict = {
-                'quoteId': quoteId,
+                'quoteId': quotes[i],
             }
-            response = self.publicGetTickerALLQuoteId(self.extend(request, params))
+            promises.append(self.publicGetTickerALLQuoteId(self.extend(request, params)))
+        responses = promises
+        for i in range(0, len(quotes)):
+            quote = quotes[i]
+            response = responses[i]
             #
             #     {
             #         "status":"0000",
@@ -443,7 +485,7 @@ class bithumb(Exchange, ImplicitAPI):
             #         }
             #     }
             #
-            data = self.safe_value(response, 'data', {})
+            data = self.safe_dict(response, 'data', {})
             timestamp = self.safe_integer(data, 'date')
             tickers = self.omit(data, 'date')
             currencyIds = list(tickers.keys())
@@ -805,7 +847,7 @@ class bithumb(Exchange, ImplicitAPI):
         #     }
         #
         timestamp = self.safe_integer_product(order, 'order_date', 0.001)
-        sideProperty = self.safe_value_2(order, 'type', 'side')
+        sideProperty = self.safe_string_2(order, 'type', 'side')
         side = 'buy' if (sideProperty == 'bid') else 'sell'
         status = self.parse_order_status(self.safe_string(order, 'order_status'))
         price = self.safe_string_2(order, 'order_price', 'price')
@@ -830,7 +872,7 @@ class bithumb(Exchange, ImplicitAPI):
             market = self.safe_market(None, market)
             symbol = market['symbol']
         id = self.safe_string(order, 'order_id')
-        rawTrades = self.safe_value(order, 'contract', [])
+        rawTrades = self.safe_list(order, 'contract', [])
         return self.safe_order({
             'info': order,
             'id': id,

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.66'
+__version__ = '4.3.68'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitget.py

@@ -1678,7 +1678,7 @@ class bitget(ccxt.async_support.bitget):
         if topic.find('books') >= 0:
             self.handle_order_book(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return 'ping'
 
     def handle_pong(self, client: Client, message):

ccxt/pro/bybit.py

@@ -1962,7 +1962,7 @@ class bybit(ccxt.async_support.bybit):
         if type == 'AUTH_RESP':
             self.handle_authenticate(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'req_id': self.request_id(),
             'op': 'ping',

ccxt/pro/coinone.py

@@ -380,7 +380,7 @@ class coinone(ccxt.async_support.coinone):
                     method(client, message)
                     return
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'request_type': 'PING',
         }

ccxt/pro/currencycom.py

@@ -56,7 +56,7 @@ class currencycom(ccxt.async_support.currencycom):
             },
         })
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # custom ping-pong
         requestId = str(self.request_id())
         return {

ccxt/pro/hollaex.py

@@ -546,7 +546,7 @@ class hollaex(ccxt.async_support.hollaex):
         if method is not None:
             method(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # hollaex does not support built-in ws protocol-level ping-pong
         return {'op': 'ping'}
 

ccxt/pro/hyperliquid.py

@@ -610,7 +610,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
                 method(client, message)
                 return
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'method': 'ping',
         }

ccxt/pro/krakenfutures.py

@@ -82,16 +82,16 @@ class krakenfutures(ccxt.async_support.krakenfutures):
         url = self.urls['api']['ws']
         messageHash = 'challenge'
         client = self.client(url)
-        future = self.safe_value(client.subscriptions, messageHash)
-        if future is None:
+        future = client.future(messageHash)
+        authenticated = self.safe_value(client.subscriptions, messageHash)
+        if authenticated is None:
             request: dict = {
                 'event': 'challenge',
                 'api_key': self.apiKey,
             }
             message = self.extend(request, params)
-            future = await self.watch(url, messageHash, message, messageHash)
-            client.subscriptions[messageHash] = future
-        return future
+            self.watch(url, messageHash, message, messageHash)
+        return await future
 
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
@@ -1483,7 +1483,8 @@ class krakenfutures(ccxt.async_support.krakenfutures):
             signature = self.hmac(hashedChallenge, base64Secret, hashlib.sha512, 'base64')
             self.options['challenge'] = challenge
             self.options['signedChallenge'] = signature
-            client.resolve(message, messageHash)
+            future = self.safe_value(client.futures, messageHash)
+            future.resolve(True)
         else:
             error = AuthenticationError(self.id + ' ' + self.json(message))
             client.reject(error, messageHash)

ccxt/pro/kucoin.py

@@ -1155,7 +1155,7 @@ class kucoin(ccxt.async_support.kucoin):
         if method is not None:
             method(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # kucoin does not support built-in ws protocol-level ping-pong
         # instead it requires a custom json-based text ping-pong
         # https://docs.kucoin.com/#ping

ccxt/pro/kucoinfutures.py

@@ -1035,7 +1035,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         else:
             return elementName + 's@all'
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # kucoin does not support built-in ws protocol-level ping-pong
         # instead it requires a custom json-based text ping-pong
         # https://docs.kucoin.com/#ping

ccxt/pro/mexc.py

@@ -1118,5 +1118,5 @@ class mexc(ccxt.async_support.mexc):
             method = methods[channel]
             method(client, message)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {'method': 'ping'}

ccxt/pro/okcoin.py

@@ -573,7 +573,7 @@ class okcoin(ccxt.async_support.okcoin):
         client.resolve(message, 'authenticated')
         return message
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # okex does not support built-in ws protocol-level ping-pong
         # instead it requires custom text-based ping-pong
         return 'ping'

ccxt/pro/okx.py

@@ -13,6 +13,7 @@ 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 InvalidNonce
 from ccxt.base.errors import ChecksumError
 
 
@@ -836,7 +837,7 @@ class okx(ccxt.async_support.okx):
         for i in range(0, len(deltas)):
             self.handle_delta(bookside, deltas[i])
 
-    def handle_order_book_message(self, client: Client, message, orderbook, messageHash):
+    def handle_order_book_message(self, client: Client, message, orderbook, messageHash, market=None):
         #
         #     {
         #         "asks": [
@@ -851,6 +852,9 @@ class okx(ccxt.async_support.okx):
         #         ],
         #         "instId": "BTC-USDT",
         #         "ts": "1626537446491"
+        #         "checksum": -855196043,
+        #         "prevSeqId": 123456,
+        #         "seqId": 123457
         #     }
         #
         asks = self.safe_value(message, 'asks', [])
@@ -860,9 +864,12 @@ class okx(ccxt.async_support.okx):
         self.handle_deltas(storedAsks, asks)
         self.handle_deltas(storedBids, bids)
         marketId = self.safe_string(message, 'instId')
-        symbol = self.safe_symbol(marketId)
+        symbol = self.safe_symbol(marketId, market)
         checksum = self.handle_option('watchOrderBook', 'checksum', True)
+        seqId = self.safe_integer(message, 'seqId')
         if checksum:
+            prevSeqId = self.safe_integer(message, 'prevSeqId')
+            nonce = orderbook['nonce']
             asksLength = len(storedAsks)
             bidsLength = len(storedBids)
             payloadArray = []
@@ -876,12 +883,17 @@ class okx(ccxt.async_support.okx):
             payload = ':'.join(payloadArray)
             responseChecksum = self.safe_integer(message, 'checksum')
             localChecksum = self.crc32(payload, True)
+            error = None
+            if prevSeqId != -1 and nonce != prevSeqId:
+                error = InvalidNonce(self.id + ' watchOrderBook received invalid nonce')
             if responseChecksum != localChecksum:
                 error = ChecksumError(self.id + ' ' + self.orderbook_checksum_message(symbol))
+            if error is not None:
                 del client.subscriptions[messageHash]
                 del self.orderbooks[symbol]
                 client.reject(error, messageHash)
         timestamp = self.safe_integer(message, 'ts')
+        orderbook['nonce'] = seqId
         orderbook['timestamp'] = timestamp
         orderbook['datetime'] = self.iso8601(timestamp)
         return orderbook
@@ -1001,7 +1013,7 @@ class okx(ccxt.async_support.okx):
                 orderbook = self.orderbooks[symbol]
                 for i in range(0, len(data)):
                     update = data[i]
-                    self.handle_order_book_message(client, update, orderbook, messageHash)
+                    self.handle_order_book_message(client, update, orderbook, messageHash, market)
                     client.resolve(orderbook, messageHash)
         elif (channel == 'books5') or (channel == 'bbo-tbt'):
             if not (symbol in self.orderbooks):
@@ -1728,7 +1740,7 @@ class okx(ccxt.async_support.okx):
         future = self.safe_value(client.futures, 'authenticated')
         future.resolve(True)
 
-    def ping(self, client):
+    def ping(self, client: Client):
         # OKX does not support the built-in WebSocket protocol-level ping-pong.
         # Instead, it requires a custom text-based ping-pong mechanism.
         return 'ping'

ccxt/pro/oxfun.py

@@ -914,7 +914,7 @@ class oxfun(ccxt.async_support.oxfun):
             if messageHash in client.subscriptions:
                 del client.subscriptions[messageHash]
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return 'ping'
 
     def handle_pong(self, client: Client, message):

ccxt/pro/p2b.py

@@ -388,7 +388,7 @@ class p2b(ccxt.async_support.p2b):
             raise ExchangeError(self.id + ' error: ' + self.json(error))
         return False
 
-    def ping(self, client):
+    def ping(self, client: Client):
         """
         :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#ping
          * @param client

ccxt/pro/poloniex.py

@@ -1160,7 +1160,7 @@ class poloniex(ccxt.async_support.poloniex):
                 del client.subscriptions[messageHash]
         return message
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'event': 'ping',
         }

ccxt/pro/whitebit.py

@@ -856,7 +856,7 @@ class whitebit(ccxt.async_support.whitebit):
         client.lastPong = self.milliseconds()
         return message
 
-    def ping(self, client):
+    def ping(self, client: Client):
         return {
             'id': 0,
             'method': 'ping',