ccxt 4.3.42__py2.py3-none-any.whl → 4.3.44__py2.py3-none-any.whl

ccxt/phemex.py

@@ -21,7 +21,6 @@ from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import CancelPending
 from ccxt.base.errors import DuplicateOrderId
-from ccxt.base.errors import NotSupported
 from ccxt.base.errors import DDoSProtection
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.decimal_to_precision import TICK_SIZE
@@ -2772,6 +2771,7 @@ class phemex(Exchange, ImplicitAPI):
 
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
+        :see: https://phemex-docs.github.io/#query-orders-by-ids
         fetches information on an order made by the user
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2781,8 +2781,6 @@ class phemex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchOrder() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        if market['settle'] == 'USDT':
-            raise NotSupported(self.id + 'fetchOrder() is not supported yet for USDT settled swap markets')  # https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#query-user-order-by-orderid-or-query-user-order-by-client-order-id
         request: dict = {
             'symbol': market['id'],
         }
@@ -2793,7 +2791,9 @@ class phemex(Exchange, ImplicitAPI):
         else:
             request['orderID'] = id
         response = None
-        if market['spot']:
+        if market['settle'] == 'USDT':
+            response = self.privateGetApiDataGFuturesOrdersByOrderId(self.extend(request, params))
+        elif market['spot']:
             response = self.privateGetSpotOrdersActive(self.extend(request, params))
         else:
             response = self.privateGetExchangeOrder(self.extend(request, params))

ccxt/poloniexfutures.py

@@ -1180,7 +1180,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
         cancelledOrderIdsLength = len(cancelledOrderIds)
         for i in range(0, cancelledOrderIdsLength):
             cancelledOrderId = self.safe_string(cancelledOrderIds, i)
-            result.append({
+            result.append(self.safe_order({
                 'id': cancelledOrderId,
                 'clientOrderId': None,
                 'timestamp': None,
@@ -1202,7 +1202,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
                 'postOnly': None,
                 'stopPrice': None,
                 'info': response,
-            })
+            }))
         return result
 
     def fetch_orders_by_status(self, status, symbol: Str = None, since: Int = None, limit: Int = None, params={}):

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.42'
+__version__ = '4.3.44'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitget.py

@@ -1153,23 +1153,30 @@ class bitget(ccxt.async_support.bitget):
         # isolated and cross margin
         #
         #     {
-        #         "enterPointSource": "web",
-        #         "force": "gtc",
-        #         "feeDetail": [],
-        #         "orderType": "limit",
-        #         "price": "35000.000000000",
-        #         "quoteSize": "10.500000000",
-        #         "side": "buy",
-        #         "status": "live",
-        #         "baseSize": "0.000300000",
-        #         "cTime": "1701923982427",
-        #         "clientOid": "4902047879864dc980c4840e9906db4e",
-        #         "fillPrice": "0.000000000",
-        #         "baseVolume": "0.000000000",
-        #         "fillTotalAmount": "0.000000000",
-        #         "loanType": "auto-loan-and-repay",
-        #         "orderId": "1116515595178356737"
-        #     }
+        #         enterPointSource: "web",
+        #         feeDetail: [
+        #           {
+        #             feeCoin: "AAVE",
+        #             deduction: "no",
+        #             totalDeductionFee: "0",
+        #             totalFee: "-0.00010740",
+        #           },
+        #         ],
+        #         force: "gtc",
+        #         orderType: "limit",
+        #         price: "93.170000000",
+        #         fillPrice: "93.170000000",
+        #         baseSize: "0.110600000",  # total amount of order
+        #         quoteSize: "10.304602000",  # total cost of order(independently if order is filled or pending)
+        #         baseVolume: "0.107400000",  # filled amount of order(during order's lifecycle, and not for self specific incoming update)
+        #         fillTotalAmount: "10.006458000",  # filled cost of order(during order's lifecycle, and not for self specific incoming update)
+        #         side: "buy",
+        #         status: "partially_filled",
+        #         cTime: "1717875017306",
+        #         clientOid: "b57afe789a06454e9c560a2aab7f7201",
+        #         loanType: "auto-loan",
+        #         orderId: "1183419084588060673",
+        #       }
         #
         isSpot = not ('posMode' in order)
         isMargin = ('loanType' in order)
@@ -1210,9 +1217,9 @@ class bitget(ccxt.async_support.bitget):
         totalFilled = self.safe_string(order, 'accBaseVolume')
         if isSpot:
             if isMargin:
-                filledAmount = self.omit_zero(self.safe_string(order, 'fillTotalAmount'))
-                totalAmount = self.omit_zero(self.safe_string(order, 'baseSize'))  # for margin trading
-                cost = self.safe_string(order, 'quoteSize')
+                totalAmount = self.safe_string(order, 'baseSize')
+                totalFilled = self.safe_string(order, 'baseVolume')
+                cost = self.safe_string(order, 'fillTotalAmount')
             else:
                 partialFillAmount = self.safe_string(order, 'baseVolume')
                 if partialFillAmount is not None:

ccxt/pro/bitmex.py

@@ -1469,11 +1469,15 @@ class bitmex(ccxt.async_support.bitmex):
         #
         action = self.safe_string(message, 'action')
         table = self.safe_string(message, 'table')
+        if table is None:
+            return  # protecting from weird updates
         data = self.safe_value(message, 'data', [])
         # if it's an initial snapshot
         if action == 'partial':
             filter = self.safe_dict(message, 'filter', {})
             marketId = self.safe_value(filter, 'symbol')
+            if marketId is None:
+                return  # protecting from weird update
             market = self.safe_market(marketId)
             symbol = market['symbol']
             if table == 'orderBookL2':
@@ -1501,6 +1505,8 @@ class bitmex(ccxt.async_support.bitmex):
             numUpdatesByMarketId: dict = {}
             for i in range(0, len(data)):
                 marketId = self.safe_value(data[i], 'symbol')
+                if marketId is None:
+                    return  # protecting from weird update
                 if not (marketId in numUpdatesByMarketId):
                     numUpdatesByMarketId[marketId] = 0
                 numUpdatesByMarketId[marketId] = self.sum(numUpdatesByMarketId, 1)

ccxt/pro/bybit.py

@@ -133,7 +133,7 @@ class bybit(ccxt.async_support.bybit):
             },
             'streaming': {
                 'ping': self.ping,
-                'keepAlive': 19000,
+                'keepAlive': 18000,
             },
         })
 

ccxt/pro/mexc.py

@@ -67,7 +67,7 @@ class mexc(ccxt.async_support.mexc):
             },
             'streaming': {
                 'ping': self.ping,
-                'keepAlive': 10000,
+                'keepAlive': 8000,
             },
             'exceptions': {
             },

ccxt/pro/woo.py

@@ -60,7 +60,7 @@ class woo(ccxt.async_support.woo):
             },
             'streaming': {
                 'ping': self.ping,
-                'keepAlive': 10000,
+                'keepAlive': 9000,
             },
             'exceptions': {
                 'ws': {

ccxt/test/test_async.py

@@ -1274,7 +1274,7 @@ class testMainClass(baseMainTestClass):
         #  -----------------------------------------------------------------------------
         #  --- Init of brokerId tests functions-----------------------------------------
         #  -----------------------------------------------------------------------------
-        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro()]
+        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro(), self.test_xt()]
         await asyncio.gather(*promises)
         success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
         dump('[INFO]' + success_message)
@@ -1602,6 +1602,26 @@ class testMainClass(baseMainTestClass):
         await close(exchange)
         return True
 
+    async def test_xt(self):
+        exchange = self.init_offline_exchange('xt')
+        id = 'CCXT'
+        spot_order_request = None
+        try:
+            await exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            spot_order_request = json_parse(exchange.last_request_body)
+        spot_media = spot_order_request['media']
+        assert spot_media == id, 'xt - id: ' + id + ' different from swap tag: ' + spot_media
+        swap_order_request = None
+        try:
+            await exchange.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            swap_order_request = json_parse(exchange.last_request_body)
+        swap_media = swap_order_request['clientMedia']
+        assert swap_media == id, 'xt - id: ' + id + ' different from swap tag: ' + swap_media
+        await close(exchange)
+        return True
+
 # ***** AUTO-TRANSPILER-END *****
 # *******************************
 

ccxt/test/test_sync.py

@@ -1273,7 +1273,7 @@ class testMainClass(baseMainTestClass):
         #  -----------------------------------------------------------------------------
         #  --- Init of brokerId tests functions-----------------------------------------
         #  -----------------------------------------------------------------------------
-        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro()]
+        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro(), self.test_xt()]
         (promises)
         success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
         dump('[INFO]' + success_message)
@@ -1601,6 +1601,26 @@ class testMainClass(baseMainTestClass):
         close(exchange)
         return True
 
