ccxt 4.3.66__py2.py3-none-any.whl → 4.3.68__py2.py3-none-any.whl

ccxt/async_support/bingx.py

@@ -63,6 +63,7 @@ class bingx(Exchange, ImplicitAPI):
                 'createTrailingPercentOrder': True,
                 'createTriggerOrder': True,
                 'fetchBalance': True,
+                'fetchCanceledOrders': True,
                 'fetchClosedOrders': True,
                 'fetchCurrencies': True,
                 'fetchDepositAddress': True,
@@ -298,6 +299,10 @@ class bingx(Exchange, ImplicitAPI):
                                 'trade/leverage': 2,
                                 'trade/forceOrders': 2,
                                 'trade/allFillOrders': 2,
+                                'trade/openOrders': 2,
+                                'trade/orderDetail': 2,
+                                'trade/orderHistory': 2,
+                                'trade/marginType': 2,
                                 'user/commissionRate': 2,
                                 'user/positions': 2,
                                 'user/balance': 2,
@@ -306,9 +311,12 @@ class bingx(Exchange, ImplicitAPI):
                                 'trade/order': 2,
                                 'trade/leverage': 2,
                                 'trade/closeAllPositions': 2,
+                                'trade/marginType': 2,
+                                'trade/positionMargin': 2,
                             },
                             'delete': {
                                 'trade/allOpenOrders': 2,
+                                'trade/cancelOrder': 2,
                             },
                         },
                     },
@@ -2835,7 +2843,7 @@ class bingx(Exchange, ImplicitAPI):
         #        "clientOrderID": ""
         #    }
         #
-        # inverse swap cancelAllOrders
+        # inverse swap cancelAllOrders, cancelOrder, fetchOrder, fetchOpenOrders, fetchClosedOrders, fetchCanceledOrders
         #
         #     {
         #         "symbol": "SOL-USD",
@@ -2893,7 +2901,7 @@ class bingx(Exchange, ImplicitAPI):
         side = self.safe_string_lower_2(order, 'side', 'S')
         timestamp = self.safe_integer_n(order, ['time', 'transactTime', 'E'])
         lastTradeTimestamp = self.safe_integer_2(order, 'updateTime', 'T')
-        statusId = self.safe_string_2(order, 'status', 'X')
+        statusId = self.safe_string_upper_2(order, 'status', 'X')
         feeCurrencyCode = self.safe_string_2(order, 'feeAsset', 'N')
         feeCost = self.safe_string_n(order, ['fee', 'commission', 'n'])
         if (feeCurrencyCode is None):
@@ -2979,13 +2987,14 @@ class bingx(Exchange, ImplicitAPI):
     async def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
         cancels an open order
-        :see: https://bingx-api.github.io/docs/#/spot/trade-api.html#Cancel%20an%20Order
-        :see: https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Cancel%20an%20Order
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Cancel%20Order
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20Order
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Cancel%20an%20Order
         :param str id: 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 str [params.clientOrderId]: a unique id for the order
-        :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        :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')
@@ -3001,11 +3010,17 @@ class bingx(Exchange, ImplicitAPI):
         else:
             request['orderId'] = id
         response = None
-        marketType, query = self.handle_market_type_and_params('cancelOrder', market, params)
-        if marketType == 'spot':
-            response = await self.spotV1PrivatePostTradeCancel(self.extend(request, query))
+        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, query))
+            if subType == 'inverse':
+                response = await self.cswapV1PrivateDeleteTradeCancelOrder(self.extend(request, params))
+            else:
+                response = await self.swapV2PrivateDeleteTradeOrder(self.extend(request, params))
         #
         # spot
         #
@@ -3025,7 +3040,59 @@ class bingx(Exchange, ImplicitAPI):
         #       }
         #   }
         #
