ccxt 4.4.34__py2.py3-none-any.whl → 4.4.36__py2.py3-none-any.whl

ccxt/async_support/bingx.py

@@ -381,6 +381,7 @@ class bingx(Exchange, ImplicitAPI):
                             'get': {
                                 'list': 10,
                                 'assets': 2,
+                                'allAccountBalance': 2,
                             },
                             'post': {
                                 'create': 10,
@@ -2598,6 +2599,9 @@ class bingx(Exchange, ImplicitAPI):
         }
         isMarketOrder = type == 'MARKET'
         isSpot = marketType == 'spot'
+        isTwapOrder = type == 'TWAP'
+        if isTwapOrder and isSpot:
+            raise BadSymbol(self.id + ' createOrder() twap order supports swap contracts only')
         stopLossPrice = self.safe_string(params, 'stopLossPrice')
         takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
         triggerPrice = self.safe_string_2(params, 'stopPrice', 'triggerPrice')
@@ -2646,6 +2650,26 @@ class bingx(Exchange, ImplicitAPI):
                     request['type'] = 'TAKE_STOP_MARKET'
                 request['stopPrice'] = self.parse_to_numeric(self.price_to_precision(symbol, stopTakePrice))
         else:
+            if isTwapOrder:
+                twapRequest: dict = {
+                    'symbol': request['symbol'],
+                    'side': request['side'],
+                    'positionSide': 'LONG' if (side == 'buy') else 'SHORT',
+                    'triggerPrice': self.parse_to_numeric(self.price_to_precision(symbol, triggerPrice)),
+                    'totalAmount': self.parse_to_numeric(self.amount_to_precision(symbol, amount)),
+                }
+                #     {
+                #         "symbol": "LTC-USDT",
+                #         "side": "BUY",
+                #         "positionSide": "LONG",
+                #         "priceType": "constant",
+                #         "priceVariance": "10",
+                #         "triggerPrice": "120",
+                #         "interval": 8,
+                #         "amountPerOrder": "0.5",
+                #         "totalAmount": "1"
+                #     }
+                return self.extend(twapRequest, params)
             if timeInForce == 'FOK':
                 request['timeInForce'] = 'FOK'
             trailingAmount = self.safe_string(params, 'trailingAmount')
@@ -2743,6 +2767,7 @@ class bingx(Exchange, ImplicitAPI):
         https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Trade%20order
         https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Create%20an%20Order
         https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Trade%20order
+        https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Place%20TWAP%20Order
 
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
@@ -2780,6 +2805,8 @@ class bingx(Exchange, ImplicitAPI):
                 response = await self.swapV2PrivatePostTradeOrderTest(request)
             elif market['inverse']:
                 response = await self.cswapV1PrivatePostTradeOrder(request)
+            elif type == 'twap':
+                response = await self.swapV1PrivatePostTwapOrder(request)
             else:
                 response = await self.swapV2PrivatePostTradeOrder(request)
         else:
@@ -2837,6 +2864,17 @@ class bingx(Exchange, ImplicitAPI):
         #         "timeInForce": ""
         #     }
         #
+        # twap order
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "timestamp": 1732693774386,
+        #         "data": {
+        #             "mainOrderId": "4633860139993029715"
+        #         }
+        #     }
+        #
         if isinstance(response, str):
             # broken api engine : order-ids are too long numbers(i.e. 1742930526912864656)
             # and json.loadscan not handle them in JS, so we have to use .parseJson
@@ -2849,7 +2887,7 @@ class bingx(Exchange, ImplicitAPI):
             if market['inverse']:
                 result = response
             else:
-                result = self.safe_dict(data, 'order', {})
+                result = self.safe_dict(data, 'order', data)
         else:
             result = data
         return self.parse_order(result, market)
@@ -3266,9 +3304,9 @@ class bingx(Exchange, ImplicitAPI):
         if market is None:
             market = self.safe_market(marketId, None, None, marketType)
         side = self.safe_string_lower_2(order, 'side', 'S')
-        timestamp = self.safe_integer_n(order, ['time', 'transactTime', 'E'])
+        timestamp = self.safe_integer_n(order, ['time', 'transactTime', 'E', 'createdTime'])
         lastTradeTimestamp = self.safe_integer_2(order, 'updateTime', 'T')