+    def test_xt(self):
+        exchange = self.init_offline_exchange('xt')
+        id = 'CCXT'
+        spot_order_request = None
+        try:
+            exchange.create_order('BTC/USDT', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            spot_order_request = json_parse(exchange.last_request_body)
+        spot_media = spot_order_request['media']
+        assert spot_media == id, 'xt - id: ' + id + ' different from swap tag: ' + spot_media
+        swap_order_request = None
+        try:
+            exchange.create_order('BTC/USDT:USDT', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            swap_order_request = json_parse(exchange.last_request_body)
+        swap_media = swap_order_request['clientMedia']
+        assert swap_media == id, 'xt - id: ' + id + ' different from swap tag: ' + swap_media
+        close(exchange)
+        return True
+
 # ***** AUTO-TRANSPILER-END *****
 # *******************************
 

ccxt/tradeogre.py

@@ -9,6 +9,7 @@ from ccxt.base.types import IndexType, Int, Market, Num, Order, OrderSide, Order
 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 InsufficientFunds
 from ccxt.base.decimal_to_precision import TICK_SIZE
@@ -441,7 +442,7 @@ class tradeogre(Exchange, ImplicitAPI):
         """
         create a trade order
         :param str symbol: unified symbol of the market to create an order in
-        :param str type: not used by tradeogre
+        :param str type: must be 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of currency you want to trade in units of base currency
         :param float price: the price at which the order is to be fullfilled, in units of the quote currency
@@ -450,13 +451,15 @@ class tradeogre(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
+        if type == 'market':
+            raise BadRequest(self.id + ' createOrder does not support market orders')
+        if price is None:
+            raise ArgumentsRequired(self.id + ' createOrder requires a limit parameter')
         request: dict = {
             'market': market['id'],
             'quantity': self.parse_to_numeric(self.amount_to_precision(symbol, amount)),
             'price': self.parse_to_numeric(self.price_to_precision(symbol, price)),
         }
-        if type == 'market':
-            raise BadRequest(self.id + ' createOrder does not support market orders')
         response = None
         if side == 'buy':
             response = self.privatePostOrderBuy(self.extend(request, params))
@@ -487,7 +490,10 @@ class tradeogre(Exchange, ImplicitAPI):
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        return self.cancel_order('all', symbol, params)
+        response = self.cancel_order('all', symbol, params)
+        return [
+            response,
+        ]
 
     def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """

ccxt/wavesexchange.py

@@ -1421,7 +1421,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         firstMessage = self.safe_value(message, 0)
         firstOrder = self.safe_value(firstMessage, 0)
         returnedId = self.safe_string(firstOrder, 'orderId')
-        return {
+        return self.safe_order({
             'info': response,
             'id': returnedId,
             'clientOrderId': None,
@@ -1440,7 +1440,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             'status': None,
             'fee': None,
             'trades': None,
-        }
+        })
 
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """

ccxt/wazirx.py

@@ -763,7 +763,26 @@ class wazirx(Exchange, ImplicitAPI):
         request: dict = {
             'symbol': market['id'],
         }
-        return self.privateDeleteOpenOrders(self.extend(request, params))
+        response = self.privateDeleteOpenOrders(self.extend(request, params))
+        #
+        #    [
+        #        {
+        #            id: "4565421197",
+        #            symbol: "adausdt",
+        #            type: "limit",
+        #            side: "buy",
+        #            status: "wait",
+        #            price: "0.41",
+        #            origQty: "11.00",
+        #            executedQty: "0.00",
+        #            avgPrice: "0.00",
+        #            createdTime: "1718089507000",
+        #            updatedTime: "1718089507000",
+        #            clientOrderId: "93d2a838-e272-405d-91e7-3a7bc6d3a003"
+        #        }
+        #    ]
+        #
+        return self.parse_orders(response)
 
     def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
@@ -831,18 +850,22 @@ class wazirx(Exchange, ImplicitAPI):
         return self.parse_order(response, market)
 
     def parse_order(self, order: dict, market: Market = None) -> Order:
-        # {
-        #     "id":1949417813,
-        #     "symbol":"ltcusdt",
-        #     "type":"limit",
-        #     "side":"sell",
-        #     "status":"done",
-        #     "price":"146.2",
-        #     "origQty":"0.05",
-        #     "executedQty":"0.05",
-        #     "createdTime":1641252564000,
-        #     "updatedTime":1641252564000
-        # },
+        #
+        #    {
+        #        "id": 1949417813,
+        #        "symbol": "ltcusdt",
+        #        "type": "limit",
+        #        "side": "sell",
+        #        "status": "done",
+        #        "price": "146.2",
+        #        "origQty": "0.05",
+        #        "executedQty": "0.05",
+        #        "avgPrice":  "0.00",
+        #        "createdTime": 1641252564000,
+        #        "updatedTime": 1641252564000
+        #        "clientOrderId": "93d2a838-e272-405d-91e7-3a7bc6d3a003"
+        #    }
+        #
         created = self.safe_integer(order, 'createdTime')
         updated = self.safe_integer(order, 'updatedTime')
         marketId = self.safe_string(order, 'symbol')
@@ -857,7 +880,7 @@ class wazirx(Exchange, ImplicitAPI):
         return self.safe_order({
             'info': order,
             'id': id,
-            'clientOrderId': None,
+            'clientOrderId': self.safe_string(order, 'clientOrderId'),
             'timestamp': created,
             'datetime': self.iso8601(created),
             'lastTradeTimestamp': updated,
@@ -873,7 +896,7 @@ class wazirx(Exchange, ImplicitAPI):
             'remaining': None,
             'cost': None,
             'fee': None,
-            'average': None,
+            'average': self.safe_string(order, 'avgPrice'),
             'trades': [],
         }, market)