-        # swap
+        # inverse swap
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "data": {
+        #             "order": {
+        #                 "symbol": "SOL-USD",
+        #                 "orderId": "1816002957423951872",
+        #                 "side": "BUY",
+        #                 "positionSide": "Long",
+        #                 "type": "Pending",
+        #                 "quantity": 0,
+        #                 "origQty": "0",
+        #                 "price": "150",
+        #                 "executedQty": "0",
+        #                 "avgPrice": "0",
+        #                 "cumQuote": "0",
+        #                 "stopPrice": "",
+        #                 "profit": "0.0000",
+        #                 "commission": "0.000000",
+        #                 "status": "CANCELLED",
+        #                 "time": 1721803819410,
+        #                 "updateTime": 1721803819427,
+        #                 "clientOrderId": "",
+        #                 "leverage": "",
+        #                 "takeProfit": {
+        #                     "type": "",
+        #                     "quantity": 0,
+        #                     "stopPrice": 0,
+        #                     "price": 0,
+        #                     "workingType": "",
+        #                     "stopGuaranteed": ""
+        #                 },
+        #                 "stopLoss": {
+        #                     "type": "",
+        #                     "quantity": 0,
+        #                     "stopPrice": 0,
+        #                     "price": 0,
+        #                     "workingType": "",
+        #                     "stopGuaranteed": ""
+        #                 },
+        #                 "advanceAttr": 0,
+        #                 "positionID": 0,
+        #                 "takeProfitEntrustPrice": 0,
+        #                 "stopLossEntrustPrice": 0,
+        #                 "orderType": "",
+        #                 "workingType": ""
+        #             }
+        #         }
+        #     }
+        #
+        # linear swap
         #
         #    {
         #        "code": 0,
@@ -3052,9 +3119,9 @@ class bingx(Exchange, ImplicitAPI):
         #        }
         #    }
         #
-        data = self.safe_value(response, 'data')
-        first = self.safe_dict(data, 'order', data)
-        return self.parse_order(first, market)
+        data = self.safe_dict(response, 'data', {})
+        order = self.safe_dict(data, 'order', data)
+        return self.parse_order(order, market)
 
     async def cancel_all_orders(self, symbol: Str = None, params={}):
         """
@@ -3333,11 +3400,12 @@ class bingx(Exchange, ImplicitAPI):
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
-        :see: https://bingx-api.github.io/docs/#/spot/trade-api.html#Query%20Orders
-        :see: https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Query%20Order
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20details
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20details
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Order
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        :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')
@@ -3347,66 +3415,120 @@ class bingx(Exchange, ImplicitAPI):
             'symbol': market['id'],
             'orderId': id,
         }
+        type = None
+        subType = None
         response = None
-        marketType, query = self.handle_market_type_and_params('fetchOrder', market, params)
-        if marketType == 'spot':
-            response = await self.spotV1PrivateGetTradeQuery(self.extend(request, query))
+        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": {
+            #             "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, query))
-        #
-        # spot
-        #
-        #     {
-        #         "code": 0,
-        #         "msg": "",
-        #         "data": {
-        #             "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"
-        #         }
-        #     }
-        #
-        # swap
-        #
-        #      {
-        #          "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_value(response, 'data')
-        first = self.safe_dict(data, 'order', data)
-        return self.parse_order(first, market)
+            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)
 
     async def fetch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
@@ -3498,9 +3620,10 @@ class bingx(Exchange, ImplicitAPI):
 
     async def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
-        :see: https://bingx-api.github.io/docs/#/spot/trade-api.html#Query%20Open%20Orders
-        :see: https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Query%20all%20current%20pending%20orders
         fetch all unfilled currently open orders
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Current%20Open%20Orders
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Current%20All%20Open%20Orders
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20all%20current%20pending%20orders
         :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
@@ -3513,12 +3636,18 @@ class bingx(Exchange, ImplicitAPI):
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
+        type = None
+        subType = None
         response = None
-        marketType, query = self.handle_market_type_and_params('fetchOpenOrders', market, params)
-        if marketType == 'spot':
-            response = await self.spotV1PrivateGetTradeOpenOrders(self.extend(request, query))
+        type, params = self.handle_market_type_and_params('fetchOpenOrders', market, params)
+        subType, params = self.handle_sub_type_and_params('fetchOpenOrders', market, params)
+        if type == 'spot':
+            response = await self.spotV1PrivateGetTradeOpenOrders(self.extend(request, params))
         else:
-            response = await self.swapV2PrivateGetTradeOpenOrders(self.extend(request, query))
+            if subType == 'inverse':
+                response = await self.cswapV1PrivateGetTradeOpenOrders(self.extend(request, params))
+            else:
+                response = await self.swapV2PrivateGetTradeOpenOrders(self.extend(request, params))
         #
         #  spot
         #
@@ -3545,7 +3674,61 @@ class bingx(Exchange, ImplicitAPI):
         #        }
         #    }
         #
-        # swap
+        # inverse swap
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "data": {
+        #             "orders": [
+        #                 {
+        #                     "symbol": "SOL-USD",
+        #                     "orderId": "1816013900044320768",
+        #                     "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": 1721806428334,
+        #                     "updateTime": 1721806428352,
+        #                     "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"
+        #                 }
+        #             ]
+        #         }
+        #     }
+        #
+        # linear swap
         #
         #    {
         #        "code": 0,
@@ -3581,8 +3764,47 @@ class bingx(Exchange, ImplicitAPI):
     async def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetches information on multiple closed orders made by the user
-        :see: https://bingx-api.github.io/docs/#/spot/trade-api.html#Query%20Order%20History
-        :see: https://bingx-api.github.io/docs/#/swapV2/trade-api.html#User's%20Force%20Orders
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20history
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20history
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#User's%20History%20Orders
+        :see: https://bingx-api.github.io/docs/#/standard/contract-interface.html#Historical%20order
+        :param str symbol: unified market symbol of the closed orders
+        :param int [since]: timestamp in ms of the earliest order
+        :param int [limit]: the max number of closed orders to return
+        :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
+        :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        orders = await self.fetch_canceled_and_closed_orders(symbol, since, limit, params)
+        return self.filter_by(orders, 'status', 'closed')
+
+    async def fetch_canceled_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
+        """
+        fetches information on multiple canceled orders made by the user
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20history
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20history
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#User's%20History%20Orders
+        :see: https://bingx-api.github.io/docs/#/standard/contract-interface.html#Historical%20order
+        :param str symbol: unified market symbol of the canceled orders
+        :param int [since]: timestamp in ms of the earliest order
+        :param int [limit]: the max number of canceled orders to return
+        :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
+        :returns dict: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        orders = await self.fetch_canceled_and_closed_orders(symbol, since, limit, params)
+        return self.filter_by(orders, 'status', 'canceled')
+
+    async def fetch_canceled_and_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
+        """
+        fetches information on multiple closed orders made by the user
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Query%20Order%20history
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Order%20history
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#User's%20History%20Orders
         :see: https://bingx-api.github.io/docs/#/standard/contract-interface.html#Historical%20order
         :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
@@ -3599,72 +3821,128 @@ class bingx(Exchange, ImplicitAPI):
         request: dict = {
             'symbol': market['id'],
         }
-        response = None
+        type = None
+        subType = None
         standard = None
+        response = None
+        type, params = self.handle_market_type_and_params('fetchClosedOrders', market, params)
+        subType, params = self.handle_sub_type_and_params('fetchClosedOrders', market, params)
         standard, params = self.handle_option_and_params(params, 'fetchClosedOrders', 'standard', False)
-        marketType, query = self.handle_market_type_and_params('fetchClosedOrders', market, params)
         if standard:
-            response = await self.contractV1PrivateGetAllOrders(self.extend(request, query))
-        elif marketType == 'spot':
-            response = await self.spotV1PrivateGetTradeHistoryOrders(self.extend(request, query))
+            response = await self.contractV1PrivateGetAllOrders(self.extend(request, params))
+        elif type == 'spot':
+            response = await self.spotV1PrivateGetTradeHistoryOrders(self.extend(request, params))
+            #
+            #    {
+            #        "code": 0,
+            #        "msg": "",
+            #        "data": {
+            #            "orders": [
+            #                {
+            #                    "symbol": "XRP-USDT",
+            #                    "orderId": 1514073325788200960,
+            #                    "price": "0.5",
+            #                    "origQty": "20",
+            #                    "executedQty": "0",
+            #                    "cummulativeQuoteQty": "0",
+            #                    "status": "PENDING",
+            #                    "type": "LIMIT",
+            #                    "side": "BUY",
+            #                    "time": 1649818185647,
+            #                    "updateTime": 1649818185647,
+            #                    "origQuoteOrderQty": "0"
+            #                }
+            #            ]
+            #        }
+            #    }
+            #
         else:
-            response = await self.swapV2PrivateGetTradeAllOrders(self.extend(request, query))
-        #
-        #  spot
-        #
-        #    {
-        #        "code": 0,
-        #        "msg": "",
-        #        "data": {
-        #            "orders": [
-        #                {
-        #                    "symbol": "XRP-USDT",
-        #                    "orderId": 1514073325788200960,
-        #                    "price": "0.5",
-        #                    "origQty": "20",
-        #                    "executedQty": "0",
-        #                    "cummulativeQuoteQty": "0",
-        #                    "status": "PENDING",
-        #                    "type": "LIMIT",
-        #                    "side": "BUY",
-        #                    "time": 1649818185647,
-        #                    "updateTime": 1649818185647,
-        #                    "origQuoteOrderQty": "0"
-        #                }
-        #            ]
-        #        }
-        #    }
-        #
-        # swap
-        #
-        #    {
-        #        "code": 0,
-        #        "msg": "",
-        #        "data": {
-        #          "orders": [
-        #            {
-        #              "symbol": "LINK-USDT",
-        #              "orderId": 1585839271162413056,
-        #              "side": "BUY",
-        #              "positionSide": "LONG",
-        #              "type": "TRIGGER_MARKET",
-        #              "origQty": "5.0",
-        #              "price": "9",
-        #              "executedQty": "0.0",
-        #              "avgPrice": "0",
-        #              "cumQuote": "0",
-        #              "stopPrice": "5",
-        #              "profit": "0.0000",
-        #              "commission": "0.000000",
-        #              "status": "CANCELLED",
-        #              "time": 1667631605000,
-        #              "updateTime": 1667631605000
-        #            },
-        #          ]
-        #        }
-        #    }
-        #
-        data = self.safe_value(response, 'data', [])
+            if subType == 'inverse':
+                response = await self.cswapV1PrivateGetTradeOrderHistory(self.extend(request, params))
+                #
+                #     {
+                #         "code": 0,
+                #         "msg": "",
+                #         "data": {
+                #             "orders": [
+                #                 {
+                #                     "symbol": "SOL-USD",
+                #                     "orderId": "1816002957423951872",
+                #                     "side": "BUY",
+                #                     "positionSide": "LONG",
+                #                     "type": "LIMIT",
+                #                     "quantity": 1,
+                #                     "origQty": "10.00000000",
+                #                     "price": "150.000",
+                #                     "executedQty": "0.00000000",
+                #                     "avgPrice": "0.000",
+                #                     "cumQuote": "",
+                #                     "stopPrice": "0.000",
+                #                     "profit": "0.0000",
+                #                     "commission": "0.000000",
+                #                     "status": "Filled",
+                #                     "time": 1721803819000,
+                #                     "updateTime": 1721803856000,
+                #                     "clientOrderId": "",
+                #                     "leverage": "",
+                #                     "takeProfit": {
+                #                         "type": "",
+                #                         "quantity": 0,
+                #                         "stopPrice": 0,
+                #                         "price": 0,
+                #                         "workingType": "",
+                #                         "stopGuaranteed": ""
+                #                     },
+                #                     "stopLoss": {
+                #                         "type": "",
+                #                         "quantity": 0,
+                #                         "stopPrice": 0,
+                #                         "price": 0,
+                #                         "workingType": "",
+                #                         "stopGuaranteed": ""
+                #                     },
+                #                     "advanceAttr": 0,
+                #                     "positionID": 0,
+                #                     "takeProfitEntrustPrice": 0,
+                #                     "stopLossEntrustPrice": 0,
+                #                     "orderType": "",
+                #                     "workingType": "MARK_PRICE"
+                #                 },
+                #             ]
+                #         }
+                #     }
+                #
+            else:
+                response = await self.swapV2PrivateGetTradeAllOrders(self.extend(request, params))
+                #
+                #     {
+                #         "code": 0,
+                #         "msg": "",
+                #         "data": {
+                #             "orders": [
+                #                 {
+                #                     "symbol": "LINK-USDT",
+                #                     "orderId": 1585839271162413056,
+                #                     "side": "BUY",
+                #                     "positionSide": "LONG",
+                #                     "type": "TRIGGER_MARKET",
+                #                     "origQty": "5.0",
+                #                     "price": "9",
+                #                     "executedQty": "0.0",
+                #                     "avgPrice": "0",
+                #                     "cumQuote": "0",
+                #                     "stopPrice": "5",
+                #                     "profit": "0.0000",
+                #                     "commission": "0.000000",
+                #                     "status": "CANCELLED",
+                #                     "time": 1667631605000,
+                #                     "updateTime": 1667631605000
+                #                 },
+                #             ]
+                #         }
+                #     }
+                #
+        data = self.safe_dict(response, 'data', {})
         orders = self.safe_list(data, 'orders', [])
         return self.parse_orders(orders, market, since, limit)
 
@@ -4067,7 +4345,8 @@ class bingx(Exchange, ImplicitAPI):
     async def set_margin_mode(self, marginMode: str, symbol: Str = None, params={}):
         """
         set margin mode to 'cross' or 'isolated'
-        :see: https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Switch%20Margin%20Mode
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Change%20Margin%20Type
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Set%20Margin%20Type
         :param str marginMode: 'cross' or 'isolated'
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -4088,7 +4367,12 @@ class bingx(Exchange, ImplicitAPI):
             'symbol': market['id'],
             'marginType': marginMode,
         }