-        statusId = self.safe_string_upper_2(order, 'status', 'X')
+        statusId = self.safe_string_upper_n(order, ['status', 'X', 'orderStatus'])
         feeCurrencyCode = self.safe_string_2(order, 'feeAsset', 'N')
         feeCost = self.safe_string_n(order, ['fee', 'commission', 'n'])
         if (feeCurrencyCode is None):
@@ -3309,7 +3347,7 @@ class bingx(Exchange, ImplicitAPI):
                 triggerPrice = None
         return self.safe_order({
             'info': info,
-            'id': self.safe_string_2(order, 'orderId', 'i'),
+            'id': self.safe_string_n(order, ['orderId', 'i', 'mainOrderId']),
             'clientOrderId': self.safe_string_n(order, ['clientOrderID', 'clientOrderId', 'origClientOrderId', 'c']),
             'symbol': self.safe_symbol(marketId, market, '-', marketType),
             'timestamp': timestamp,
@@ -3327,7 +3365,7 @@ class bingx(Exchange, ImplicitAPI):
             'takeProfitPrice': takeProfitPrice,
             'average': self.safe_string_2(order, 'avgPrice', 'ap'),
             'cost': self.safe_string(order, 'cummulativeQuoteQty'),
-            'amount': self.safe_string_n(order, ['origQty', 'q', 'quantity']),
+            'amount': self.safe_string_n(order, ['origQty', 'q', 'quantity', 'totalAmount']),
             'filled': self.safe_string_2(order, 'executedQty', 'z'),
             'remaining': None,
             'status': self.parse_order_status(statusId),
@@ -3344,6 +3382,7 @@ class bingx(Exchange, ImplicitAPI):
             'NEW': 'open',
             'PENDING': 'open',
             'PARTIALLY_FILLED': 'open',
+            'RUNNING': 'open',
             'FILLED': 'closed',
             'CANCELED': 'canceled',
             'CANCELLED': 'canceled',
@@ -3358,6 +3397,7 @@ class bingx(Exchange, ImplicitAPI):
         https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Cancel%20Order
         https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20Order
         https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Cancel%20an%20Order
+        https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20TWAP%20Order
 
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
@@ -3365,31 +3405,64 @@ class bingx(Exchange, ImplicitAPI):
         :param str [params.clientOrderId]: a unique id for the order
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' cancelOrder() requires a symbol argument')
         await self.load_markets()
-        market = self.market(symbol)
-        request: dict = {
-            'symbol': market['id'],
-        }
-        clientOrderId = self.safe_string_2(params, 'clientOrderId', 'clientOrderID')
-        params = self.omit(params, ['clientOrderId'])
-        if clientOrderId is not None:
-            request['clientOrderID'] = clientOrderId
-        else:
-            request['orderId'] = id
+        isTwapOrder = self.safe_bool(params, 'twap', False)
+        params = self.omit(params, 'twap')
         response = None
-        type = None
-        subType = None
-        type, params = self.handle_market_type_and_params('cancelOrder', market, params)
-        subType, params = self.handle_sub_type_and_params('cancelOrder', market, params)
-        if type == 'spot':
-            response = await self.spotV1PrivatePostTradeCancel(self.extend(request, params))
+        market = None
+        if isTwapOrder:
+            twapRequest: dict = {
+                'mainOrderId': id,
+            }
+            response = await self.swapV1PrivatePostTwapCancelOrder(self.extend(twapRequest, params))
+            #
+            #     {
+            #         "code": 0,
+            #         "msg": "",
+            #         "timestamp": 1702731661854,
+            #         "data": {
+            #             "symbol": "BNB-USDT",
+            #             "side": "BUY",
+            #             "positionSide": "LONG",
+            #             "priceType": "constant",
+            #             "priceVariance": "2000",
+            #             "triggerPrice": "68000",
+            #             "interval": 8,
+            #             "amountPerOrder": "0.111",
+            #             "totalAmount": "0.511",
+            #             "orderStatus": "Running",
+            #             "executedQty": "0.1",
+            #             "duration": 800,
+            #             "maxDuration": 9000,
+            #             "createdTime": 1702731661854,
+            #             "updateTime": 1702731661854
+            #         }
+            #     }
+            #
         else:
-            if subType == 'inverse':
-                response = await self.cswapV1PrivateDeleteTradeCancelOrder(self.extend(request, params))
+            if symbol is None:
+                raise ArgumentsRequired(self.id + ' cancelOrder() requires a symbol argument')
+            market = self.market(symbol)
+            request: dict = {
+                'symbol': market['id'],
+            }
+            clientOrderId = self.safe_string_2(params, 'clientOrderId', 'clientOrderID')
+            params = self.omit(params, ['clientOrderId'])
+            if clientOrderId is not None:
+                request['clientOrderID'] = clientOrderId
+            else:
+                request['orderId'] = id
+            type = None
+            subType = None
+            type, params = self.handle_market_type_and_params('cancelOrder', market, params)
+            subType, params = self.handle_sub_type_and_params('cancelOrder', market, params)
+            if type == 'spot':
+                response = await self.spotV1PrivatePostTradeCancel(self.extend(request, params))
             else:
-                response = await self.swapV2PrivateDeleteTradeOrder(self.extend(request, params))
+                if subType == 'inverse':
+                    response = await self.cswapV1PrivateDeleteTradeCancelOrder(self.extend(request, params))
+                else:
+                    response = await self.swapV2PrivateDeleteTradeOrder(self.extend(request, params))
         #
         # spot
         #
@@ -3779,131 +3852,167 @@ class bingx(Exchange, ImplicitAPI):
         https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20details
         https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20details
         https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Order
+        https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#TWAP%20Order%20Details
 
         :param str id: the order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.twap]: if fetching twap order
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' fetchOrder() requires a symbol argument')
         await self.load_markets()
-        market = self.market(symbol)
-        request: dict = {
-            'symbol': market['id'],
-            'orderId': id,
-        }
-        type = None
-        subType = None
+        isTwapOrder = self.safe_bool(params, 'twap', False)
+        params = self.omit(params, 'twap')
         response = None
-        type, params = self.handle_market_type_and_params('fetchOrder', market, params)
-        subType, params = self.handle_sub_type_and_params('fetchOrder', market, params)
-        if type == 'spot':
-            response = await self.spotV1PrivateGetTradeQuery(self.extend(request, params))
+        market = None
+        if isTwapOrder:
+            twapRequest: dict = {
+                'mainOrderId': id,
+            }
+            response = await self.swapV1PrivateGetTwapOrderDetail(self.extend(twapRequest, params))
             #
             #     {
             #         "code": 0,
-            #         "msg": "",
+            #         "msg": "success cancel order",
+            #         "timestamp": 1732760856617,
             #         "data": {
-            #             "symbol": "XRP-USDT",
-            #             "orderId": 1514087361158316032,
-            #             "price": "0.5",
-            #             "origQty": "10",
-            #             "executedQty": "0",
-            #             "cummulativeQuoteQty": "0",
-            #             "status": "CANCELED",
-            #             "type": "LIMIT",
+            #             "symbol": "LTC-USDT",
+            #             "mainOrderId": "5596903086063901779",
             #             "side": "BUY",
-            #             "time": 1649821532000,
-            #             "updateTime": 1649821543000,
-            #             "origQuoteOrderQty": "0",
-            #             "fee": "0",
-            #             "feeAsset": "XRP"
+            #             "positionSide": "LONG",
+            #             "priceType": "constant",
+            #             "priceVariance": "10.00",
+            #             "triggerPrice": "120.00",
+            #             "interval": 8,
+            #             "amountPerOrder": "0.5",
+            #             "totalAmount": "1.0",
+            #             "orderStatus": "Filled",
+            #             "executedQty": "1.0",
+            #             "duration": 16,
+            #             "maxDuration": 86400,
+            #             "createdTime": 1732693017000,
+            #             "updateTime": 1732693033000
             #         }
             #     }
             #
         else:
-            if subType == 'inverse':
-                response = await self.cswapV1PrivateGetTradeOrderDetail(self.extend(request, params))
+            if symbol is None:
+                raise ArgumentsRequired(self.id + ' fetchOrder() requires a symbol argument')
+            market = self.market(symbol)
+            request: dict = {
+                'symbol': market['id'],
+                'orderId': id,
+            }
+            type = None
+            subType = None
+            type, params = self.handle_market_type_and_params('fetchOrder', market, params)
+            subType, params = self.handle_sub_type_and_params('fetchOrder', market, params)
+            if type == 'spot':
+                response = await self.spotV1PrivateGetTradeQuery(self.extend(request, params))
                 #
                 #     {
                 #         "code": 0,
                 #         "msg": "",
                 #         "data": {
