ccxt 4.3.58__py2.py3-none-any.whl → 4.3.60__py2.py3-none-any.whl

ccxt/async_support/xt.py

@@ -40,7 +40,7 @@ class xt(Exchange, ImplicitAPI):
             'rateLimit': 100,
             'version': 'v4',
             'certified': False,
-            'pro': False,
+            'pro': True,
             'has': {
                 'CORS': False,
                 'spot': True,
@@ -235,6 +235,7 @@ class xt(Exchange, ImplicitAPI):
                             'withdraw': 1,
                             'balance/transfer': 1,
                             'balance/account/transfer': 1,
+                            'ws-token': 1,
                         },
                         'delete': {
                             'batch-order': 1,
@@ -835,7 +836,7 @@ class xt(Exchange, ImplicitAPI):
                 'name': self.safe_string(entry, 'fullName'),
                 'active': active,
                 'fee': self.parse_number(minWithdrawFeeString),
-                'precision': None,
+                'precision': minPrecision,
                 'deposit': deposit,
                 'withdraw': withdraw,
                 'networks': networks,
@@ -1436,8 +1437,12 @@ class xt(Exchange, ImplicitAPI):
         orderBook = self.safe_value(response, 'result', {})
         timestamp = self.safe_integer_2(orderBook, 'timestamp', 't')
         if market['spot']:
-            return self.parse_order_book(orderBook, symbol, timestamp)
-        return self.parse_order_book(orderBook, symbol, timestamp, 'b', 'a')
+            ob = self.parse_order_book(orderBook, symbol, timestamp)
+            ob['nonce'] = self.safe_integer(orderBook, 'lastUpdateId')
+            return ob
+        swapOb = self.parse_order_book(orderBook, symbol, timestamp, 'b', 'a')
+        swapOb['nonce'] = self.safe_integer_2(orderBook, 'u', 'lastUpdateId')
+        return swapOb
 
     async def fetch_ticker(self, symbol: str, params={}):
         """
@@ -1680,8 +1685,9 @@ class xt(Exchange, ImplicitAPI):
         #
         marketId = self.safe_string(ticker, 's')
         marketType = market['type'] if (market is not None) else None
+        hasSpotKeys = ('cv' in ticker) or ('aq' in ticker)
         if marketType is None:
-            marketType = ('cv' in ticker) or 'spot' if ('aq' in ticker) else 'contract'
+            marketType = 'spot' if hasSpotKeys else 'contract'
         market = self.safe_market(marketId, market, '_', marketType)
         symbol = market['symbol']
         timestamp = self.safe_integer(ticker, 't')
@@ -1889,6 +1895,29 @@ class xt(Exchange, ImplicitAPI):
         #         "b": True
         #     }
         #
+        # spot: watchMyTrades
+        #
+        #    {
+        #        "s": "btc_usdt",                # symbol
+        #        "t": 1656043204763,             # time
+        #        "i": "6316559590087251233",     # tradeId
+        #        "oi": "6216559590087220004",    # orderId
+        #        "p": "30000",                   # trade price
+        #        "q": "3",                       # qty quantity
+        #        "v": "90000"                    # volume trade amount
+        #    }
+        #
+        # spot: watchTrades
+        #
+        #    {
+        #        s: 'btc_usdt',
+        #        i: '228825383103928709',
+        #        t: 1684258222702,
+        #        p: '27003.65',
+        #        q: '0.000796',
+        #        b: True
+        #    }
+        #
         # swap and future: fetchTrades
         #
         #     {
@@ -1933,19 +1962,53 @@ class xt(Exchange, ImplicitAPI):
         #         "takerMaker": "TAKER"
         #     }
         #
+        # contract watchMyTrades
+        #
+        #    {
+        #        "symbol": 'btc_usdt',
+        #        "orderSide": 'SELL',
+        #        "positionSide": 'LONG',
+        #        "orderId": '231485367663419328',
+        #        "price": '27152.7',
+        #        "quantity": '33',
+        #        "marginUnfrozen": '2.85318000',
+        #        "timestamp": 1684892412565
+        #    }
+        #
+        # watchMyTrades(ws, swap)
+        #
+        #    {
+        #        'fee': '0.04080840',
+        #        'isMaker': False,
+        #        'marginUnfrozen': '0.75711984',
+        #        'orderId': '376172779053188416',
+        #        'orderSide': 'BUY',
+        #        'positionSide': 'LONG',
+        #        'price': '3400.70',
+        #        'quantity': '2',
+        #        'symbol': 'eth_usdt',
+        #        'timestamp': 1719388579622
+        #    }
+        #
         marketId = self.safe_string_2(trade, 's', 'symbol')
         marketType = market['type'] if (market is not None) else None
+        hasSpotKeys = ('b' in trade) or ('bizType' in trade) or ('oi' in trade)
         if marketType is None:
-            marketType = ('b' in trade) or 'spot' if ('bizType' in trade) else 'contract'
+            marketType = 'spot' if hasSpotKeys else 'contract'
         market = self.safe_market(marketId, market, '_', marketType)
         bidOrAsk = self.safe_string(trade, 'm')
         side = self.safe_string_lower(trade, 'orderSide')
         if bidOrAsk is not None:
             side = 'buy' if (bidOrAsk == 'BID') else 'sell'
         buyerMaker = self.safe_value(trade, 'b')
+        if buyerMaker is not None:
+            side = 'buy'
         takerOrMaker = self.safe_string_lower(trade, 'takerMaker')
         if buyerMaker is not None:
             takerOrMaker = 'maker' if buyerMaker else 'taker'
+        isMaker = self.safe_bool(trade, 'isMaker')
+        if isMaker is not None:
+            takerOrMaker = 'maker' if isMaker else 'taker'
         timestamp = self.safe_integer_n(trade, ['t', 'time', 'timestamp'])
         quantity = self.safe_string_2(trade, 'q', 'quantity')
         amount = None
@@ -1962,7 +2025,7 @@ class xt(Exchange, ImplicitAPI):
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'symbol': market['symbol'],
-            'order': self.safe_string(trade, 'orderId'),
+            'order': self.safe_string_2(trade, 'orderId', 'oi'),
             'type': self.safe_string_lower(trade, 'orderType'),
             'side': side,
             'takerOrMaker': takerOrMaker,
@@ -4419,7 +4482,7 @@ class xt(Exchange, ImplicitAPI):
                     body['clientMedia'] = id
                 else:
                     body['media'] = id
-            isUndefinedBody = ((method == 'GET') or (path == 'order/{orderId}'))
+            isUndefinedBody = ((method == 'GET') or (path == 'order/{orderId}') or (path == 'ws-token'))
             body = None if isUndefinedBody else self.json(body)
             payloadString = None
             if (endpoint == 'spot') or (endpoint == 'user'):

ccxt/base/errors.py

@@ -17,9 +17,6 @@ error_hierarchy = {
                 },
                 'MarketClosed': {},
             },
-            'BadResponse': {
-                'NullResponse': {},
-            },
             'InsufficientFunds': {},
             'InvalidAddress': {
                 'AddressPending': {},
@@ -27,14 +24,13 @@ error_hierarchy = {
             'InvalidOrder': {
                 'OrderNotFound': {},
                 'OrderNotCached': {},
-                'CancelPending': {},
                 'OrderImmediatelyFillable': {},
                 'OrderNotFillable': {},
                 'DuplicateOrderId': {},
                 'ContractUnavailable': {},
             },
             'NotSupported': {},
-            'ProxyError': {},
+            'InvalidProxySettings': {},
             'ExchangeClosedByUser': {},
         },
         'OperationFailed': {
@@ -47,6 +43,10 @@ error_hierarchy = {
                 'InvalidNonce': {},
                 'RequestTimeout': {},
             },
+            'BadResponse': {
+                'NullResponse': {},
+            },
+            'CancelPending': {},
         },
     },
 }
@@ -104,14 +104,6 @@ class MarketClosed(OperationRejected):
     pass
 
 
-class BadResponse(ExchangeError):
-    pass
-
-
-class NullResponse(BadResponse):
-    pass
-
-
 class InsufficientFunds(ExchangeError):
     pass
 
@@ -136,10 +128,6 @@ class OrderNotCached(InvalidOrder):
     pass
 
 
-class CancelPending(InvalidOrder):
-    pass
-
-
 class OrderImmediatelyFillable(InvalidOrder):
     pass
 
@@ -160,7 +148,7 @@ class NotSupported(ExchangeError):
     pass
 
 
-class ProxyError(ExchangeError):
+class InvalidProxySettings(ExchangeError):
     pass
 
 
@@ -200,6 +188,18 @@ class RequestTimeout(NetworkError):
     pass
 
 
+class BadResponse(OperationFailed):
+    pass
+
+
+class NullResponse(BadResponse):
+    pass
+
+
+class CancelPending(OperationFailed):
+    pass
+
+
 __all__ = [
     'error_hierarchy',
     'BaseError',
@@ -215,21 +215,18 @@ __all__ = [
     'NoChange',
     'MarginModeAlreadySet',
     'MarketClosed',
-    'BadResponse',
-    'NullResponse',
     'InsufficientFunds',
     'InvalidAddress',
     'AddressPending',
     'InvalidOrder',
     'OrderNotFound',
     'OrderNotCached',
-    'CancelPending',
     'OrderImmediatelyFillable',
     'OrderNotFillable',
     'DuplicateOrderId',
     'ContractUnavailable',
     'NotSupported',
-    'ProxyError',
+    'InvalidProxySettings',
     'ExchangeClosedByUser',
     'OperationFailed',
     'NetworkError',
@@ -238,5 +235,8 @@ __all__ = [
     'ExchangeNotAvailable',
     'OnMaintenance',
     'InvalidNonce',
-    'RequestTimeout'
+    'RequestTimeout',
+    'BadResponse',
+    'NullResponse',
+    'CancelPending'
 ]

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.58'
+__version__ = '4.3.60'
 
 # -----------------------------------------------------------------------------
 
@@ -23,7 +23,7 @@ from ccxt.base.errors import NullResponse
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadResponse
-from ccxt.base.errors import ProxyError
+from ccxt.base.errors import InvalidProxySettings
 
 # -----------------------------------------------------------------------------
 
@@ -1943,7 +1943,7 @@ class Exchange(object):
         length = len(usedProxies)
         if length > 1:
             joinedProxyNames = ','.join(usedProxies)
-            raise ProxyError(self.id + ' you have multiple conflicting proxy settings(' + joinedProxyNames + '), please use only one from : proxyUrl, proxy_url, proxyUrlCallback, proxy_url_callback')
+            raise InvalidProxySettings(self.id + ' you have multiple conflicting proxy settings(' + joinedProxyNames + '), please use only one from : proxyUrl, proxy_url, proxyUrlCallback, proxy_url_callback')
         return proxyUrl
 
     def check_proxy_settings(self, url: Str = None, method: Str = None, headers=None, body=None):
@@ -1994,7 +1994,7 @@ class Exchange(object):
         length = len(usedProxies)
         if length > 1:
             joinedProxyNames = ','.join(usedProxies)
-            raise ProxyError(self.id + ' you have multiple conflicting proxy settings(' + joinedProxyNames + '), please use only one from: httpProxy, httpsProxy, httpProxyCallback, httpsProxyCallback, socksProxy, socksProxyCallback')
+            raise InvalidProxySettings(self.id + ' you have multiple conflicting proxy settings(' + joinedProxyNames + '), please use only one from: httpProxy, httpsProxy, httpProxyCallback, httpsProxyCallback, socksProxy, socksProxyCallback')
         return [httpProxy, httpsProxy, socksProxy]
 
     def check_ws_proxy_settings(self):
@@ -2027,12 +2027,12 @@ class Exchange(object):
         length = len(usedProxies)
         if length > 1:
             joinedProxyNames = ','.join(usedProxies)
-            raise ProxyError(self.id + ' you have multiple conflicting proxy settings(' + joinedProxyNames + '), please use only one from: wsProxy, wssProxy, wsSocksProxy')
+            raise InvalidProxySettings(self.id + ' you have multiple conflicting proxy settings(' + joinedProxyNames + '), please use only one from: wsProxy, wssProxy, wsSocksProxy')
         return [wsProxy, wssProxy, wsSocksProxy]
 
     def check_conflicting_proxies(self, proxyAgentSet, proxyUrlSet):
         if proxyAgentSet and proxyUrlSet:
-            raise ProxyError(self.id + ' you have multiple conflicting proxy settings, please use only one from : proxyUrl, httpProxy, httpsProxy, socksProxy')
+            raise InvalidProxySettings(self.id + ' you have multiple conflicting proxy settings, please use only one from : proxyUrl, httpProxy, httpsProxy, socksProxy')
 
     def find_message_hashes(self, client, element: str):
         result = []
@@ -2258,13 +2258,13 @@ class Exchange(object):
     def parse_isolated_borrow_rate(self, info: dict, market: Market = None):
         raise NotSupported(self.id + ' parseIsolatedBorrowRate() is not supported yet')
 
-    def parse_ws_trade(self, trade, market: Market = None):
+    def parse_ws_trade(self, trade: dict, market: Market = None):
         raise NotSupported(self.id + ' parseWsTrade() is not supported yet')
 
-    def parse_ws_order(self, order, market: Market = None):
+    def parse_ws_order(self, order: dict, market: Market = None):
         raise NotSupported(self.id + ' parseWsOrder() is not supported yet')
 
-    def parse_ws_order_trade(self, trade, market: Market = None):
+    def parse_ws_order_trade(self, trade: dict, market: Market = None):
         raise NotSupported(self.id + ' parseWsOrderTrade() is not supported yet')
 
     def parse_ws_ohlcv(self, ohlcv, market: Market = None):

ccxt/binance.py

@@ -19,7 +19,6 @@ from ccxt.base.errors import BadSymbol
 from ccxt.base.errors import OperationRejected
 from ccxt.base.errors import MarginModeAlreadySet
 from ccxt.base.errors import MarketClosed
-from ccxt.base.errors import BadResponse
 from ccxt.base.errors import InsufficientFunds
 from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
@@ -32,6 +31,7 @@ from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import OnMaintenance
 from ccxt.base.errors import InvalidNonce
 from ccxt.base.errors import RequestTimeout
+from ccxt.base.errors import BadResponse
 from ccxt.base.decimal_to_precision import TRUNCATE
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
@@ -6647,22 +6647,64 @@ class binance(Exchange, ImplicitAPI):
         response = None
         if market['option']:
             response = self.eapiPrivateDeleteAllOpenOrders(self.extend(request, params))
+            #
+            #    {
+            #        "code": 0,
+            #        "msg": "success"
+            #    }
+            #
         elif market['linear']:
             if isPortfolioMargin:
                 if isConditional:
                     response = self.papiDeleteUmConditionalAllOpenOrders(self.extend(request, params))
+                    #
+                    #    {
+                    #        "code": "200",
+                    #        "msg": "The operation of cancel all conditional open order is done."
+                    #    }
+                    #
                 else:
                     response = self.papiDeleteUmAllOpenOrders(self.extend(request, params))
+                    #
+                    #    {
+                    #        "code": 200,
+                    #        "msg": "The operation of cancel all open order is done."
+                    #    }
+                    #
             else:
                 response = self.fapiPrivateDeleteAllOpenOrders(self.extend(request, params))
+                #
+                #    {
+                #        "code": 200,
+                #        "msg": "The operation of cancel all open order is done."
+                #    }
+                #
         elif market['inverse']:
             if isPortfolioMargin:
                 if isConditional:
                     response = self.papiDeleteCmConditionalAllOpenOrders(self.extend(request, params))
+                    #
+                    #    {
+                    #        "code": "200",
+                    #        "msg": "The operation of cancel all conditional open order is done."
+                    #    }
+                    #
                 else:
                     response = self.papiDeleteCmAllOpenOrders(self.extend(request, params))
+                    #
+                    #    {
+                    #        "code": 200,
+                    #        "msg": "The operation of cancel all open order is done."
+                    #    }
+                    #
             else:
                 response = self.dapiPrivateDeleteAllOpenOrders(self.extend(request, params))
+                #
+                #    {
+                #        "code": 200,
+                #        "msg": "The operation of cancel all open order is done."
+                #    }
+                #
         elif (type == 'margin') or (marginMode is not None) or isPortfolioMargin:
             if isPortfolioMargin:
                 response = self.papiDeleteMarginAllOpenOrders(self.extend(request, params))
@@ -6670,12 +6712,59 @@ class binance(Exchange, ImplicitAPI):
                 if marginMode == 'isolated':
                     request['isIsolated'] = True
                 response = self.sapiDeleteMarginOpenOrders(self.extend(request, params))
+                #
+                #    [
+                #        {
+                #          "symbol": "BTCUSDT",
+                #          "isIsolated": True,       # if isolated margin
+                #          "origClientOrderId": "E6APeyTJvkMvLMYMqu1KQ4",
+                #          "orderId": 11,
+                #          "orderListId": -1,
+                #          "clientOrderId": "pXLV6Hz6mprAcVYpVMTGgx",
+                #          "price": "0.089853",
+                #          "origQty": "0.178622",
+                #          "executedQty": "0.000000",
+                #          "cummulativeQuoteQty": "0.000000",
+                #          "status": "CANCELED",
+                #          "timeInForce": "GTC",
+                #          "type": "LIMIT",
+                #          "side": "BUY",
+                #          "selfTradePreventionMode": "NONE"
+                #        },
+                #        ...
+                #    ]
+                #
         else:
             response = self.privateDeleteOpenOrders(self.extend(request, params))
+            #
+            #    [
+            #        {
+            #            "symbol": "ADAUSDT",
+            #            "origClientOrderId": "x-R4BD3S82662cde7a90114475b86e21",
+            #            "orderId": 3935107,
+            #            "orderListId": -1,
+            #            "clientOrderId": "bqM2w1oTlugfRAjnTIFBE8",
+            #            "transactTime": 1720589016657,
+            #            "price": "0.35000000",
+            #            "origQty": "30.00000000",
+            #            "executedQty": "0.00000000",
+            #            "cummulativeQuoteQty": "0.00000000",
+            #            "status": "CANCELED",
+            #            "timeInForce": "GTC",
+            #            "type": "LIMIT",
+            #            "side": "BUY",
+            #            "selfTradePreventionMode": "EXPIRE_MAKER"
+            #        }
+            #    ]
+            #
         if isinstance(response, list):
             return self.parse_orders(response, market)
         else:
-            return response
+            return [
+                self.safe_order({
+                    'info': response,
+                }),
+            ]
 
     def cancel_orders(self, ids: List[str], symbol: Str = None, params={}):
         """