ccxt 4.3.8__py2.py3-none-any.whl → 4.3.9__py2.py3-none-any.whl

ccxt/async_support/coinex.py

@@ -1689,7 +1689,7 @@ class coinex(Exchange, ImplicitAPI):
         #         "client_id": "",
         #     }
         #
-        # Spot and Margin createOrder, createOrders, cancelOrder, cancelOrders, fetchOrder
+        # Spot and Margin cancelOrder, cancelOrders, fetchOrder
         #
         #      {
         #          "amount":"1.5",
@@ -1717,7 +1717,7 @@ class coinex(Exchange, ImplicitAPI):
         #          "client_id": "",
         #      }
         #
-        # Swap createOrder, cancelOrder, fetchOrder
+        # Swap cancelOrder, fetchOrder
         #
         #     {
         #         "amount": "0.0005",
@@ -1754,10 +1754,6 @@ class coinex(Exchange, ImplicitAPI):
         #         "user_id": 3620173
         #     }
         #
-        # Stop order createOrder
-        #
-        #     {"status":"success"}
-        #
         # Swap Stop cancelOrder, fetchOrder
         #
         #     {
@@ -1930,43 +1926,148 @@ class coinex(Exchange, ImplicitAPI):
         #         "user_id": 3620173
         #     }
         #
+        # Spot and Margin createOrder, createOrders v2
+        #
+        #     {
+        #         "amount": "0.0001",
+        #         "base_fee": "0",
+        #         "ccy": "BTC",
+        #         "client_id": "x-167673045-a0a3c6461459a801",
+        #         "created_at": 1714114386250,
+        #         "discount_fee": "0",
+        #         "filled_amount": "0",
+        #         "filled_value": "0",
+        #         "last_fill_amount": "0",
+        #         "last_fill_price": "0",
+        #         "maker_fee_rate": "0.002",
+        #         "market": "BTCUSDT",
+        #         "market_type": "SPOT",
+        #         "order_id": 117178743547,
+        #         "price": "61000",
+        #         "quote_fee": "0",
+        #         "side": "buy",
+        #         "taker_fee_rate": "0.002",
+        #         "type": "limit",
+        #         "unfilled_amount": "0.0001",
+        #         "updated_at": 1714114386250
+        #     }
+        #
+        # Spot, Margin and Swap trigger createOrder, createOrders v2
+        #
+        #     {
+        #         "stop_id": 117180138153
+        #     }
+        #
+        # Swap createOrder, createOrders v2
+        #
+        #     {
+        #         "amount": "0.0001",
+        #         "client_id": "x-167673045-1471b81d747080a0",
+        #         "created_at": 1714116769986,
+        #         "fee": "0",
+        #         "fee_ccy": "USDT",
+        #         "filled_amount": "0",
+        #         "filled_value": "0",
+        #         "last_filled_amount": "0",
+        #         "last_filled_price": "0",
+        #         "maker_fee_rate": "0.0003",
+        #         "market": "BTCUSDT",
+        #         "market_type": "FUTURES",
+        #         "order_id": 136913377780,
+        #         "price": "61000.42",
+        #         "realized_pnl": "0",
+        #         "side": "buy",
+        #         "taker_fee_rate": "0.0005",
+        #         "type": "limit",
+        #         "unfilled_amount": "0.0001",
+        #         "updated_at": 1714116769986
+        #     }
+        #
+        # Swap stopLossPrice and takeProfitPrice createOrder v2
+        #
+        #     {
+        #         "adl_level": 1,
+        #         "ath_margin_size": "2.14586666",
+        #         "ath_position_amount": "0.0001",
+        #         "avg_entry_price": "64376",
+        #         "bkr_price": "0",
+        #         "close_avbl": "0.0001",
+        #         "cml_position_value": "6.4376",
+        #         "created_at": 1714119054558,
+        #         "leverage": "3",
+        #         "liq_price": "0",
+        #         "maintenance_margin_rate": "0.005",
+        #         "maintenance_margin_value": "0.03218632",
+        #         "margin_avbl": "2.14586666",
+        #         "margin_mode": "cross",
+        #         "market": "BTCUSDT",
+        #         "market_type": "FUTURES",
+        #         "max_position_value": "6.4376",
+        #         "open_interest": "0.0001",
+        #         "position_id": 303884204,
+        #         "position_margin_rate": "3.10624785634397912265",
+        #         "realized_pnl": "-0.0032188",
+        #         "settle_price": "64376",
+        #         "settle_value": "6.4376",
+        #         "side": "long",
+        #         "stop_loss_price": "62000",
+        #         "stop_loss_type": "latest_price",
+        #         "take_profit_price": "0",
+        #         "take_profit_type": "",
+        #         "unrealized_pnl": "0",
+        #         "updated_at": 1714119054559
+        #     }
+        #
         rawStatus = self.safe_string(order, 'status')
         timestamp = self.safe_timestamp(order, 'create_time')
