ccxt 4.1.69__py2.py3-none-any.whl → 4.1.70__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.1.69'
+__version__ = '4.1.70'
 
 # ----------------------------------------------------------------------------
 

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.1.69'
+__version__ = '4.1.70'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.1.69'
+__version__ = '4.1.70'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/coinex.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.coinex import ImplicitAPI
 import asyncio
-from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -55,8 +55,10 @@ class coinex(Exchange, ImplicitAPI):
                 'borrowIsolatedMargin': True,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
+                'cancelOrders': True,
                 'createDepositAddress': True,
                 'createOrder': True,
+                'createOrders': True,
                 'createReduceOnlyOrder': True,
                 'editOrder': True,
                 'fetchBalance': True,
@@ -1494,6 +1496,8 @@ class coinex(Exchange, ImplicitAPI):
 
     def parse_order_status(self, status):
         statuses = {
+            'rejected': 'rejected',
+            'open': 'open',
             'not_deal': 'open',
             'part_deal': 'open',
             'done': 'closed',
@@ -1527,7 +1531,7 @@ class coinex(Exchange, ImplicitAPI):
         #         "client_id": "",
         #     }
         #
-        # Spot and Margin createOrder, cancelOrder, fetchOrder
+        # Spot and Margin createOrder, createOrders, cancelOrder, cancelOrders, fetchOrder
         #
         #      {
         #          "amount":"1.5",
@@ -1726,13 +1730,50 @@ class coinex(Exchange, ImplicitAPI):
         #         "user_id": 3620173
         #     }
         #
+        # swap: cancelOrders
+        #
+        #     {
+        #         "amount": "0.0005",
+        #         "client_id": "x-167673045-b0cee0c584718b65",
+        #         "create_time": 1701233683.294231,
+        #         "deal_asset_fee": "0.00000000000000000000",
+        #         "deal_fee": "0.00000000000000000000",
+        #         "deal_profit": "0.00000000000000000000",
+        #         "deal_stock": "0.00000000000000000000",
+        #         "effect_type": 1,
+        #         "fee_asset": "",
+        #         "fee_discount": "0.00000000000000000000",
+        #         "last_deal_amount": "0.00000000000000000000",
+        #         "last_deal_id": 0,
+        #         "last_deal_price": "0.00000000000000000000",
+        #         "last_deal_role": 0,
+        #         "last_deal_time": 0,
+        #         "last_deal_type": 0,
+        #         "left": "0.0005",
+        #         "leverage": "3",
+        #         "maker_fee": "0.00030",
+        #         "market": "BTCUSDT",
+        #         "option": 0,
+        #         "order_id": 115940476323,
+        #         "position_id": 0,
+        #         "position_type": 2,
+        #         "price": "25000.00",
+        #         "side": 2,
+        #         "source": "api.v1",
+        #         "stop_id": 0,
+        #         "stop_loss_price": "0.00000000000000000000",
+        #         "stop_loss_type": 0,
+        #         "take_profit_price": "0.00000000000000000000",
+        #         "take_profit_type": 0,
+        #         "taker_fee": "0.00050",
+        #         "target": 0,
+        #         "type": 1,
+        #         "update_time": 1701233721.718884,
+        #         "user_id": 3620173
+        #     }
+        #
+        rawStatus = self.safe_string(order, 'status')
         timestamp = self.safe_timestamp(order, 'create_time')
-        priceString = self.safe_string(order, 'price')
-        costString = self.safe_string(order, 'deal_money')
-        amountString = self.safe_string(order, 'amount')
-        filledString = self.safe_string(order, 'deal_amount')
-        averageString = self.safe_string(order, 'avg_price')
-        remainingString = self.safe_string(order, 'left')
         marketId = self.safe_string(order, 'market')
         defaultType = self.safe_string(self.options, 'defaultType')
         orderType = 'swap' if ('source' in order) else defaultType
@@ -1741,7 +1782,6 @@ class coinex(Exchange, ImplicitAPI):
         feeCurrency = self.safe_currency_code(feeCurrencyId)
         if feeCurrency is None:
             feeCurrency = market['quote']
-        status = self.parse_order_status(self.safe_string(order, 'status'))
         rawSide = self.safe_integer(order, 'side')
         side: Str = None
         if rawSide == 1:
@@ -1769,21 +1809,23 @@ class coinex(Exchange, ImplicitAPI):
             'datetime': self.iso8601(timestamp),
             'timestamp': timestamp,
             'lastTradeTimestamp': self.safe_timestamp(order, 'update_time'),
-            'status': status,
+            'status': self.parse_order_status(rawStatus),
             'symbol': market['symbol'],
             'type': type,
             'timeInForce': None,
             'postOnly': None,
             'reduceOnly': None,
             'side': side,
-            'price': priceString,
+            'price': self.safe_string(order, 'price'),
             'stopPrice': self.safe_string(order, 'stop_price'),
             'triggerPrice': self.safe_string(order, 'stop_price'),
-            'cost': costString,
-            'average': averageString,
-            'amount': amountString,
-            'filled': filledString,
-            'remaining': remainingString,
+            'takeProfitPrice': self.safe_number(order, 'take_profit_price'),
+            'stopLossPrice': self.safe_number(order, 'stop_loss_price'),
+            'cost': self.safe_string(order, 'deal_money'),
+            'average': self.safe_string(order, 'avg_price'),
+            'amount': self.safe_string(order, 'amount'),
+            'filled': self.safe_string(order, 'deal_amount'),
+            'remaining': self.safe_string(order, 'left'),
             'trades': None,
             'fee': {
                 'currency': feeCurrency,
@@ -1792,32 +1834,7 @@ class coinex(Exchange, ImplicitAPI):
             'info': order,
         }, market)
 
-    async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
-        """
-        create a trade order
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http017_put_limit
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http018_put_market
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http019_put_limit_stop
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http020_put_market_stop
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http031_market_close
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http030_limit_close
-        :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 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, ignored in market orders
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param float triggerPrice: price at which to triger stop orders
-        :param float stopPrice: price at which to triger stop orders
-        :param float stopLossPrice: price at which to trigger stop-loss orders
-        :param float takeProfitPrice: price at which to trigger take-profit orders
-        :param str [params.timeInForce]: "GTC", "IOC", "FOK", "PO"
-        :param bool params.postOnly:
-        :param bool params.reduceOnly:
-        :param bool [params.position_id]: *required for reduce only orders* the position id to reduce
-        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
-        """
-        await self.load_markets()
+    def create_order_request(self, symbol, type, side, amount, price=None, params={}):
         market = self.market(symbol)
         swap = market['swap']
         clientOrderId = self.safe_string_2(params, 'client_id', 'clientOrderId')
@@ -1831,11 +1848,10 @@ class coinex(Exchange, ImplicitAPI):
         timeInForceRaw = self.safe_string(params, 'timeInForce')  # Spot: IOC, FOK, PO, GTC, ... NORMAL(default), MAKER_ONLY
         reduceOnly = self.safe_value(params, 'reduceOnly')
         if reduceOnly:
-            if market['type'] != 'swap':
+            if not market['swap']:
                 raise InvalidOrder(self.id + ' createOrder() does not support reduceOnly for ' + market['type'] + ' orders, reduceOnly orders are supported for swap markets only')
             if positionId is None:
                 raise ArgumentsRequired(self.id + ' createOrder() requires a position_id/positionId parameter for reduceOnly orders')
-        method = None
         request = {
             'market': market['id'],
         }
@@ -1852,13 +1868,10 @@ class coinex(Exchange, ImplicitAPI):
                     raise ArgumentsRequired(self.id + ' createOrder() requires a position_id parameter for stop loss and take profit orders')
                 request['position_id'] = positionId
                 if stopLossPrice:
-                    method = 'perpetualPrivatePostPositionStopLoss'
                     request['stop_loss_price'] = self.price_to_precision(symbol, stopLossPrice)
                 elif takeProfitPrice:
-                    method = 'perpetualPrivatePostPositionTakeProfit'
                     request['take_profit_price'] = self.price_to_precision(symbol, takeProfitPrice)
             else:
-                method = 'perpetualPrivatePostOrderPut' + self.capitalize(type)
                 requestSide = 2 if (side == 'buy') else 1
                 if stopPrice is not None:
                     request['stop_price'] = self.price_to_precision(symbol, stopPrice)
@@ -1866,10 +1879,7 @@ class coinex(Exchange, ImplicitAPI):
                     request['amount'] = self.amount_to_precision(symbol, amount)
                     request['side'] = requestSide
                     if type == 'limit':
-                        method = 'perpetualPrivatePostOrderPutStopLimit'
                         request['price'] = self.price_to_precision(symbol, price)
-                    elif type == 'market':
-                        method = 'perpetualPrivatePostOrderPutStopMarket'
                     request['amount'] = self.amount_to_precision(symbol, amount)
                 timeInForce = None
                 if (type != 'market') or (stopPrice is not None):
@@ -1885,7 +1895,6 @@ class coinex(Exchange, ImplicitAPI):
                         request['effect_type'] = timeInForce  # exchange takes 'IOC' and 'FOK'
                 if type == 'limit' and stopPrice is None:
                     if reduceOnly:
-                        method = 'perpetualPrivatePostOrderCloseLimit'
                         request['position_id'] = positionId
                     else:
                         request['side'] = requestSide
@@ -1893,13 +1902,11 @@ class coinex(Exchange, ImplicitAPI):
                     request['amount'] = self.amount_to_precision(symbol, amount)
                 elif type == 'market' and stopPrice is None:
                     if reduceOnly:
-                        method = 'perpetualPrivatePostOrderCloseMarket'
                         request['position_id'] = positionId
                     else:
                         request['side'] = requestSide
                         request['amount'] = self.amount_to_precision(symbol, amount)
         else:
-            method = 'privatePostOrder' + self.capitalize(type)
             request['type'] = side
             if (type == 'market') and (side == 'buy'):
                 if self.options['createMarketBuyOrderRequiresPrice']:
@@ -1919,10 +1926,6 @@ class coinex(Exchange, ImplicitAPI):
                 request['price'] = self.price_to_precision(symbol, price)
             if stopPrice is not None:
                 request['stop_price'] = self.price_to_precision(symbol, stopPrice)
-                if type == 'limit':
-                    method = 'privatePostOrderStopLimit'
-                elif type == 'market':
-                    method = 'privatePostOrderStopMarket'
             if (type != 'market') or (stopPrice is not None):
                 # following options cannot be applied to vanilla market orders(but can be applied to stop-market orders)
                 if (timeInForceRaw is not None) or postOnly:
@@ -1940,7 +1943,77 @@ class coinex(Exchange, ImplicitAPI):
                 raise BadRequest(self.id + ' createOrder() requires an account_id parameter for margin orders')
             request['account_id'] = accountId
         params = self.omit(params, ['reduceOnly', 'positionId', 'timeInForce', 'postOnly', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice'])
-        response = await getattr(self, method)(self.extend(request, params))
+        return self.extend(request, params)
+
+    async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+        """
+        create a trade order
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http017_put_limit
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http018_put_market
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http019_put_limit_stop
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http020_put_market_stop
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http031_market_close
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http030_limit_close
+        :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 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 quote currency, ignored in market orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.triggerPrice]: price to trigger stop orders
+        :param float [params.stopLossPrice]: price to trigger stop loss orders
+        :param float [params.takeProfitPrice]: price to trigger take profit orders
+        :param str [params.timeInForce]: 'GTC', 'IOC', 'FOK', 'PO'
+        :param boolean [params.postOnly]: set to True if you wish to make a post only order
+        :param boolean [params.reduceOnly]: *contract only* indicates if self order is to reduce the size of a position
+        :param int [params.position_id]: *required for reduce only orders* the position id to reduce
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        reduceOnly = self.safe_value(params, 'reduceOnly')
+        triggerPrice = self.safe_number_2(params, 'stopPrice', 'triggerPrice')
+        stopLossTriggerPrice = self.safe_number(params, 'stopLossPrice')
+        takeProfitTriggerPrice = self.safe_number(params, 'takeProfitPrice')
+        isTriggerOrder = triggerPrice is not None
+        isStopLossTriggerOrder = stopLossTriggerPrice is not None
+        isTakeProfitTriggerOrder = takeProfitTriggerPrice is not None
+        isStopLossOrTakeProfitTrigger = isStopLossTriggerOrder or isTakeProfitTriggerOrder
+        request = self.create_order_request(symbol, type, side, amount, price, params)
+        response = None
+        if market['spot']:
+            if isTriggerOrder:
+                if type == 'limit':
+                    response = await self.privatePostOrderStopLimit(request)
+                else:
+                    response = await self.privatePostOrderStopMarket(request)
+            else:
+                if type == 'limit':
+                    response = await self.privatePostOrderLimit(request)
+                else:
+                    response = await self.privatePostOrderMarket(request)
+        else:
+            if isTriggerOrder:
+                if type == 'limit':
+                    response = await self.perpetualPrivatePostOrderPutStopLimit(request)
+                else:
+                    response = await self.perpetualPrivatePostOrderPutStopMarket(request)
+            elif isStopLossOrTakeProfitTrigger:
+                if isStopLossTriggerOrder:
+                    response = await self.perpetualPrivatePostPositionStopLoss(request)
+                elif isTakeProfitTriggerOrder:
+                    response = await self.perpetualPrivatePostPositionTakeProfit(request)
+            else:
+                if reduceOnly:
+                    if type == 'limit':
+                        response = await self.perpetualPrivatePostOrderCloseLimit(request)
+                    else:
+                        response = await self.perpetualPrivatePostOrderCloseMarket(request)
+                else:
+                    if type == 'limit':
+                        response = await self.perpetualPrivatePostOrderPutLimit(request)
+                    else:
+                        response = await self.perpetualPrivatePostOrderPutMarket(request)
         #
         # Spot and Margin
         #
@@ -2018,9 +2091,225 @@ class coinex(Exchange, ImplicitAPI):
         #
         #     {"code":0,"data":{"status":"success"},"message":"OK"}
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_value(response, 'data', {})
         return self.parse_order(data, market)
 
+    async def create_orders(self, orders: List[OrderRequest], params={}) -> List[Order]:
+        """
+        create a list of trade orders(all orders should be of the same symbol)
+        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade002_batch_limit_orders
+        :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
+        :param dict [params]: extra parameters specific to the api endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        ordersRequests = []
+        symbol = None
+        for i in range(0, len(orders)):
+            rawOrder = orders[i]
+            marketId = self.safe_string(rawOrder, 'symbol')
+            if symbol is None:
+                symbol = marketId
+            else:
+                if symbol != marketId:
+                    raise BadRequest(self.id + ' createOrders() requires all orders to have the same symbol')
+            type = self.safe_string(rawOrder, 'type')
+            side = self.safe_string(rawOrder, 'side')
+            amount = self.safe_value(rawOrder, 'amount')
+            price = self.safe_value(rawOrder, 'price')
+            orderParams = self.safe_value(rawOrder, 'params', {})
+            if type != 'limit':
+                raise NotSupported(self.id + ' createOrders() does not support ' + type + ' orders, only limit orders are accepted')
+            orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams)
+            ordersRequests.append(orderRequest)
+        market = self.market(symbol)
+        if not market['spot']:
+            raise NotSupported(self.id + ' createOrders() does not support ' + market['type'] + ' orders, only spot orders are accepted')
+        request = {
+            'market': market['id'],
+            'batch_orders': self.json(ordersRequests),
+        }
+        response = await self.privatePostOrderLimitBatch(request)
+        #
+        #     {
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "code": 0,
+        #                 "data": {
+        #                     "amount": "0.0005",
+        #                     "asset_fee": "0",
+        #                     "avg_price": "0.00",
+        #                     "client_id": "x-167673045-d34bfb41242d8fd1",
+        #                     "create_time": 1701229157,
+        #                     "deal_amount": "0",
+        #                     "deal_fee": "0",
+        #                     "deal_money": "0",
+        #                     "fee_asset": null,
+        #                     "fee_discount": "1",
+        #                     "finished_time": null,
+        #                     "id": 107745856676,
+        #                     "left": "0.0005",
+        #                     "maker_fee_rate": "0.002",
+        #                     "market": "BTCUSDT",
+        #                     "money_fee": "0",
+        #                     "order_type": "limit",
+        #                     "price": "23000",
+        #                     "source_id": "",
+        #                     "status": "not_deal",
+        #                     "stock_fee": "0",
+        #                     "taker_fee_rate": "0.002",
+        #                     "type": "buy"
+        #                 },
+        #                 "message": "OK"
+        #             },
+        #         ],
+        #         "message": "Success"
+        #     }
+        #
+        data = self.safe_value(response, 'data', [])
+        results = []
+        for i in range(0, len(data)):
+            entry = data[i]
+            status = None
+            code = self.safe_integer(entry, 'code')
+            if code is not None:
+                if code != 0:
+                    status = 'rejected'
+                else:
+                    status = 'open'
+            item = self.safe_value(entry, 'data', {})
+            item['status'] = status
+            order = self.parse_order(item, market)
+            results.append(order)
+        return results
+
+    async def cancel_orders(self, ids, symbol: Str = None, params={}):
+        """
+        cancel multiple orders
+        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade016_batch_cancel_order
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http021-0_cancel_order_batch
+        :param str[] ids: order ids
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        if symbol is None:
+            raise ArgumentsRequired(self.id + ' cancelOrders() requires a symbol argument')
+        await self.load_markets()
+        market = self.market(symbol)
+        request = {
+            'market': market['id'],
+        }
+        idsString = ','.join(ids)
+        response = None
+        if market['spot']:
+            request['batch_ids'] = idsString
+            response = await self.privateDeleteOrderPendingBatch(self.extend(request, params))
+        else:
+            request['order_ids'] = idsString
+            response = await self.perpetualPrivatePostOrderCancelBatch(self.extend(request, params))
+        #
+        # spot
+        #
+        #     {
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "code": 0,
+        #                 "data": {
+        #                     "account_id": 0,
+        #                     "amount": "0.0005",
+        #                     "asset_fee": "0",
+        #                     "avg_price": "0.00",
+        #                     "client_id": "x-167673045-d4e03c38f4d19b4e",
+        #                     "create_time": 1701229157,
+        #                     "deal_amount": "0",
+        #                     "deal_fee": "0",
+        #                     "deal_money": "0",
+        #                     "fee_asset": null,
+        #                     "fee_discount": "1",
+        #                     "finished_time": 0,
+        #                     "id": 107745856682,
+        #                     "left": "0",
+        #                     "maker_fee_rate": "0.002",
+        #                     "market": "BTCUSDT",
+        #                     "money_fee": "0",
+        #                     "order_type": "limit",
+        #                     "price": "22000",
+        #                     "status": "not_deal",
+        #                     "stock_fee": "0",
+        #                     "taker_fee_rate": "0.002",
+        #                     "type": "buy"
+        #                 },
+        #                 "message": ""
+        #             },
+        #         ],
+        #         "message": "Success"
+        #     }
+        #
+        # swap
+        #
+        #     {
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "code": 0,
+        #                 "message": "",
+        #                 "order": {
+        #                     "amount": "0.0005",
+        #                     "client_id": "x-167673045-b0cee0c584718b65",
+        #                     "create_time": 1701233683.294231,
+        #                     "deal_asset_fee": "0.00000000000000000000",
+        #                     "deal_fee": "0.00000000000000000000",
+        #                     "deal_profit": "0.00000000000000000000",
+        #                     "deal_stock": "0.00000000000000000000",
+        #                     "effect_type": 1,
+        #                     "fee_asset": "",
+        #                     "fee_discount": "0.00000000000000000000",
+        #                     "last_deal_amount": "0.00000000000000000000",
+        #                     "last_deal_id": 0,
+        #                     "last_deal_price": "0.00000000000000000000",
+        #                     "last_deal_role": 0,
+        #                     "last_deal_time": 0,
+        #                     "last_deal_type": 0,
+        #                     "left": "0.0005",
+        #                     "leverage": "3",
+        #                     "maker_fee": "0.00030",
+        #                     "market": "BTCUSDT",
+        #                     "option": 0,
+        #                     "order_id": 115940476323,
+        #                     "position_id": 0,
+        #                     "position_type": 2,
+        #                     "price": "25000.00",
+        #                     "side": 2,
+        #                     "source": "api.v1",
+        #                     "stop_id": 0,
+        #                     "stop_loss_price": "0.00000000000000000000",
+        #                     "stop_loss_type": 0,
+        #                     "take_profit_price": "0.00000000000000000000",
+        #                     "take_profit_type": 0,
+        #                     "taker_fee": "0.00050",
+        #                     "target": 0,
+        #                     "type": 1,
+        #                     "update_time": 1701233721.718884,
+        #                     "user_id": 3620173
+        #                 }
+        #             },
+        #         ],
+        #         "message": "OK"
+        #     }
+        #
+        data = self.safe_value(response, 'data', [])
+        results = []
+        for i in range(0, len(data)):
+            entry = data[i]
+            dataRequest = 'data' if market['spot'] else 'order'
+            item = self.safe_value(entry, dataRequest, {})
+            order = self.parse_order(item, market)
+            results.append(order)
+        return results
+
     async def edit_order(self, id, symbol, type, side, amount=None, price=None, params={}):
         """
         edit a trade order

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.1.69'
+__version__ = '4.1.70'
 
 # -----------------------------------------------------------------------------
 

ccxt/coinex.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.coinex import ImplicitAPI
-from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -54,8 +54,10 @@ class coinex(Exchange, ImplicitAPI):
                 'borrowIsolatedMargin': True,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
+                'cancelOrders': True,
                 'createDepositAddress': True,
                 'createOrder': True,
+                'createOrders': True,
                 'createReduceOnlyOrder': True,
                 'editOrder': True,
                 'fetchBalance': True,
@@ -1493,6 +1495,8 @@ class coinex(Exchange, ImplicitAPI):
 
     def parse_order_status(self, status):
         statuses = {
+            'rejected': 'rejected',
+            'open': 'open',
             'not_deal': 'open',
             'part_deal': 'open',
             'done': 'closed',
@@ -1526,7 +1530,7 @@ class coinex(Exchange, ImplicitAPI):
         #         "client_id": "",
         #     }
         #
-        # Spot and Margin createOrder, cancelOrder, fetchOrder
+        # Spot and Margin createOrder, createOrders, cancelOrder, cancelOrders, fetchOrder
         #
         #      {
         #          "amount":"1.5",
@@ -1725,13 +1729,50 @@ class coinex(Exchange, ImplicitAPI):
         #         "user_id": 3620173
         #     }
         #
+        # swap: cancelOrders
+        #
+        #     {
+        #         "amount": "0.0005",
+        #         "client_id": "x-167673045-b0cee0c584718b65",
+        #         "create_time": 1701233683.294231,
+        #         "deal_asset_fee": "0.00000000000000000000",
+        #         "deal_fee": "0.00000000000000000000",
+        #         "deal_profit": "0.00000000000000000000",
+        #         "deal_stock": "0.00000000000000000000",
+        #         "effect_type": 1,
+        #         "fee_asset": "",
+        #         "fee_discount": "0.00000000000000000000",
+        #         "last_deal_amount": "0.00000000000000000000",
+        #         "last_deal_id": 0,
+        #         "last_deal_price": "0.00000000000000000000",
+        #         "last_deal_role": 0,
+        #         "last_deal_time": 0,
+        #         "last_deal_type": 0,
+        #         "left": "0.0005",
+        #         "leverage": "3",
+        #         "maker_fee": "0.00030",
+        #         "market": "BTCUSDT",
+        #         "option": 0,
+        #         "order_id": 115940476323,
+        #         "position_id": 0,
+        #         "position_type": 2,
+        #         "price": "25000.00",
+        #         "side": 2,
+        #         "source": "api.v1",
+        #         "stop_id": 0,
+        #         "stop_loss_price": "0.00000000000000000000",
+        #         "stop_loss_type": 0,
+        #         "take_profit_price": "0.00000000000000000000",
+        #         "take_profit_type": 0,
+        #         "taker_fee": "0.00050",
+        #         "target": 0,
+        #         "type": 1,
+        #         "update_time": 1701233721.718884,
+        #         "user_id": 3620173
+        #     }
+        #
+        rawStatus = self.safe_string(order, 'status')
         timestamp = self.safe_timestamp(order, 'create_time')
-        priceString = self.safe_string(order, 'price')
-        costString = self.safe_string(order, 'deal_money')
-        amountString = self.safe_string(order, 'amount')
-        filledString = self.safe_string(order, 'deal_amount')
-        averageString = self.safe_string(order, 'avg_price')
-        remainingString = self.safe_string(order, 'left')
         marketId = self.safe_string(order, 'market')
         defaultType = self.safe_string(self.options, 'defaultType')
         orderType = 'swap' if ('source' in order) else defaultType
@@ -1740,7 +1781,6 @@ class coinex(Exchange, ImplicitAPI):
         feeCurrency = self.safe_currency_code(feeCurrencyId)
         if feeCurrency is None:
             feeCurrency = market['quote']
-        status = self.parse_order_status(self.safe_string(order, 'status'))
         rawSide = self.safe_integer(order, 'side')
         side: Str = None
         if rawSide == 1:
@@ -1768,21 +1808,23 @@ class coinex(Exchange, ImplicitAPI):
             'datetime': self.iso8601(timestamp),
             'timestamp': timestamp,
             'lastTradeTimestamp': self.safe_timestamp(order, 'update_time'),
-            'status': status,
+            'status': self.parse_order_status(rawStatus),
             'symbol': market['symbol'],
             'type': type,
             'timeInForce': None,
             'postOnly': None,
             'reduceOnly': None,
             'side': side,
-            'price': priceString,
+            'price': self.safe_string(order, 'price'),
             'stopPrice': self.safe_string(order, 'stop_price'),
             'triggerPrice': self.safe_string(order, 'stop_price'),
-            'cost': costString,
-            'average': averageString,
-            'amount': amountString,
-            'filled': filledString,
-            'remaining': remainingString,
+            'takeProfitPrice': self.safe_number(order, 'take_profit_price'),
+            'stopLossPrice': self.safe_number(order, 'stop_loss_price'),
+            'cost': self.safe_string(order, 'deal_money'),
+            'average': self.safe_string(order, 'avg_price'),
+            'amount': self.safe_string(order, 'amount'),
+            'filled': self.safe_string(order, 'deal_amount'),
+            'remaining': self.safe_string(order, 'left'),
             'trades': None,
             'fee': {
                 'currency': feeCurrency,
@@ -1791,32 +1833,7 @@ class coinex(Exchange, ImplicitAPI):
             'info': order,
         }, market)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
-        """
-        create a trade order
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http017_put_limit
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http018_put_market
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http019_put_limit_stop
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http020_put_market_stop
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http031_market_close
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http030_limit_close
-        :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 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, ignored in market orders
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param float triggerPrice: price at which to triger stop orders
-        :param float stopPrice: price at which to triger stop orders
-        :param float stopLossPrice: price at which to trigger stop-loss orders
-        :param float takeProfitPrice: price at which to trigger take-profit orders
-        :param str [params.timeInForce]: "GTC", "IOC", "FOK", "PO"
-        :param bool params.postOnly:
-        :param bool params.reduceOnly:
-        :param bool [params.position_id]: *required for reduce only orders* the position id to reduce
-        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
-        """
-        self.load_markets()
+    def create_order_request(self, symbol, type, side, amount, price=None, params={}):
         market = self.market(symbol)
         swap = market['swap']
         clientOrderId = self.safe_string_2(params, 'client_id', 'clientOrderId')
@@ -1830,11 +1847,10 @@ class coinex(Exchange, ImplicitAPI):
         timeInForceRaw = self.safe_string(params, 'timeInForce')  # Spot: IOC, FOK, PO, GTC, ... NORMAL(default), MAKER_ONLY
         reduceOnly = self.safe_value(params, 'reduceOnly')
         if reduceOnly:
-            if market['type'] != 'swap':
+            if not market['swap']:
                 raise InvalidOrder(self.id + ' createOrder() does not support reduceOnly for ' + market['type'] + ' orders, reduceOnly orders are supported for swap markets only')
             if positionId is None:
                 raise ArgumentsRequired(self.id + ' createOrder() requires a position_id/positionId parameter for reduceOnly orders')
-        method = None
         request = {
             'market': market['id'],
         }
@@ -1851,13 +1867,10 @@ class coinex(Exchange, ImplicitAPI):
                     raise ArgumentsRequired(self.id + ' createOrder() requires a position_id parameter for stop loss and take profit orders')
                 request['position_id'] = positionId
                 if stopLossPrice:
-                    method = 'perpetualPrivatePostPositionStopLoss'
                     request['stop_loss_price'] = self.price_to_precision(symbol, stopLossPrice)
                 elif takeProfitPrice:
-                    method = 'perpetualPrivatePostPositionTakeProfit'
                     request['take_profit_price'] = self.price_to_precision(symbol, takeProfitPrice)
             else:
-                method = 'perpetualPrivatePostOrderPut' + self.capitalize(type)
                 requestSide = 2 if (side == 'buy') else 1
                 if stopPrice is not None:
                     request['stop_price'] = self.price_to_precision(symbol, stopPrice)
@@ -1865,10 +1878,7 @@ class coinex(Exchange, ImplicitAPI):
                     request['amount'] = self.amount_to_precision(symbol, amount)
                     request['side'] = requestSide
                     if type == 'limit':
-                        method = 'perpetualPrivatePostOrderPutStopLimit'
                         request['price'] = self.price_to_precision(symbol, price)
-                    elif type == 'market':
-                        method = 'perpetualPrivatePostOrderPutStopMarket'
                     request['amount'] = self.amount_to_precision(symbol, amount)
                 timeInForce = None
                 if (type != 'market') or (stopPrice is not None):
@@ -1884,7 +1894,6 @@ class coinex(Exchange, ImplicitAPI):
                         request['effect_type'] = timeInForce  # exchange takes 'IOC' and 'FOK'
                 if type == 'limit' and stopPrice is None:
                     if reduceOnly:
-                        method = 'perpetualPrivatePostOrderCloseLimit'
                         request['position_id'] = positionId
                     else:
                         request['side'] = requestSide
@@ -1892,13 +1901,11 @@ class coinex(Exchange, ImplicitAPI):
                     request['amount'] = self.amount_to_precision(symbol, amount)
                 elif type == 'market' and stopPrice is None:
                     if reduceOnly:
-                        method = 'perpetualPrivatePostOrderCloseMarket'
                         request['position_id'] = positionId
                     else:
                         request['side'] = requestSide
                         request['amount'] = self.amount_to_precision(symbol, amount)
         else:
-            method = 'privatePostOrder' + self.capitalize(type)
             request['type'] = side
             if (type == 'market') and (side == 'buy'):
                 if self.options['createMarketBuyOrderRequiresPrice']:
@@ -1918,10 +1925,6 @@ class coinex(Exchange, ImplicitAPI):
                 request['price'] = self.price_to_precision(symbol, price)
             if stopPrice is not None:
                 request['stop_price'] = self.price_to_precision(symbol, stopPrice)
-                if type == 'limit':
-                    method = 'privatePostOrderStopLimit'
-                elif type == 'market':
-                    method = 'privatePostOrderStopMarket'
             if (type != 'market') or (stopPrice is not None):
                 # following options cannot be applied to vanilla market orders(but can be applied to stop-market orders)
                 if (timeInForceRaw is not None) or postOnly:
@@ -1939,7 +1942,77 @@ class coinex(Exchange, ImplicitAPI):
                 raise BadRequest(self.id + ' createOrder() requires an account_id parameter for margin orders')
             request['account_id'] = accountId
         params = self.omit(params, ['reduceOnly', 'positionId', 'timeInForce', 'postOnly', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice'])
-        response = getattr(self, method)(self.extend(request, params))
+        return self.extend(request, params)
+
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+        """
+        create a trade order
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http017_put_limit
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http018_put_market
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http019_put_limit_stop
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http020_put_market_stop
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http031_market_close
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http030_limit_close
+        :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 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 quote currency, ignored in market orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.triggerPrice]: price to trigger stop orders
+        :param float [params.stopLossPrice]: price to trigger stop loss orders
+        :param float [params.takeProfitPrice]: price to trigger take profit orders
+        :param str [params.timeInForce]: 'GTC', 'IOC', 'FOK', 'PO'
+        :param boolean [params.postOnly]: set to True if you wish to make a post only order
+        :param boolean [params.reduceOnly]: *contract only* indicates if self order is to reduce the size of a position
+        :param int [params.position_id]: *required for reduce only orders* the position id to reduce
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        reduceOnly = self.safe_value(params, 'reduceOnly')
+        triggerPrice = self.safe_number_2(params, 'stopPrice', 'triggerPrice')
+        stopLossTriggerPrice = self.safe_number(params, 'stopLossPrice')
+        takeProfitTriggerPrice = self.safe_number(params, 'takeProfitPrice')
+        isTriggerOrder = triggerPrice is not None
+        isStopLossTriggerOrder = stopLossTriggerPrice is not None
+        isTakeProfitTriggerOrder = takeProfitTriggerPrice is not None
+        isStopLossOrTakeProfitTrigger = isStopLossTriggerOrder or isTakeProfitTriggerOrder
+        request = self.create_order_request(symbol, type, side, amount, price, params)
+        response = None
+        if market['spot']:
+            if isTriggerOrder:
+                if type == 'limit':
+                    response = self.privatePostOrderStopLimit(request)
+                else:
+                    response = self.privatePostOrderStopMarket(request)
+            else:
+                if type == 'limit':
+                    response = self.privatePostOrderLimit(request)
+                else:
+                    response = self.privatePostOrderMarket(request)
+        else:
+            if isTriggerOrder:
+                if type == 'limit':
+                    response = self.perpetualPrivatePostOrderPutStopLimit(request)
+                else:
+                    response = self.perpetualPrivatePostOrderPutStopMarket(request)
+            elif isStopLossOrTakeProfitTrigger:
+                if isStopLossTriggerOrder:
+                    response = self.perpetualPrivatePostPositionStopLoss(request)
+                elif isTakeProfitTriggerOrder:
+                    response = self.perpetualPrivatePostPositionTakeProfit(request)
+            else:
+                if reduceOnly:
+                    if type == 'limit':
+                        response = self.perpetualPrivatePostOrderCloseLimit(request)
+                    else:
+                        response = self.perpetualPrivatePostOrderCloseMarket(request)
+                else:
+                    if type == 'limit':
+                        response = self.perpetualPrivatePostOrderPutLimit(request)
+                    else:
+                        response = self.perpetualPrivatePostOrderPutMarket(request)
         #
         # Spot and Margin
         #
@@ -2017,9 +2090,225 @@ class coinex(Exchange, ImplicitAPI):
         #
         #     {"code":0,"data":{"status":"success"},"message":"OK"}
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_value(response, 'data', {})
         return self.parse_order(data, market)
 
+    def create_orders(self, orders: List[OrderRequest], params={}) -> List[Order]:
+        """
+        create a list of trade orders(all orders should be of the same symbol)
+        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade002_batch_limit_orders
+        :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
+        :param dict [params]: extra parameters specific to the api endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        ordersRequests = []
+        symbol = None
+        for i in range(0, len(orders)):
+            rawOrder = orders[i]
+            marketId = self.safe_string(rawOrder, 'symbol')
+            if symbol is None:
+                symbol = marketId
+            else:
+                if symbol != marketId:
+                    raise BadRequest(self.id + ' createOrders() requires all orders to have the same symbol')
+            type = self.safe_string(rawOrder, 'type')
+            side = self.safe_string(rawOrder, 'side')
+            amount = self.safe_value(rawOrder, 'amount')
+            price = self.safe_value(rawOrder, 'price')
+            orderParams = self.safe_value(rawOrder, 'params', {})
+            if type != 'limit':
+                raise NotSupported(self.id + ' createOrders() does not support ' + type + ' orders, only limit orders are accepted')
+            orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams)
+            ordersRequests.append(orderRequest)
+        market = self.market(symbol)
+        if not market['spot']:
+            raise NotSupported(self.id + ' createOrders() does not support ' + market['type'] + ' orders, only spot orders are accepted')
+        request = {
+            'market': market['id'],
+            'batch_orders': self.json(ordersRequests),
+        }
+        response = self.privatePostOrderLimitBatch(request)
+        #
+        #     {
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "code": 0,
+        #                 "data": {
+        #                     "amount": "0.0005",
+        #                     "asset_fee": "0",
+        #                     "avg_price": "0.00",
+        #                     "client_id": "x-167673045-d34bfb41242d8fd1",
+        #                     "create_time": 1701229157,
+        #                     "deal_amount": "0",
+        #                     "deal_fee": "0",
+        #                     "deal_money": "0",
+        #                     "fee_asset": null,
+        #                     "fee_discount": "1",
+        #                     "finished_time": null,
+        #                     "id": 107745856676,
+        #                     "left": "0.0005",
+        #                     "maker_fee_rate": "0.002",
+        #                     "market": "BTCUSDT",
+        #                     "money_fee": "0",
+        #                     "order_type": "limit",
+        #                     "price": "23000",
+        #                     "source_id": "",
+        #                     "status": "not_deal",
+        #                     "stock_fee": "0",
+        #                     "taker_fee_rate": "0.002",
+        #                     "type": "buy"
+        #                 },
+        #                 "message": "OK"
+        #             },
+        #         ],
+        #         "message": "Success"
+        #     }
+        #
+        data = self.safe_value(response, 'data', [])
+        results = []
+        for i in range(0, len(data)):
+            entry = data[i]
+            status = None
+            code = self.safe_integer(entry, 'code')
+            if code is not None:
+                if code != 0:
+                    status = 'rejected'
+                else:
+                    status = 'open'
+            item = self.safe_value(entry, 'data', {})
+            item['status'] = status
+            order = self.parse_order(item, market)
+            results.append(order)
+        return results
+
+    def cancel_orders(self, ids, symbol: Str = None, params={}):
+        """
+        cancel multiple orders
+        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade016_batch_cancel_order
+        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http021-0_cancel_order_batch
+        :param str[] ids: order ids
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        if symbol is None:
+            raise ArgumentsRequired(self.id + ' cancelOrders() requires a symbol argument')
+        self.load_markets()
+        market = self.market(symbol)
+        request = {
+            'market': market['id'],
+        }
+        idsString = ','.join(ids)
+        response = None
+        if market['spot']:
+            request['batch_ids'] = idsString
+            response = self.privateDeleteOrderPendingBatch(self.extend(request, params))
+        else:
+            request['order_ids'] = idsString
+            response = self.perpetualPrivatePostOrderCancelBatch(self.extend(request, params))
+        #
+        # spot
+        #
+        #     {
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "code": 0,
+        #                 "data": {
+        #                     "account_id": 0,
+        #                     "amount": "0.0005",
+        #                     "asset_fee": "0",
+        #                     "avg_price": "0.00",
+        #                     "client_id": "x-167673045-d4e03c38f4d19b4e",
+        #                     "create_time": 1701229157,
+        #                     "deal_amount": "0",
+        #                     "deal_fee": "0",
+        #                     "deal_money": "0",
+        #                     "fee_asset": null,
+        #                     "fee_discount": "1",
+        #                     "finished_time": 0,
+        #                     "id": 107745856682,
+        #                     "left": "0",
+        #                     "maker_fee_rate": "0.002",
+        #                     "market": "BTCUSDT",
+        #                     "money_fee": "0",
+        #                     "order_type": "limit",
+        #                     "price": "22000",
+        #                     "status": "not_deal",
+        #                     "stock_fee": "0",
+        #                     "taker_fee_rate": "0.002",
+        #                     "type": "buy"
+        #                 },
+        #                 "message": ""
+        #             },
+        #         ],
+        #         "message": "Success"
+        #     }
+        #
+        # swap
+        #
+        #     {
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "code": 0,
+        #                 "message": "",
+        #                 "order": {
+        #                     "amount": "0.0005",
+        #                     "client_id": "x-167673045-b0cee0c584718b65",
+        #                     "create_time": 1701233683.294231,
+        #                     "deal_asset_fee": "0.00000000000000000000",
+        #                     "deal_fee": "0.00000000000000000000",
+        #                     "deal_profit": "0.00000000000000000000",
+        #                     "deal_stock": "0.00000000000000000000",
+        #                     "effect_type": 1,
+        #                     "fee_asset": "",
+        #                     "fee_discount": "0.00000000000000000000",
+        #                     "last_deal_amount": "0.00000000000000000000",
+        #                     "last_deal_id": 0,
+        #                     "last_deal_price": "0.00000000000000000000",
+        #                     "last_deal_role": 0,
+        #                     "last_deal_time": 0,
+        #                     "last_deal_type": 0,
+        #                     "left": "0.0005",
+        #                     "leverage": "3",
+        #                     "maker_fee": "0.00030",
+        #                     "market": "BTCUSDT",
+        #                     "option": 0,
+        #                     "order_id": 115940476323,
+        #                     "position_id": 0,
+        #                     "position_type": 2,
+        #                     "price": "25000.00",
+        #                     "side": 2,
+        #                     "source": "api.v1",
+        #                     "stop_id": 0,
+        #                     "stop_loss_price": "0.00000000000000000000",
+        #                     "stop_loss_type": 0,
+        #                     "take_profit_price": "0.00000000000000000000",
+        #                     "take_profit_type": 0,
+        #                     "taker_fee": "0.00050",
+        #                     "target": 0,
+        #                     "type": 1,
+        #                     "update_time": 1701233721.718884,
+        #                     "user_id": 3620173
+        #                 }
+        #             },
+        #         ],
+        #         "message": "OK"
+        #     }
+        #
+        data = self.safe_value(response, 'data', [])
+        results = []
+        for i in range(0, len(data)):
+            entry = data[i]
+            dataRequest = 'data' if market['spot'] else 'order'
+            item = self.safe_value(entry, dataRequest, {})
+            order = self.parse_order(item, market)
+            results.append(order)
+        return results
+
     def edit_order(self, id, symbol, type, side, amount=None, price=None, params={}):
         """
         edit a trade order

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.1.69'
+__version__ = '4.1.70'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -55,8 +55,8 @@ class binance(ccxt.async_support.binance):
                 },
                 'api': {
                     'ws': {
-                        'spot': 'wss://stream.binance.com:9443/ws',
-                        'margin': 'wss://stream.binance.com:9443/ws',
+                        'spot': 'wss://stream.binance.com/ws',
+                        'margin': 'wss://stream.binance.com/ws',
                         'future': 'wss://fstream.binance.com/ws',
                         'delivery': 'wss://dstream.binance.com/ws',
                         'ws': 'wss://ws-api.binance.com:443/ws-api/v3',

{ccxt-4.1.69.dist-info → ccxt-4.1.70.dist-info}/METADATA

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

{ccxt-4.1.69.dist-info → ccxt-4.1.70.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ccxt/__init__.py,sha256=l5BBrH7XKIChtMjSh_t6W6_gkI0uFVstgpPipSl3PTg,15177
+ccxt/__init__.py,sha256=O0y7MONwUqyB-0mNdz5qSEJv4PRykG9GoGfWaEMTK10,15177
 ccxt/ace.py,sha256=BWWFoSfDar1k8SuqIuupgs8BLfZyu8w6BEdGZxWVR7M,41264
 ccxt/alpaca.py,sha256=4MSi6SDyes3lNvGKmWgXWEIB2CacwfbVdhLxchv3m7k,45944
 ccxt/ascendex.py,sha256=EQjZX2RRa2vBCIPnKsfaRpam9MCEGHe_zWOwMkGJ_b0,143331
@@ -41,7 +41,7 @@ ccxt/coinbase.py,sha256=yAJr50ql9Jg84dubNvHxdjRRXbTwFYIzwCvezeeDJzE,143324
 ccxt/coinbaseprime.py,sha256=Ygvljulxb2uKdei5yimCj1LMjLlUJNvP-G7ns1HpUFk,1219
 ccxt/coinbasepro.py,sha256=gpe6UVg4pDDpvzjVGE_fKeoDmkdIyzNucANptY9FeH8,80087
 ccxt/coincheck.py,sha256=91mcnxBYEpaEjqb-q_jvWSfient50_dLncnpXISNrdA,34543
-ccxt/coinex.py,sha256=GTZSSeN-RFBknqqCK0GD9Q-2wBcOv1k5HrMMUe4HoYI,201142
+ccxt/coinex.py,sha256=DxautcoxydR21ywuliVwn1kNKu0xYbBKLNmNrMoz9I8,214363
 ccxt/coinlist.py,sha256=WxUtdebmVD5so6vtldeHXUhpuh_cxGt3EKGu4vKPBFM,102150
 ccxt/coinmate.py,sha256=1Qd8MQ0gxL4ppjxkuwIP-TSiQJWNK6dhEFZA8tDzoVg,39870
 ccxt/coinone.py,sha256=4YZVII8t-87KJ6PQ85qxVNzXnTe7Ga-2jOaBpJ9YC1g,35624
@@ -205,7 +205,7 @@ ccxt/abstract/woo.py,sha256=Z3ua45hKE0Tf9rtfSEYYgGEztaTO1Ri3mKl_hIo3OHs,8768
 ccxt/abstract/yobit.py,sha256=8ycfCO8ORFly9hc0Aa47sZyX4_ZKPXS9h9yJzI-uQ7Q,1339
 ccxt/abstract/zaif.py,sha256=m15WHdl3gYy0GOXNZ8NEH8eE7sVh8c0T_ITNuU8vXeU,3935
 ccxt/abstract/zonda.py,sha256=aSfewvRojzmuymX6QbOnDR8v9VFqWTULMHX9Y7kKD1M,5820
-ccxt/async_support/__init__.py,sha256=EdbggL9fiyqdcYHBrPmyAWEGeQ0bi1I6H8K6wD7DmqQ,14900
+ccxt/async_support/__init__.py,sha256=3GyP00xgtbGUi-ipamiwlIFRYX729fSIGxjPuc0hmvM,14900
 ccxt/async_support/ace.py,sha256=H3BMrCEUPt86k1nFZnuTbcGPtgzzTii5V0OQeRK8x4U,41488
 ccxt/async_support/alpaca.py,sha256=q8s3omyklOv0grJ6kDJxmPkt9kqKHwes_fuYkP_Nhf8,46156
 ccxt/async_support/ascendex.py,sha256=GHeezJpE30VFKhVC-AKtLM5GJsGav0nNgCrvlRkN5gE,144071
@@ -248,7 +248,7 @@ ccxt/async_support/coinbase.py,sha256=-GQCGYqy2YX36VTpIcBJZZEajnHBtSfnsTxp4EzysZ
 ccxt/async_support/coinbaseprime.py,sha256=M5Ez1DsFcW3-vJ-4QoZzwYBAKjAAtJnJpkfnV4sWAIc,1233
 ccxt/async_support/coinbasepro.py,sha256=yfHm6Hx0afMSogFlNLtKPc38YPip1l211285XYewRfk,80611
 ccxt/async_support/coincheck.py,sha256=tfdumxzqeQxLYtaEsYv1EtkVHySxF_6-79EftZvQcZQ,34749
-ccxt/async_support/coinex.py,sha256=pCzHZqt7l4aKJVa21Ymu-b-4asKggD2vdVfpfFrDCD4,202070
+ccxt/async_support/coinex.py,sha256=GqoGMD1pWqh7UQJvDXX_Hn8nSwjBu93QuP_AoJQbH2I,215399
 ccxt/async_support/coinlist.py,sha256=l5ufcRAEA7la3Xpliuwocvv09wDF-51u5hZTBI5Gvso,102638
 ccxt/async_support/coinmate.py,sha256=hGCkulm5wiQBNW8ZbMXRunEMruQ7rv2rqxQBH_fGRn4,40118
 ccxt/async_support/coinone.py,sha256=W3Bx0IZ92dhtc5Ugx9n3PSyjhx7flBjcN_FIPy0auOc,35848
@@ -312,7 +312,7 @@ ccxt/async_support/yobit.py,sha256=Sr_o0G6zpBB2YHRClnD6FUzPBW74cukKl-cvjILW7YQ,5
 ccxt/async_support/zaif.py,sha256=-YCjZLw87m9m-JXxUCr6AEC8KfnNX8b7IVSv5caW3QQ,28158
 ccxt/async_support/zonda.py,sha256=DSrmvHZ4_uAwRzQQl_C6KGy3UK2kaTjJVohNg0SNbPQ,80592
 ccxt/async_support/base/__init__.py,sha256=aVYSsFi--b4InRs9zDN_wtCpj8odosAB726JdUHavrk,67
-ccxt/async_support/base/exchange.py,sha256=J6lXidpTChWowrzfVLjVSTqFe7gtbw4wEahPXOVgYN8,67412
+ccxt/async_support/base/exchange.py,sha256=Ct3l0hbkEOKf6uIQU6BFPTjNdaZFuBjgiottvj5t2ZY,67412
 ccxt/async_support/base/throttler.py,sha256=tvDVcdRUVYi8fZRlEcnqtgzcgB_KMUMRs5Pu8tuU-tU,1847
 ccxt/async_support/base/ws/__init__.py,sha256=uockzpLuwntKGZbs5EOWFe-Zg-k6Cj7GhNJLc_RX0so,1791
 ccxt/async_support/base/ws/aiohttp_client.py,sha256=_qjsl_x-rd88QmzQeGVWovMDK0XoD3f4m5GHqxZRajs,5203
@@ -326,14 +326,14 @@ ccxt/async_support/base/ws/order_book_side.py,sha256=Pxrq22nCODckJ6G1OXkYEmUunIu
 ccxt/base/__init__.py,sha256=eTx1OE3HJjspFUQjGm6LBhaQiMKJnXjkdP-JUXknyQ0,1320
 ccxt/base/decimal_to_precision.py,sha256=fgWRBzRTtsf3r2INyS4f7WHlzgjB5YM1ekiwqD21aac,6634
 ccxt/base/errors.py,sha256=1C38u76jlNGq06N_uwfw8b8FZHK8_3_90wM1rKfU_Rg,3878
-ccxt/base/exchange.py,sha256=1ONGtgF68tQBJQyv9vN09EwT-9fO4NvtedrZkSsr2HM,213806
+ccxt/base/exchange.py,sha256=Juw-n3IJOp_v9FlTf0qwDtirtszQs9o7lhvSAbnubDA,213806
 ccxt/base/precise.py,sha256=_xfu54sV0vWNnOfGTKRFykeuWP8mn4K1m9lk1tcllX4,8565
 ccxt/base/types.py,sha256=LN8MOE5oGr8ATL6VNuMAnE9f6o2fZ9zbeLLyXLndlEk,5528
-ccxt/pro/__init__.py,sha256=LDQn4Y7HMAou3Te_kLhlw4UfYGXzxR8VoBPrRwFfUbI,6376
+ccxt/pro/__init__.py,sha256=cl52DqUszddmvLAw6R-9CQ_bN1cM_2R1qLlOC0jesg4,6376
 ccxt/pro/alpaca.py,sha256=fy1mLmw4yac7DKvGPpaqEBuA8briQqaRwPbvKsKUJwY,26974
 ccxt/pro/ascendex.py,sha256=GqH6QOPZfQtbAYhdB65zJ9iIMQDGsXugSyAPUsKXk40,34730
 ccxt/pro/bequant.py,sha256=3IeQ0vPg-eVqPiGMfX7yqH9qtXKm1ZqocQDeLwpA8EE,1093
-ccxt/pro/binance.py,sha256=A4ct4PIxsy7brzg55XRekdGAwQgrMx8QYTLSXoPj2jY,125645
+ccxt/pro/binance.py,sha256=O7skVuVN1J9bVEJgDogX2JDjXSbz8k9HQFkQQR6a7lc,125635
 ccxt/pro/binancecoinm.py,sha256=vu5SUgP70T1Dax-Am3rch7ZldGrmUwxr_rI51Y38xjw,724
 ccxt/pro/binanceus.py,sha256=xKL-1cOHyqlLTwLGg-DPf6g3JMM1oU2Kv708FiGJwrY,2016
 ccxt/pro/binanceusdm.py,sha256=S0eT662O2ReplsihWk42nhJWqw1XsODpeDQa9eFVVt8,1357
@@ -439,7 +439,7 @@ ccxt/test/base/test_ticker.py,sha256=5J8KHgFhJLgcWyFwt3bhJ-tldMho3K7LD5yJnnUyrT4
 ccxt/test/base/test_trade.py,sha256=AN3emAdEPhdFyunap43cKqZTS1cbaShZKTjYue67jEU,2297
 ccxt/test/base/test_trading_fee.py,sha256=2_WCp3qJ2UpraQQoGFlGJYwHD-T0Bm5W7KIw4zpFvSM,1068
 ccxt/test/base/test_transaction.py,sha256=BTbB4UHHXkrvYgwbrhh867nVRlevmIkIrz1W_odlQJI,1434
-ccxt-4.1.69.dist-info/METADATA,sha256=rguuG5qqoZ9QUhdbUEd3axylukbGXIfoOJMxmZlzDiw,106775
-ccxt-4.1.69.dist-info/WHEEL,sha256=P2T-6epvtXQ2cBOE_U1K4_noqlJFN3tj15djMgEu4NM,110
-ccxt-4.1.69.dist-info/top_level.txt,sha256=CkQDuCTDKNcImPV60t36G6MdYfxsAPNiSaEwifVoVMo,5
-ccxt-4.1.69.dist-info/RECORD,,
+ccxt-4.1.70.dist-info/METADATA,sha256=KucSPgIlXfXu9FLUC64s2HfQPymRSJ5rKCFTxpzDfoo,106775
+ccxt-4.1.70.dist-info/WHEEL,sha256=P2T-6epvtXQ2cBOE_U1K4_noqlJFN3tj15djMgEu4NM,110
+ccxt-4.1.70.dist-info/top_level.txt,sha256=CkQDuCTDKNcImPV60t36G6MdYfxsAPNiSaEwifVoVMo,5
+ccxt-4.1.70.dist-info/RECORD,,