-                #             "order": {
-                #                 "symbol": "SOL-USD",
-                #                 "orderId": "1816342420721254400",
-                #                 "side": "BUY",
-                #                 "positionSide": "Long",
-                #                 "type": "LIMIT",
-                #                 "quantity": 1,
-                #                 "origQty": "",
-                #                 "price": "150",
-                #                 "executedQty": "0",
-                #                 "avgPrice": "0.000",
-                #                 "cumQuote": "",
-                #                 "stopPrice": "",
-                #                 "profit": "0.0000",
-                #                 "commission": "0.0000",
-                #                 "status": "Pending",
-                #                 "time": 1721884753767,
-                #                 "updateTime": 1721884753786,
-                #                 "clientOrderId": "",
-                #                 "leverage": "",
-                #                 "takeProfit": {
-                #                     "type": "TAKE_PROFIT",
-                #                     "quantity": 0,
-                #                     "stopPrice": 0,
-                #                     "price": 0,
-                #                     "workingType": "MARK_PRICE",
-                #                     "stopGuaranteed": ""
-                #                 },
-                #                 "stopLoss": {
-                #                     "type": "STOP",
-                #                     "quantity": 0,
-                #                     "stopPrice": 0,
-                #                     "price": 0,
-                #                     "workingType": "MARK_PRICE",
-                #                     "stopGuaranteed": ""
-                #                 },
-                #                 "advanceAttr": 0,
-                #                 "positionID": 0,
-                #                 "takeProfitEntrustPrice": 0,
-                #                 "stopLossEntrustPrice": 0,
-                #                 "orderType": "",
-                #                 "workingType": "MARK_PRICE"
-                #             }
+                #             "symbol": "XRP-USDT",
+                #             "orderId": 1514087361158316032,
+                #             "price": "0.5",
+                #             "origQty": "10",
+                #             "executedQty": "0",
+                #             "cummulativeQuoteQty": "0",
+                #             "status": "CANCELED",
+                #             "type": "LIMIT",
+                #             "side": "BUY",
+                #             "time": 1649821532000,
+                #             "updateTime": 1649821543000,
+                #             "origQuoteOrderQty": "0",
+                #             "fee": "0",
+                #             "feeAsset": "XRP"
                 #         }
                 #     }
                 #
             else:
-                response = await self.swapV2PrivateGetTradeOrder(self.extend(request, params))
-                #
-                #     {
-                #         "code": 0,
-                #         "msg": "",
-                #         "data": {
-                #             "order": {
-                #                 "symbol": "BTC-USDT",
-                #                 "orderId": 1597597642269917184,
-                #                 "side": "SELL",
-                #                 "positionSide": "LONG",
-                #                 "type": "TAKE_PROFIT_MARKET",
-                #                 "origQty": "1.0000",
-                #                 "price": "0.0",
-                #                 "executedQty": "0.0000",
-                #                 "avgPrice": "0.0",
-                #                 "cumQuote": "",
-                #                 "stopPrice": "16494.0",
-                #                 "profit": "",
-                #                 "commission": "",
-                #                 "status": "FILLED",
-                #                 "time": 1669731935000,
-                #                 "updateTime": 1669752524000
-                #             }
-                #         }
-                #     }
-                #
+                if subType == 'inverse':
+                    response = await self.cswapV1PrivateGetTradeOrderDetail(self.extend(request, params))
+                    #
+                    #     {
+                    #         "code": 0,
+                    #         "msg": "",
+                    #         "data": {
+                    #             "order": {
+                    #                 "symbol": "SOL-USD",
+                    #                 "orderId": "1816342420721254400",
+                    #                 "side": "BUY",
+                    #                 "positionSide": "Long",
+                    #                 "type": "LIMIT",
+                    #                 "quantity": 1,
+                    #                 "origQty": "",
+                    #                 "price": "150",
+                    #                 "executedQty": "0",
+                    #                 "avgPrice": "0.000",
+                    #                 "cumQuote": "",
+                    #                 "stopPrice": "",
+                    #                 "profit": "0.0000",
+                    #                 "commission": "0.0000",
+                    #                 "status": "Pending",
+                    #                 "time": 1721884753767,
+                    #                 "updateTime": 1721884753786,
+                    #                 "clientOrderId": "",
+                    #                 "leverage": "",
+                    #                 "takeProfit": {
+                    #                     "type": "TAKE_PROFIT",
+                    #                     "quantity": 0,
+                    #                     "stopPrice": 0,
+                    #                     "price": 0,
+                    #                     "workingType": "MARK_PRICE",
+                    #                     "stopGuaranteed": ""
+                    #                 },
+                    #                 "stopLoss": {
+                    #                     "type": "STOP",
+                    #                     "quantity": 0,
+                    #                     "stopPrice": 0,
+                    #                     "price": 0,
+                    #                     "workingType": "MARK_PRICE",
+                    #                     "stopGuaranteed": ""
+                    #                 },
+                    #                 "advanceAttr": 0,
+                    #                 "positionID": 0,
+                    #                 "takeProfitEntrustPrice": 0,
+                    #                 "stopLossEntrustPrice": 0,
+                    #                 "orderType": "",
+                    #                 "workingType": "MARK_PRICE"
+                    #             }
+                    #         }
+                    #     }
+                    #
+                else:
+                    response = await self.swapV2PrivateGetTradeOrder(self.extend(request, params))
+                    #
+                    #     {
+                    #         "code": 0,
+                    #         "msg": "",
+                    #         "data": {
+                    #             "order": {
+                    #                 "symbol": "BTC-USDT",
+                    #                 "orderId": 1597597642269917184,
+                    #                 "side": "SELL",
+                    #                 "positionSide": "LONG",
+                    #                 "type": "TAKE_PROFIT_MARKET",
+                    #                 "origQty": "1.0000",
+                    #                 "price": "0.0",
+                    #                 "executedQty": "0.0000",
+                    #                 "avgPrice": "0.0",
+                    #                 "cumQuote": "",
+                    #                 "stopPrice": "16494.0",
+                    #                 "profit": "",
+                    #                 "commission": "",
+                    #                 "status": "FILLED",
+                    #                 "time": 1669731935000,
+                    #                 "updateTime": 1669752524000
+                    #             }
+                    #         }
+                    #     }
+                    #
         data = self.safe_dict(response, 'data', {})
         order = self.safe_dict(data, 'order', data)
         return self.parse_order(order, market)
@@ -4002,11 +4111,13 @@ class bingx(Exchange, ImplicitAPI):
         https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Current%20Open%20Orders
         https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Current%20All%20Open%20Orders
         https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20all%20current%20pending%20orders
+        https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20TWAP%20Entrusted%20Order
 
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch open orders for
         :param int [limit]: the maximum number of open order structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.twap]: if fetching twap open orders
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
@@ -4023,7 +4134,11 @@ class bingx(Exchange, ImplicitAPI):
         if type == 'spot':
             response = await self.spotV1PrivateGetTradeOpenOrders(self.extend(request, params))
         else:
-            if subType == 'inverse':
+            isTwapOrder = self.safe_bool(params, 'twap', False)
+            params = self.omit(params, 'twap')
+            if isTwapOrder:
+                response = await self.swapV1PrivateGetTwapOpenOrders(self.extend(request, params))
+            elif subType == 'inverse':
                 response = await self.cswapV1PrivateGetTradeOpenOrders(self.extend(request, params))
             else:
                 response = await self.swapV2PrivateGetTradeOpenOrders(self.extend(request, params))
@@ -4136,8 +4251,38 @@ class bingx(Exchange, ImplicitAPI):
         #        }
         #    }
         #
+        # twap
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "timestamp": 1702731661854,
+        #         "data": {
+        #             "list": [
+        #                 {
+        #                     "symbol": "BNB-USDT",
+        #                     "side": "BUY",
+        #                     "positionSide": "LONG",
+        #                     "priceType": "constant",
+        #                     "priceVariance": "2000",
+        #                     "triggerPrice": "68000",
+        #                     "interval": 8,
+        #                     "amountPerOrder": "0.111",
+        #                     "totalAmount": "0.511",
+        #                     "orderStatus": "Running",
+        #                     "executedQty": "0.1",
+        #                     "duration": 800,
+        #                     "maxDuration": 9000,
+        #                     "createdTime": 1702731661854,
+        #                     "updateTime": 1702731661854
+        #                 }
+        #             ],
+        #             "total": 1
+        #         }
+        #     }
+        #
         data = self.safe_dict(response, 'data', {})