+        if timestamp is None:
+            timestamp = self.safe_integer(order, 'created_at')
+        update = self.safe_timestamp(order, 'update_time')
+        if update is None:
+            update = self.safe_integer(order, 'updated_at')
         marketId = self.safe_string(order, 'market')
         defaultType = self.safe_string(self.options, 'defaultType')
         orderType = 'swap' if ('source' in order) else defaultType
         market = self.safe_market(marketId, market, None, orderType)
-        feeCurrencyId = self.safe_string(order, 'fee_asset')
+        feeCurrencyId = self.safe_string_2(order, 'fee_asset', 'fee_ccy')
         feeCurrency = self.safe_currency_code(feeCurrencyId)
         if feeCurrency is None:
             feeCurrency = market['quote']
-        rawSide = self.safe_integer(order, 'side')
+        rawIntegerSide = self.safe_integer(order, 'side')
+        rawStringSide = self.safe_string(order, 'side')
         side: Str = None
-        if rawSide == 1:
+        if rawIntegerSide == 1:
             side = 'sell'
-        elif rawSide == 2:
+        elif rawIntegerSide == 2:
             side = 'buy'
+        elif (rawStringSide == 'buy') or (rawStringSide == 'sell'):
+            side = rawStringSide
         else:
             side = self.safe_string(order, 'type')
         rawType = self.safe_string(order, 'order_type')
         type: Str = None
         if rawType is None:
             typeInteger = self.safe_integer(order, 'type')
+            typeString = self.safe_string(order, 'type')
             if typeInteger == 1:
                 type = 'limit'
             elif typeInteger == 2:
                 type = 'market'
+            elif (typeString == 'limit') or (typeString == 'market'):
+                type = typeString
+            elif typeString == 'maker_only':
+                type = 'limit'
         else:
             type = rawType
         clientOrderId = self.safe_string(order, 'client_id')
         if clientOrderId == '':
             clientOrderId = None
         return self.safe_order({
-            'id': self.safe_string_2(order, 'id', 'order_id'),
+            'id': self.safe_string_n(order, ['id', 'order_id', 'stop_id']),
             'clientOrderId': clientOrderId,
             'datetime': self.iso8601(timestamp),
             'timestamp': timestamp,
-            'lastTradeTimestamp': self.safe_timestamp(order, 'update_time'),
+            'lastTradeTimestamp': update,
             'status': self.parse_order_status(rawStatus),
             'symbol': market['symbol'],
             'type': type,
@@ -1979,15 +2080,15 @@ class coinex(Exchange, ImplicitAPI):
             'triggerPrice': self.safe_string(order, 'stop_price'),
             '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'),
+            'cost': self.safe_string_2(order, 'deal_money', 'filled_value'),
+            'average': self.safe_string_2(order, 'avg_price', 'avg_entry_price'),
             'amount': self.safe_string(order, 'amount'),
-            'filled': self.safe_string(order, 'deal_amount'),
-            'remaining': self.safe_string(order, 'left'),
+            'filled': self.safe_string_2(order, 'deal_amount', 'filled_amount'),
+            'remaining': self.safe_string_2(order, 'left', 'unfilled_amount'),
             'trades': None,
             'fee': {
                 'currency': feeCurrency,
-                'cost': self.safe_string(order, 'deal_fee'),
+                'cost': self.safe_string_n(order, ['deal_fee', 'quote_fee', 'fee']),
             },
             'info': order,
         }, market)