-        return await self.swapV2PrivatePostTradeMarginType(self.extend(request, params))
+        subType = None
+        subType, params = self.handle_sub_type_and_params('setMarginMode', market, params)
+        if subType == 'inverse':
+            return await self.cswapV1PrivatePostTradeMarginType(self.extend(request, params))
+        else:
+            return await self.swapV2PrivatePostTradeMarginType(self.extend(request, params))
 
     async def add_margin(self, symbol: str, amount: float, params={}) -> MarginModification:
         request: dict = {
@@ -4980,7 +5264,8 @@ class bingx(Exchange, ImplicitAPI):
     async def fetch_margin_mode(self, symbol: str, params={}) -> MarginMode:
         """
         fetches the margin mode of the trading pair
-        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Margin%20Mode
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Query%20Margin%20Type
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Margin%20Type
         :param str symbol: unified symbol of the market to fetch the margin mode for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `margin mode structure <https://docs.ccxt.com/#/?id=margin-mode-structure>`
@@ -4990,25 +5275,43 @@ class bingx(Exchange, ImplicitAPI):
         request: dict = {
             'symbol': market['id'],
         }
-        response = await self.swapV2PrivateGetTradeMarginType(self.extend(request, params))
-        #
-        #     {
-        #         "code": 0,
-        #         "msg": "",
-        #         "data": {
-        #             "marginType": "CROSSED"
-        #         }
-        #     }
-        #
+        subType = None
+        response = None
+        subType, params = self.handle_sub_type_and_params('fetchMarginMode', market, params)
+        if subType == 'inverse':
+            response = await self.cswapV1PrivateGetTradeMarginType(self.extend(request, params))
+            #
+            #     {
+            #         "code": 0,
+            #         "msg": "",
+            #         "timestamp": 1721966069132,
+            #         "data": {
+            #             "symbol": "SOL-USD",
+            #             "marginType": "CROSSED"
+            #         }
+            #     }
+            #
+        else:
+            response = await self.swapV2PrivateGetTradeMarginType(self.extend(request, params))
+            #
+            #     {
+            #         "code": 0,
+            #         "msg": "",
+            #         "data": {
+            #             "marginType": "CROSSED"
+            #         }
+            #     }
+            #
         data = self.safe_dict(response, 'data', {})
         return self.parse_margin_mode(data, market)
 
     def parse_margin_mode(self, marginMode: dict, market=None) -> MarginMode:
+        marketId = self.safe_string(marginMode, 'symbol')
         marginType = self.safe_string_lower(marginMode, 'marginType')
         marginType = 'cross' if (marginType == 'crossed') else marginType
         return {
             'info': marginMode,
-            'symbol': market['symbol'],
+            'symbol': self.safe_symbol(marketId, market, '-', 'swap'),
             'marginMode': marginType,
         }