-        orders = self.safe_list(data, 'orders', [])
+        orders = self.safe_list_2(data, 'orders', 'list', [])
         return self.parse_orders(orders, market, since, limit)
 
     async def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -4190,6 +4335,7 @@ class bingx(Exchange, ImplicitAPI):
         https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20history
         https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#User's%20History%20Orders
         https://bingx-api.github.io/docs/#/standard/contract-interface.html#Historical%20order
+        https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20TWAP%20Historical%20Orders
 
         :param str [symbol]: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
@@ -4197,6 +4343,7 @@ class bingx(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param int [params.until]: the latest time in ms to fetch orders for
         :param boolean [params.standard]: whether to fetch standard contract orders
+        :param boolean [params.twap]: if fetching twap orders
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         if symbol is None:
@@ -4244,7 +4391,46 @@ class bingx(Exchange, ImplicitAPI):
             #    }
             #
         else:
-            if subType == 'inverse':
+            isTwapOrder = self.safe_bool(params, 'twap', False)
+            params = self.omit(params, 'twap')
+            if isTwapOrder:
+                request['pageIndex'] = 1
+                request['pageSize'] = 100 if (limit is None) else limit
+                request['startTime'] = 1 if (since is None) else since
+                until = self.safe_integer(params, 'until', self.milliseconds())
+                params = self.omit(params, 'until')
+                request['endTime'] = until
+                response = await self.swapV1PrivateGetTwapHistoryOrders(self.extend(request, params))
+                #
+                #     {
+                #         "code": 0,
+                #         "msg": "",
+                #         "timestamp": 1702731661854,
+                #         "data": {
+                #             "list": [
+                #                 {
+                #                     "symbol": "BNB-USDT",
+                #                     "side": "BUY",
+                #                     "positionSide": "LONG",
+                #                     "priceType": "constant",
+                #                     "priceVariance": "2000",
+                #                     "triggerPrice": "68000",
+                #                     "interval": 8,
+                #                     "amountPerOrder": "0.111",
+                #                     "totalAmount": "0.511",
+                #                     "orderStatus": "Running",
+                #                     "executedQty": "0.1",
+                #                     "duration": 800,
+                #                     "maxDuration": 9000,
+                #                     "createdTime": 1702731661854,
+                #                     "updateTime": 1702731661854
+                #                 }
+                #             ],
+                #             "total": 1
+                #         }
+                #     }
+                #
+            elif subType == 'inverse':
                 response = await self.cswapV1PrivateGetTradeOrderHistory(self.extend(request, params))
                 #
                 #     {
@@ -4330,7 +4516,7 @@ class bingx(Exchange, ImplicitAPI):
                 #     }
                 #
         data = self.safe_dict(response, 'data', {})
-        orders = self.safe_list(data, 'orders', [])
+        orders = self.safe_list_2(data, 'orders', 'list', [])
         return self.parse_orders(orders, market, since, limit)
 
     async def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
@@ -5883,27 +6069,27 @@ class bingx(Exchange, ImplicitAPI):
         path = self.implode_params(path, params)
         url += path
         params = self.omit(params, self.extract_params(path))
+        params['timestamp'] = self.nonce()
         params = self.keysort(params)
         if access == 'public':
-            params['timestamp'] = self.nonce()
             if params:
                 url += '?' + self.urlencode(params)
         elif access == 'private':
             self.check_required_credentials()
-            params['timestamp'] = self.nonce()
+            isJsonContentType = ((type == 'subAccount') and (method == 'POST'))
             parsedParams = self.parse_params(params)
-            query = self.urlencode(parsedParams)
             signature = self.hmac(self.encode(self.rawencode(parsedParams)), self.encode(self.secret), hashlib.sha256)
-            if params:
-                query = '?' + query + '&'
-            else:
-                query += '?'
-            query += 'signature=' + signature
             headers = {
                 'X-BX-APIKEY': self.apiKey,
                 'X-SOURCE-KEY': self.safe_string(self.options, 'broker', 'CCXT'),
             }
-            url += query
+            if isJsonContentType:
+                headers['Content-Type'] = 'application/json'
+                parsedParams['signature'] = signature
+                body = self.json(parsedParams)
+            else:
+                query = self.urlencode(parsedParams)
+                url += '?' + query + '&signature=' + signature
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
     def nonce(self):