@@ -1996,6 +2097,7 @@ class coinex(Exchange, ImplicitAPI):
         """
         create a market buy order by providing the symbol and cost
         :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade003_market_order
+        :see: https://docs.coinex.com/api/v2/spot/order/http/put-order
         :param str symbol: unified symbol of the market to create an order in
         :param float cost: how much you want to trade in units of the quote currency
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2012,20 +2114,17 @@ class coinex(Exchange, ImplicitAPI):
         market = self.market(symbol)
         swap = market['swap']
         clientOrderId = self.safe_string_2(params, 'client_id', 'clientOrderId')
-        stopPrice = self.safe_value_2(params, 'stopPrice', 'triggerPrice')
-        stopLossPrice = self.safe_value(params, 'stopLossPrice')
-        takeProfitPrice = self.safe_value(params, 'takeProfitPrice')
+        stopPrice = self.safe_string_2(params, 'stopPrice', 'triggerPrice')
+        stopLossPrice = self.safe_string(params, 'stopLossPrice')
+        takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
         option = self.safe_string(params, 'option')
         isMarketOrder = type == 'market'
-        postOnly = self.is_post_only(isMarketOrder, option == 'MAKER_ONLY', params)
-        positionId = self.safe_integer_2(params, 'position_id', 'positionId')  # Required for closing swap positions
-        timeInForceRaw = self.safe_string(params, 'timeInForce')  # Spot: IOC, FOK, PO, GTC, ... NORMAL(default), MAKER_ONLY
-        reduceOnly = self.safe_value(params, 'reduceOnly')
+        postOnly = self.is_post_only(isMarketOrder, option == 'maker_only', params)
+        timeInForceRaw = self.safe_string_upper(params, 'timeInForce')
+        reduceOnly = self.safe_bool(params, 'reduceOnly')
         if reduceOnly:
             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')
         request = {
             'market': market['id'],
         }
@@ -2035,53 +2134,41 @@ class coinex(Exchange, ImplicitAPI):
             request['client_id'] = brokerId + '-' + self.uuid16()
         else:
             request['client_id'] = clientOrderId
+        if (stopLossPrice is None) and (takeProfitPrice is None):
+            if not reduceOnly:
+                request['side'] = side
+            requestType = type
+            if postOnly:
+                requestType = 'maker_only'
+            elif timeInForceRaw is not None:
+                if timeInForceRaw == 'IOC':
+                    requestType = 'ioc'
+                elif timeInForceRaw == 'FOK':
+                    requestType = 'fok'
+            if not isMarketOrder:
+                request['price'] = self.price_to_precision(symbol, price)
+            request['type'] = requestType
         if swap:
+            request['market_type'] = 'FUTURES'
             if stopLossPrice or takeProfitPrice:
-                request['stop_type'] = self.safe_integer(params, 'stop_type', 1)  # 1: triggered by the latest transaction, 2: mark price, 3: index price
-                if positionId is None:
-                    raise ArgumentsRequired(self.id + ' createOrder() requires a position_id parameter for stop loss and take profit orders')
-                request['position_id'] = positionId
                 if stopLossPrice:
                     request['stop_loss_price'] = self.price_to_precision(symbol, stopLossPrice)
+                    request['stop_loss_type'] = self.safe_string(params, 'stop_type', 'latest_price')
                 elif takeProfitPrice:
                     request['take_profit_price'] = self.price_to_precision(symbol, takeProfitPrice)
+                    request['take_profit_type'] = self.safe_string(params, 'stop_type', 'latest_price')
             else:
-                requestSide = 2 if (side == 'buy') else 1
+                request['amount'] = self.amount_to_precision(symbol, amount)
                 if stopPrice is not None:
-                    request['stop_price'] = self.price_to_precision(symbol, stopPrice)
-                    request['stop_type'] = self.safe_integer(params, 'stop_type', 1)  # 1: triggered by the latest transaction, 2: mark price, 3: index price
-                    request['amount'] = self.amount_to_precision(symbol, amount)
-                    request['side'] = requestSide
-                    if type == 'limit':
-                        request['price'] = self.price_to_precision(symbol, price)
-                    request['amount'] = self.amount_to_precision(symbol, amount)
-                timeInForce = None
-                if (type != 'market') or (stopPrice is not None):
-                    if postOnly:
-                        request['option'] = 1
-                    elif timeInForceRaw is not None:
-                        if timeInForceRaw == 'IOC':
-                            timeInForce = 2
-                        elif timeInForceRaw == 'FOK':
-                            timeInForce = 3
-                        else:
-                            timeInForce = 1
-                        request['effect_type'] = timeInForce  # exchange takes 'IOC' and 'FOK'
-                if type == 'limit' and stopPrice is None:
-                    if reduceOnly:
-                        request['position_id'] = positionId
-                    else:
-                        request['side'] = requestSide
-                    request['price'] = self.price_to_precision(symbol, price)
-                    request['amount'] = self.amount_to_precision(symbol, amount)
-                elif type == 'market' and stopPrice is None:
-                    if reduceOnly:
-                        request['position_id'] = positionId
-                    else:
-                        request['side'] = requestSide
-                        request['amount'] = self.amount_to_precision(symbol, amount)
+                    request['trigger_price'] = self.price_to_precision(symbol, stopPrice)
+                    request['trigger_price_type'] = self.safe_string(params, 'stop_type', 'latest_price')
         else:
-            request['type'] = side
+            marginMode = None
+            marginMode, params = self.handle_margin_mode_and_params('createOrder', params)
+            if marginMode is not None:
+                request['market_type'] = 'MARGIN'
+            else:
+                request['market_type'] = 'SPOT'
             if (type == 'market') and (side == 'buy'):
                 createMarketBuyOrderRequiresPrice = True
                 createMarketBuyOrderRequiresPrice, params = self.handle_option_and_params(params, 'createOrder', 'createMarketBuyOrderRequiresPrice', True)
@@ -2100,44 +2187,21 @@ class coinex(Exchange, ImplicitAPI):
                     request['amount'] = self.cost_to_precision(symbol, amount)
             else:
                 request['amount'] = self.amount_to_precision(symbol, amount)
-            if (type == 'limit') or (type == 'ioc'):
-                request['price'] = self.price_to_precision(symbol, price)
             if stopPrice is not None:
-                request['stop_price'] = self.price_to_precision(symbol, stopPrice)
-            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:
-                    if (postOnly or (timeInForceRaw != 'IOC')) and ((type == 'limit') and (stopPrice is not None)):
-                        raise InvalidOrder(self.id + ' createOrder() only supports the IOC option for stop-limit orders')
-                    if postOnly:
-                        request['option'] = 'MAKER_ONLY'
-                    else:
-                        if timeInForceRaw is not None:
-                            request['option'] = timeInForceRaw  # exchange takes 'IOC' and 'FOK'
-        accountId = self.safe_integer(params, 'account_id')
-        marginMode = None
-        marginMode, params = self.handle_margin_mode_and_params('createOrder', params)
-        if marginMode is not None:
-            if accountId is None:
-                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'])
+                request['trigger_price'] = self.price_to_precision(symbol, stopPrice)
+        params = self.omit(params, ['reduceOnly', 'timeInForce', 'postOnly', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice'])
         return self.extend(request, params)
 
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """
         create a trade order
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade001_limit_order
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade003_market_order
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade004_IOC_order
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade005_stop_limit_order
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot003_trade006_stop_market_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
+        :see: https://docs.coinex.com/api/v2/spot/order/http/put-order
+        :see: https://docs.coinex.com/api/v2/spot/order/http/put-stop-order
+        :see: https://docs.coinex.com/api/v2/futures/order/http/put-order
+        :see: https://docs.coinex.com/api/v2/futures/order/http/put-stop-order
+        :see: https://docs.coinex.com/api/v2/futures/position/http/close-position
+        :see: https://docs.coinex.com/api/v2/futures/position/http/set-position-stop-loss
+        :see: https://docs.coinex.com/api/v2/futures/position/http/set-position-take-profit
         :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'
@@ -2150,15 +2214,14 @@ class coinex(Exchange, ImplicitAPI):
         :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')
+        reduceOnly = self.safe_bool(params, 'reduceOnly')
+        triggerPrice = self.safe_string_2(params, 'stopPrice', 'triggerPrice')
+        stopLossTriggerPrice = self.safe_string(params, 'stopLossPrice')
+        takeProfitTriggerPrice = self.safe_string(params, 'takeProfitPrice')
         isTriggerOrder = triggerPrice is not None
         isStopLossTriggerOrder = stopLossTriggerPrice is not None
         isTakeProfitTriggerOrder = takeProfitTriggerPrice is not None
@@ -2167,121 +2230,211 @@ class coinex(Exchange, ImplicitAPI):
         response = None
         if market['spot']:
             if isTriggerOrder:
-                if type == 'limit':
-                    response = await self.v1PrivatePostOrderStopLimit(request)
-                else:
-                    response = await self.v1PrivatePostOrderStopMarket(request)
+                response = await self.v2PrivatePostSpotStopOrder(request)
+                #
+                #     {
+                #         "code": 0,
+                #         "data": {
+                #             "stop_id": 117180138153
+                #         },
+                #         "message": "OK"
+                #     }
+                #
             else:
-                if type == 'limit':
-                    response = await self.v1PrivatePostOrderLimit(request)
-                else:
-                    response = await self.v1PrivatePostOrderMarket(request)
+                response = await self.v2PrivatePostSpotOrder(request)
+                #
+                #     {
+                #         "code": 0,
+                #         "data": {
+                #             "amount": "0.0001",
+                #             "base_fee": "0",
+                #             "ccy": "BTC",
+                #             "client_id": "x-167673045-a0a3c6461459a801",
+                #             "created_at": 1714114386250,
+                #             "discount_fee": "0",
+                #             "filled_amount": "0",
+                #             "filled_value": "0",
+                #             "last_fill_amount": "0",
+                #             "last_fill_price": "0",
+                #             "maker_fee_rate": "0.002",
+                #             "market": "BTCUSDT",
+                #             "market_type": "SPOT",
+                #             "order_id": 117178743547,
+                #             "price": "61000",
+                #             "quote_fee": "0",
+                #             "side": "buy",
+                #             "taker_fee_rate": "0.002",
+                #             "type": "limit",
+                #             "unfilled_amount": "0.0001",
+                #             "updated_at": 1714114386250
+                #         },
+                #         "message": "OK"
+                #     }
+                #
         else:
             if isTriggerOrder:
-                if type == 'limit':
-                    response = await self.v1PerpetualPrivatePostOrderPutStopLimit(request)
-                else:
-                    response = await self.v1PerpetualPrivatePostOrderPutStopMarket(request)
+                response = await self.v2PrivatePostFuturesStopOrder(request)
+                #
+                #     {
+                #         "code": 0,
+                #         "data": {
+                #             "stop_id": 136915460994
+                #         },
+                #         "message": "OK"
+                #     }
+                #
             elif isStopLossOrTakeProfitTrigger:
                 if isStopLossTriggerOrder:
-                    response = await self.v1PerpetualPrivatePostPositionStopLoss(request)
+                    response = await self.v2PrivatePostFuturesSetPositionStopLoss(request)
+                    #
+                    #     {
+                    #         "code": 0,
+                    #         "data": {
+                    #             "adl_level": 1,
+                    #             "ath_margin_size": "2.14586666",
+                    #             "ath_position_amount": "0.0001",
+                    #             "avg_entry_price": "64376",
+                    #             "bkr_price": "0",
+                    #             "close_avbl": "0.0001",
+                    #             "cml_position_value": "6.4376",
+                    #             "created_at": 1714119054558,
+                    #             "leverage": "3",
+                    #             "liq_price": "0",
+                    #             "maintenance_margin_rate": "0.005",
+                    #             "maintenance_margin_value": "0.03218632",
+                    #             "margin_avbl": "2.14586666",
+                    #             "margin_mode": "cross",
+                    #             "market": "BTCUSDT",
+                    #             "market_type": "FUTURES",
+                    #             "max_position_value": "6.4376",
+                    #             "open_interest": "0.0001",
+                    #             "position_id": 303884204,
+                    #             "position_margin_rate": "3.10624785634397912265",
+                    #             "realized_pnl": "-0.0032188",
+                    #             "settle_price": "64376",
+                    #             "settle_value": "6.4376",
+                    #             "side": "long",
+                    #             "stop_loss_price": "62000",
+                    #             "stop_loss_type": "latest_price",
+                    #             "take_profit_price": "0",
+                    #             "take_profit_type": "",
+                    #             "unrealized_pnl": "0",
+                    #             "updated_at": 1714119054559
+                    #         },
+                    #         "message": "OK"
+                    #     }
+                    #
                 elif isTakeProfitTriggerOrder:
-                    response = await self.v1PerpetualPrivatePostPositionTakeProfit(request)
+                    response = await self.v2PrivatePostFuturesSetPositionTakeProfit(request)
+                    #
+                    #     {
+                    #         "code": 0,
+                    #         "data": {
+                    #             "adl_level": 1,
+                    #             "ath_margin_size": "2.14586666",
+                    #             "ath_position_amount": "0.0001",
+                    #             "avg_entry_price": "64376",
+                    #             "bkr_price": "0",
+                    #             "close_avbl": "0.0001",
+                    #             "cml_position_value": "6.4376",
+                    #             "created_at": 1714119054558,
+                    #             "leverage": "3",
+                    #             "liq_price": "0",
+                    #             "maintenance_margin_rate": "0.005",
+                    #             "maintenance_margin_value": "0.03218632",
+                    #             "margin_avbl": "2.14586666",
+                    #             "margin_mode": "cross",
+                    #             "market": "BTCUSDT",
+                    #             "market_type": "FUTURES",
+                    #             "max_position_value": "6.4376",
+                    #             "open_interest": "0.0001",
+                    #             "position_id": 303884204,
+                    #             "position_margin_rate": "3.10624785634397912265",
+                    #             "realized_pnl": "-0.0032188",
+                    #             "settle_price": "64376",
+                    #             "settle_value": "6.4376",
+                    #             "side": "long",
+                    #             "stop_loss_price": "62000",
+                    #             "stop_loss_type": "latest_price",
+                    #             "take_profit_price": "70000",
+                    #             "take_profit_type": "latest_price",
+                    #             "unrealized_pnl": "0",
+                    #             "updated_at": 1714119054559
+                    #         },
+                    #         "message": "OK"
+                    #     }
+                    #
             else:
                 if reduceOnly:
-                    if type == 'limit':
-                        response = await self.v1PerpetualPrivatePostOrderCloseLimit(request)
-                    else:
-                        response = await self.v1PerpetualPrivatePostOrderCloseMarket(request)
+                    response = await self.v2PrivatePostFuturesClosePosition(request)
+                    #
+                    #     {
+                    #         "code": 0,
+                    #         "data": {
+                    #             "amount": "0.0001",
+                    #             "client_id": "x-167673045-4f264600c432ac06",
+                    #             "created_at": 1714119323764,
+                    #             "fee": "0.003221",
+                    #             "fee_ccy": "USDT",
+                    #             "filled_amount": "0.0001",
+                    #             "filled_value": "6.442017",
+                    #             "last_filled_amount": "0.0001",
+                    #             "last_filled_price": "64420.17",
+                    #             "maker_fee_rate": "0",
+                    #             "market": "BTCUSDT",
+                    #             "market_type": "FUTURES",
+                    #             "order_id": 136915813578,
+                    #             "price": "0",
+                    #             "realized_pnl": "0.004417",
+                    #             "side": "sell",
+                    #             "taker_fee_rate": "0.0005",
+                    #             "type": "market",
+                    #             "unfilled_amount": "0",
+                    #             "updated_at": 1714119323764
+                    #         },
+                    #         "message": "OK"
+                    #     }
+                    #
                 else:
-                    if type == 'limit':
-                        response = await self.v1PerpetualPrivatePostOrderPutLimit(request)
-                    else:
-                        response = await self.v1PerpetualPrivatePostOrderPutMarket(request)
-        #
-        # Spot and Margin
-        #
-        #     {
-        #         "code": 0,
-        #         "data": {
-        #             "amount": "0.0005",
-        #             "asset_fee": "0",
-        #             "avg_price": "0.00",
-        #             "client_id": "",
-        #             "create_time": 1650951627,
-        #             "deal_amount": "0",
-        #             "deal_fee": "0",
-        #             "deal_money": "0",
-        #             "fee_asset": null,
-        #             "fee_discount": "1",
-        #             "finished_time": null,
-        #             "id": 74510932594,
-        #             "left": "0.0005",
-        #             "maker_fee_rate": "0.002",
-        #             "market": "BTCUSDT",
-        #             "money_fee": "0",
-        #             "order_type": "limit",
-        #             "price": "30000",
-        #             "status": "not_deal",
-        #             "stock_fee": "0",
-        #             "taker_fee_rate": "0.002",
-        #             "type": "buy"
-        #         },
-        #         "message": "Success"
-        #     }
-        #
-        # Swap
-        #
-        #     {
-        #         "code": 0,
-        #         "data": {
-        #             "amount": "0.0005",
-        #             "client_id": "",
-        #             "create_time": 1651004578.618224,
-        #             "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",
-        #             "order_id": 18221659097,
-        #             "position_id": 0,
-        #             "position_type": 1,
-        #             "price": "30000.00",
-        #             "side": 2,
-        #             "source": "api.v1",
-        #             "stop_id": 0,
-        #             "taker_fee": "0.00050",
-        #             "target": 0,
-        #             "type": 1,
-        #             "update_time": 1651004578.618224,
-        #             "user_id": 3620173
-        #         },
-        #         "message": "OK"
-        #     }
-        #
-        # Stop Order
-        #
-        #     {"code":0,"data":{"status":"success"},"message":"OK"}
-        #
+                    response = await self.v2PrivatePostFuturesOrder(request)
+                    #
+                    #     {
+                    #         "code": 0,
+                    #         "data": {
+                    #             "amount": "0.0001",
+                    #             "client_id": "x-167673045-1471b81d747080a0",
+                    #             "created_at": 1714116769986,
+                    #             "fee": "0",
+                    #             "fee_ccy": "USDT",
+                    #             "filled_amount": "0",
+                    #             "filled_value": "0",
+                    #             "last_filled_amount": "0",
+                    #             "last_filled_price": "0",
+                    #             "maker_fee_rate": "0.0003",
+                    #             "market": "BTCUSDT",
+                    #             "market_type": "FUTURES",
+                    #             "order_id": 136913377780,
+                    #             "price": "61000.42",
+                    #             "realized_pnl": "0",
+                    #             "side": "buy",
+                    #             "taker_fee_rate": "0.0005",
+                    #             "type": "limit",
+                    #             "unfilled_amount": "0.0001",
+                    #             "updated_at": 1714116769986
+                    #         },
+                    #         "message": "OK"
+                    #     }
+                    #
         data = self.safe_dict(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
+        :see: https://docs.coinex.com/api/v2/spot/order/http/put-multi-order
+        :see: https://docs.coinex.com/api/v2/spot/order/http/put-multi-stop-order
+        :see: https://docs.coinex.com/api/v2/futures/order/http/put-multi-order
+        :see: https://docs.coinex.com/api/v2/futures/order/http/put-multi-stop-order
         :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>`
@@ -2289,6 +2442,9 @@ class coinex(Exchange, ImplicitAPI):
         await self.load_markets()
         ordersRequests = []
         symbol = None
+        reduceOnly = False
+        isTriggerOrder = False
+        isStopLossOrTakeProfitTrigger = False
         for i in range(0, len(orders)):
             rawOrder = orders[i]
             marketId = self.safe_string(rawOrder, 'symbol')
@@ -2304,54 +2460,138 @@ class coinex(Exchange, ImplicitAPI):
             orderParams = self.safe_value(rawOrder, 'params', {})
             if type != 'limit':
                 raise NotSupported(self.id + ' createOrders() does not support ' + type + ' orders, only limit orders are accepted')
+            reduceOnly = self.safe_value(orderParams, 'reduceOnly')
+            triggerPrice = self.safe_number_2(orderParams, 'stopPrice', 'triggerPrice')
+            stopLossTriggerPrice = self.safe_number(orderParams, 'stopLossPrice')
+            takeProfitTriggerPrice = self.safe_number(orderParams, 'takeProfitPrice')
+            isTriggerOrder = triggerPrice is not None
+            isStopLossTriggerOrder = stopLossTriggerPrice is not None
+            isTakeProfitTriggerOrder = takeProfitTriggerPrice is not None
+            isStopLossOrTakeProfitTrigger = isStopLossTriggerOrder or isTakeProfitTriggerOrder
             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),
+            'orders': ordersRequests,
         }
-        response = await self.v1PrivatePostOrderLimitBatch(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', [])
+        response = None
+        if market['spot']:
+            if isTriggerOrder:
+                response = await self.v2PrivatePostSpotBatchStopOrder(request)
+                #
+                #     {
+                #         "code": 0,
+                #         "data": [
+                #             {
+                #                 "code": 0,
+                #                 "data": {
+                #                     "stop_id": 117186257510
+                #                 },
+                #                 "message": "OK"
+                #             },
+                #         ],
+                #         "message": "OK"
+                #     }
+                #
+            else:
+                response = await self.v2PrivatePostSpotBatchOrder(request)
+                #
+                #     {
+                #         "code": 0,
+                #         "data": [
+                #             {
+                #                 "amount": "0.0001",
+                #                 "base_fee": "0",
+                #                 "ccy": "BTC",
+                #                 "client_id": "x-167673045-f3651372049dab0d",
+                #                 "created_at": 1714121403450,
+                #                 "discount_fee": "0",
+                #                 "filled_amount": "0",
+                #                 "filled_value": "0",
+                #                 "last_fill_amount": "0",
+                #                 "last_fill_price": "0",
+                #                 "maker_fee_rate": "0.002",
+                #                 "market": "BTCUSDT",
+                #                 "market_type": "SPOT",
+                #                 "order_id": 117185362233,
+                #                 "price": "61000",
+                #                 "quote_fee": "0",
+                #                 "side": "buy",
+                #                 "taker_fee_rate": "0.002",
+                #                 "type": "limit",
+                #                 "unfilled_amount": "0.0001",
+                #                 "updated_at": 1714121403450
+                #             },
+                #             {
+                #                 "code": 3109,
+                #                 "data": null,
+                #                 "message": "balance not enough"
+                #             }
+                #         ],
+                #         "message": "OK"
+                #     }
+                #
+        else:
+            if isTriggerOrder:
+                response = await self.v2PrivatePostFuturesBatchStopOrder(request)
+                #
+                #     {
+                #         "code": 0,
+                #         "data": [
+                #             {
+                #                 "code": 0,
+                #                 "data": {
+                #                     "stop_id": 136919625994
+                #                 },
+                #                 "message": "OK"
+                #             },
+                #         ],
+                #         "message": "OK"
+                #     }
+                #
+            elif isStopLossOrTakeProfitTrigger:
+                raise NotSupported(self.id + ' createOrders() does not support stopLossPrice or takeProfitPrice orders')
+            else:
+                if reduceOnly:
+                    raise NotSupported(self.id + ' createOrders() does not support reduceOnly orders')
+                else:
+                    response = await self.v2PrivatePostFuturesBatchOrder(request)
+                    #
+                    #     {
+                    #         "code": 0,
+                    #         "data": [
+                    #             {
+                    #                 "code": 0,
+                    #                 "data": {
+                    #                     "amount": "0.0001",
+                    #                     "client_id": "x-167673045-2cb7436f3462a654",
+                    #                     "created_at": 1714122832493,
+                    #                     "fee": "0",
+                    #                     "fee_ccy": "USDT",
+                    #                     "filled_amount": "0",
+                    #                     "filled_value": "0",
+                    #                     "last_filled_amount": "0",
+                    #                     "last_filled_price": "0",
+                    #                     "maker_fee_rate": "0.0003",
+                    #                     "market": "BTCUSDT",
+                    #                     "market_type": "FUTURES",
+                    #                     "order_id": 136918835063,
+                    #                     "price": "61000",
+                    #                     "realized_pnl": "0",
+                    #                     "side": "buy",
+                    #                     "taker_fee_rate": "0.0005",
+                    #                     "type": "limit",
+                    #                     "unfilled_amount": "0.0001",
+                    #                     "updated_at": 1714122832493
+                    #                 },
+                    #                 "message": "OK"
+                    #             },
+                    #         ],
+                    #         "message": "OK"
+                    #     }
+                    #
+        data = self.safe_list(response, 'data', [])
         results = []
         for i in range(0, len(data)):
             entry = data[i]
@@ -2362,9 +2602,14 @@ class coinex(Exchange, ImplicitAPI):
                     status = 'rejected'
                 else:
                     status = 'open'
-            item = self.safe_value(entry, 'data', {})
-            item['status'] = status
-            order = self.parse_order(item, market)
+            innerData = self.safe_dict(entry, 'data', {})
+            order = None
+            if market['spot'] and not isTriggerOrder:
+                entry['status'] = status
+                order = self.parse_order(entry, market)
+            else:
+                innerData['status'] = status
+                order = self.parse_order(innerData, market)
             results.append(order)
         return results
 
@@ -5404,7 +5649,10 @@ class coinex(Exchange, ImplicitAPI):
                 query = self.keysort(query)
                 urlencoded = self.rawencode(query)
                 preparedString = method + '/' + version + '/' + path
-                if urlencoded:
+                if method == 'POST':
+                    body = self.json(query)
+                    preparedString += body
+                elif urlencoded:
                     preparedString += '?' + urlencoded
                 preparedString += nonce + self.secret
                 signature = self.hash(self.encode(preparedString), 'sha256')
@@ -5413,11 +5661,9 @@ class coinex(Exchange, ImplicitAPI):
                     'X-COINEX-SIGN': signature,
                     'X-COINEX-TIMESTAMP': nonce,
                 }
-                if (method == 'GET') or (method == 'DELETE') or (method == 'PUT'):
+                if method != 'POST':
                     if urlencoded:
                         url += '?' + urlencoded
-                else:
-                    body = self.json(query)
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
     def handle_errors(self, httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody):