ccxt 4.3.88__py2.py3-none-any.whl → 4.3.90__py2.py3-none-any.whl

ccxt/pro/bingx.py

@@ -37,7 +37,8 @@ class bingx(ccxt.async_support.bingx):
                 'api': {
                     'ws': {
                         'spot': 'wss://open-api-ws.bingx.com/market',
-                        'swap': 'wss://open-api-swap.bingx.com/swap-market',
+                        'linear': 'wss://open-api-swap.bingx.com/swap-market',
+                        'inverse': 'wss://open-api-cswap-ws.bingx.com/market',
                     },
                 },
             },
@@ -95,17 +96,24 @@ class bingx(ccxt.async_support.bingx):
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/market.html#Subscribe%20to%2024-hour%20Price%20Change
         :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20to%2024-hour%20price%20changes
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/socket/market.html#Subscribe%20to%2024-Hour%20Price%20Change
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
         market = self.market(symbol)
-        marketType, query = self.handle_market_type_and_params('watchTicker', market, params)
-        url = self.safe_value(self.urls['api']['ws'], marketType)
-        if url is None:
-            raise BadRequest(self.id + ' watchTicker is not supported for ' + marketType + ' markets.')
+        marketType = None
+        subType = None
+        url = None
+        marketType, params = self.handle_market_type_and_params('watchTicker', market, params)
+        subType, params = self.handle_sub_type_and_params('watchTicker', market, params, 'linear')
+        if marketType == 'swap':
+            url = self.safe_string(self.urls['api']['ws'], subType)
+        else:
+            url = self.safe_string(self.urls['api']['ws'], marketType)
         subscriptionHash = market['id'] + '@ticker'
         messageHash = self.get_message_hash('ticker', market['symbol'])
         uuid = self.uuid()
@@ -115,7 +123,7 @@ class bingx(ccxt.async_support.bingx):
         }
         if marketType == 'swap':
             request['reqType'] = 'sub'
-        return await self.watch(url, messageHash, self.extend(request, query), subscriptionHash)
+        return await self.watch(url, messageHash, self.extend(request, params), subscriptionHash)
 
     def handle_ticker(self, client: Client, message):
         #
@@ -247,12 +255,16 @@ class bingx(ccxt.async_support.bingx):
         symbols = self.market_symbols(symbols, None, True, True, False)
         firstMarket = None
         marketType = None
+        subType = None
         symbolsDefined = (symbols is not None)
         if symbolsDefined:
             firstMarket = self.market(symbols[0])
         marketType, params = self.handle_market_type_and_params('watchTickers', firstMarket, params)
+        subType, params = self.handle_sub_type_and_params('watchTickers', firstMarket, params, 'linear')
         if marketType == 'spot':
             raise NotSupported(self.id + ' watchTickers is not supported for spot markets yet')
+        if subType == 'inverse':
+            raise NotSupported(self.id + ' watchTickers is not supported for inverse markets yet')
         messageHashes = []
         subscriptionHashes = ['all@ticker']
         if symbolsDefined:
@@ -262,7 +274,7 @@ class bingx(ccxt.async_support.bingx):
                 messageHashes.append(self.get_message_hash('ticker', market['symbol']))
         else:
             messageHashes.append(self.get_message_hash('ticker'))
-        url = self.safe_string(self.urls['api']['ws'], marketType)
+        url = self.safe_string(self.urls['api']['ws'], subType)
         uuid = self.uuid()
         request: dict = {
             'id': uuid,
@@ -289,12 +301,16 @@ class bingx(ccxt.async_support.bingx):
         symbols = self.market_symbols(symbols, None, True, True, False)
         firstMarket = None
         marketType = None
+        subType = None
         symbolsDefined = (symbols is not None)
         if symbolsDefined:
             firstMarket = self.market(symbols[0])
         marketType, params = self.handle_market_type_and_params('watchOrderBookForSymbols', firstMarket, params)
+        subType, params = self.handle_sub_type_and_params('watchOrderBookForSymbols', firstMarket, params, 'linear')
         if marketType == 'spot':
             raise NotSupported(self.id + ' watchOrderBookForSymbols is not supported for spot markets yet')
+        if subType == 'inverse':
+            raise NotSupported(self.id + ' watchOrderBookForSymbols is not supported for inverse markets yet')
         limit = self.get_order_book_limit_by_market_type(marketType, limit)
         interval = None
         interval, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'interval', 500)
@@ -309,7 +325,7 @@ class bingx(ccxt.async_support.bingx):
                 messageHashes.append(self.get_message_hash('orderbook', market['symbol']))
         else:
             messageHashes.append(self.get_message_hash('orderbook'))
-        url = self.safe_string(self.urls['api']['ws'], marketType)
+        url = self.safe_string(self.urls['api']['ws'], subType)
         uuid = self.uuid()
         request: dict = {
             'id': uuid,
@@ -329,6 +345,7 @@ class bingx(ccxt.async_support.bingx):
     async def watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], since: Int = None, limit: Int = None, params={}):
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20K-Line%20Data%20of%20all%20trading%20pairs
         :param str[][] symbolsAndTimeframes: array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
         :param int [since]: timestamp in ms of the earliest candle to fetch
         :param int [limit]: the maximum amount of candles to fetch
@@ -341,14 +358,19 @@ class bingx(ccxt.async_support.bingx):
         await self.load_markets()
         messageHashes = []
         marketType = None
+        subType = None
         chosenTimeframe = None
+        firstMarket = None
         if symbolsLength != 0:
             symbols = self.get_list_from_object_values(symbolsAndTimeframes, 0)
             symbols = self.market_symbols(symbols, None, True, True, False)
             firstMarket = self.market(symbols[0])
-            marketType, params = self.handle_market_type_and_params('watchOrderBookForSymbols', firstMarket, params)
-            if marketType == 'spot':
-                raise NotSupported(self.id + ' watchOrderBookForSymbols is not supported for spot markets yet')
+        marketType, params = self.handle_market_type_and_params('watchOHLCVForSymbols', firstMarket, params)
+        subType, params = self.handle_sub_type_and_params('watchOHLCVForSymbols', firstMarket, params, 'linear')
+        if marketType == 'spot':
+            raise NotSupported(self.id + ' watchOHLCVForSymbols is not supported for spot markets yet')
+        if subType == 'inverse':
+            raise NotSupported(self.id + ' watchOHLCVForSymbols is not supported for inverse markets yet')
         marketOptions = self.safe_dict(self.options, marketType)
         timeframes = self.safe_dict(marketOptions, 'timeframes', {})
         for i in range(0, len(symbolsAndTimeframes)):
@@ -363,7 +385,7 @@ class bingx(ccxt.async_support.bingx):
                 raise BadRequest(self.id + ' watchOHLCVForSymbols requires all timeframes to be the same')
             messageHashes.append(self.get_message_hash('ohlcv', market['symbol'], chosenTimeframe))
         subscriptionHash = 'all@kline_' + chosenTimeframe
-        url = self.safe_string(self.urls['api']['ws'], marketType)
+        url = self.safe_string(self.urls['api']['ws'], subType)
         uuid = self.uuid()
         request: dict = {
             'id': uuid,
@@ -404,8 +426,9 @@ class bingx(ccxt.async_support.bingx):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         watches information on multiple trades made in a market
-        :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/market.html#Subscription%20transaction%20by%20transaction
-        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20the%20Latest%20Trade%20Detail
+        :see: https://bingx-api.github.io/docs/#/spot/socket/market.html#Subscribe%20to%20tick-by-tick
+        :see: https://bingx-api.github.io/docs/#/swapV2/socket/market.html#Subscribe%20the%20Latest%20Trade%20Detail
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/socket/market.html#Subscription%20transaction%20by%20transaction
         :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
         :param int [limit]: the maximum number of order structures to retrieve
@@ -414,11 +437,16 @@ class bingx(ccxt.async_support.bingx):
         """
         await self.load_markets()
         market = self.market(symbol)
+        symbol = market['symbol']
         marketType = None
+        subType = None
+        url = None
         marketType, params = self.handle_market_type_and_params('watchTrades', market, params)
-        url = self.safe_value(self.urls['api']['ws'], marketType)
-        if url is None:
-            raise BadRequest(self.id + ' watchTrades is not supported for ' + marketType + ' markets.')
+        subType, params = self.handle_sub_type_and_params('watchTrades', market, params, 'linear')
+        if marketType == 'swap':
+            url = self.safe_string(self.urls['api']['ws'], subType)
+        else:
+            url = self.safe_string(self.urls['api']['ws'], marketType)
         rawHash = market['id'] + '@trade'
         messageHash = 'trade::' + symbol
         uuid = self.uuid()
@@ -435,8 +463,7 @@ class bingx(ccxt.async_support.bingx):
 
     def handle_trades(self, client: Client, message):
         #
-        # spot
-        # first snapshot
+        # spot: first snapshot
         #
         #    {
         #      "id": "d83b78ce-98be-4dc2-b847-12fe471b5bc5",
@@ -445,7 +472,7 @@ class bingx(ccxt.async_support.bingx):
         #      "timestamp": 1690214699854
         #    }
         #
-        # subsequent updates
+        # spot: subsequent updates
         #
         #     {
         #         "code": 0,
@@ -463,9 +490,7 @@ class bingx(ccxt.async_support.bingx):
         #         "success": True
         #     }
         #
-        #
-        # swap
-        # first snapshot
+        # linear swap: first snapshot
         #
         #    {
         #        "id": "2aed93b1-6e1e-4038-aeba-f5eeaec2ca48",
@@ -475,8 +500,7 @@ class bingx(ccxt.async_support.bingx):
         #        "data": null
         #    }
         #
-        # subsequent updates
-        #
+        # linear swap: subsequent updates
         #
         #    {
         #        "code": 0,
@@ -493,6 +517,32 @@ class bingx(ccxt.async_support.bingx):
         #        ]
         #    }
         #
+        # inverse swap: first snapshot
+        #
+        #     {
+        #         "code": 0,
+        #         "id": "a2e482ca-f71b-42f8-a83a-8ff85a713e64",
+        #         "msg": "SUCCESS",
+        #         "timestamp": 1722920589426
+        #     }
+        #
+        # inverse swap: subsequent updates
+        #
+        #     {
+        #         "code": 0,
+        #         "dataType": "BTC-USD@trade",
+        #         "data": {
+        #             "e": "trade",
+        #             "E": 1722920589665,
+        #             "s": "BTC-USD",
+        #             "t": "39125001",
+        #             "p": "55360.0",
+        #             "q": "1",
+        #             "T": 1722920589582,
+        #             "m": False
+        #         }
+        #     }
+        #
         data = self.safe_value(message, 'data', [])
         rawHash = self.safe_string(message, 'dataType')
         marketId = rawHash.split('@')[0]
@@ -520,6 +570,7 @@ class bingx(ccxt.async_support.bingx):
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/market.html#Subscribe%20Market%20Depth%20Data
         :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20Market%20Depth%20Data
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/socket/market.html#Subscribe%20to%20Limited%20Depth
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -527,17 +578,23 @@ class bingx(ccxt.async_support.bingx):
         """
         await self.load_markets()
         market = self.market(symbol)
-        marketType, query = self.handle_market_type_and_params('watchOrderBook', market, params)
+        marketType = None
+        subType = None
+        url = None
+        marketType, params = self.handle_market_type_and_params('watchOrderBook', market, params)
+        subType, params = self.handle_sub_type_and_params('watchOrderBook', market, params, 'linear')
+        if marketType == 'swap':
+            url = self.safe_string(self.urls['api']['ws'], subType)
+        else:
+            url = self.safe_string(self.urls['api']['ws'], marketType)
         limit = self.get_order_book_limit_by_market_type(marketType, limit)
         channelName = 'depth' + str(limit)
-        url = self.safe_value(self.urls['api']['ws'], marketType)
-        if url is None:
-            raise BadRequest(self.id + ' watchOrderBook is not supported for ' + marketType + ' markets.')
         interval = None
         if marketType != 'spot':
-            interval, params = self.handle_option_and_params(params, 'watchOrderBook', 'interval', 500)
-            self.check_required_argument('watchOrderBook', interval, 'interval', [100, 200, 500, 1000])
-            channelName = channelName + '@' + str(interval) + 'ms'
+            if not market['inverse']:
+                interval, params = self.handle_option_and_params(params, 'watchOrderBook', 'interval', 500)
+                self.check_required_argument('watchOrderBook', interval, 'interval', [100, 200, 500, 1000])
+                channelName = channelName + '@' + str(interval) + 'ms'
         subscriptionHash = market['id'] + '@' + channelName
         messageHash = self.get_message_hash('orderbook', market['symbol'])
         uuid = self.uuid()
@@ -547,24 +604,30 @@ class bingx(ccxt.async_support.bingx):
         }
         if marketType == 'swap':
             request['reqType'] = 'sub'
-        subscriptionArgs: dict = {
-            'limit': limit,
-            'interval': interval,
-            'params': params,
-        }
-        orderbook = await self.watch(url, messageHash, self.deep_extend(request, query), subscriptionHash, subscriptionArgs)
+        subscriptionArgs: dict = {}
+        if market['inverse']:
+            subscriptionArgs = {
+                'count': limit,
+                'params': params,
+            }
+        else:
+            subscriptionArgs = {
+                'level': limit,
+                'interval': interval,
+                'params': params,
+            }
+        orderbook = await self.watch(url, messageHash, self.deep_extend(request, params), subscriptionHash, subscriptionArgs)
         return orderbook.limit()
 
     def handle_delta(self, bookside, delta):
-        price = self.safe_float(delta, 0)
-        amount = self.safe_float(delta, 1)
+        price = self.safe_float_2(delta, 0, 'p')
+        amount = self.safe_float_2(delta, 1, 'a')
         bookside.store(price, amount)
 
     def handle_order_book(self, client: Client, message):
         #
         # spot
         #
-        #
         #    {
         #        "code": 0,
         #        "dataType": "BTC-USDT@depth20",
@@ -582,8 +645,7 @@ class bingx(ccxt.async_support.bingx):
         #        "success": True
         #    }
         #
-        # swap
-        #
+        # linear swap
         #
         #    {
         #        "code": 0,
@@ -601,6 +663,28 @@ class bingx(ccxt.async_support.bingx):
         #        }
         #    }
         #
+        # inverse swap
+        #
+        #     {
+        #         "code": 0,
+        #         "dataType": "BTC-USD@depth100",
+        #         "data": {
+        #             {
+        #                 "symbol": "BTC-USD",
+        #                 "bids": [
+        #                     {"p": "58074.2", "a": "1.422318", "v": "826.0"},
+        #                     ...
+        #                 ],
+        #                 "asks": [
+        #                     {"p": "62878.0", "a": "0.001590", "v": "1.0"},
+        #                     ...
+        #                 ],
+        #                 "aggPrecision": "0.1",
+        #                 "timestamp": 1723705093529
+        #             }
+        #         }
+        #     }
+        #
         data = self.safe_dict(message, 'data', {})
         dataType = self.safe_string(message, 'dataType')
         parts = dataType.split('@')
@@ -618,7 +702,11 @@ class bingx(ccxt.async_support.bingx):
             limit = self.safe_integer(subscription, 'limit')
             self.orderbooks[symbol] = self.order_book({}, limit)
         orderbook = self.orderbooks[symbol]
-        snapshot = self.parse_order_book(data, symbol, None, 'bids', 'asks', 0, 1)
+        snapshot = None
+        if market['inverse']:
+            snapshot = self.parse_order_book(data, symbol, None, 'bids', 'asks', 'p', 'a')
+        else:
+            snapshot = self.parse_order_book(data, symbol, None, 'bids', 'asks', 0, 1)
         orderbook.reset(snapshot)
         self.orderbooks[symbol] = orderbook
         messageHash = self.get_message_hash('orderbook', symbol)
@@ -641,8 +729,10 @@ class bingx(ccxt.async_support.bingx):
         #    }
         #
         # for spot, opening-time(t) is used instead of closing-time(T), to be compatible with fetchOHLCV
-        # for swap,(T) is the opening time
+        # for linear swap,(T) is the opening time
         timestamp = 't' if (market['spot']) else 'T'
+        if market['swap']:
+            timestamp = 't' if (market['inverse']) else 'T'
         return [
             self.safe_integer(ohlcv, timestamp),
             self.safe_number(ohlcv, 'o'),
@@ -654,7 +744,7 @@ class bingx(ccxt.async_support.bingx):
 
     def handle_ohlcv(self, client: Client, message):
         #
-        # spot
+        # spot:
         #
         #   {
         #       "code": 0,
@@ -680,7 +770,8 @@ class bingx(ccxt.async_support.bingx):
         #       "success": True
         #   }
         #
-        # swap
+        # linear swap:
+        #
         #    {
         #        "code": 0,
         #        "dataType": "BTC-USDT@kline_1m",
@@ -697,13 +788,26 @@ class bingx(ccxt.async_support.bingx):
         #        ]
         #    }
         #
+        # inverse swap:
+        #
+        #     {
+        #         "code": 0,
+        #         "timestamp": 1723769354547,
+        #         "dataType": "BTC-USD@kline_1m",
+        #         "data": {
+        #             "t": 1723769340000,
+        #             "o": 57485.1,
+        #             "c": 57468,
+        #             "l": 57464.9,
+        #             "h": 57485.1,
+        #             "a": 0.189663,
+        #             "v": 109,
+        #             "u": 92,
+        #             "s": "BTC-USD"
+        #         }
+        #     }
+        #
         isSwap = client.url.find('swap') >= 0
-        candles = None
-        if isSwap:
-            candles = self.safe_list(message, 'data', [])
-        else:
-            data = self.safe_dict(message, 'data', {})
-            candles = [self.safe_dict(data, 'K', {})]
         dataType = self.safe_string(message, 'dataType')
         parts = dataType.split('@')
         firstPart = parts[0]
@@ -711,6 +815,15 @@ class bingx(ccxt.async_support.bingx):
         marketId = self.safe_string(message, 's', firstPart)
         marketType = 'swap' if isSwap else 'spot'
         market = self.safe_market(marketId, None, None, marketType)
+        candles = None
+        if isSwap:
+            if market['inverse']:
+                candles = [self.safe_dict(message, 'data', {})]
+            else:
+                candles = self.safe_list(message, 'data', [])
+        else:
+            data = self.safe_dict(message, 'data', {})
+            candles = [self.safe_dict(data, 'K', {})]
         symbol = market['symbol']
         self.ohlcvs[symbol] = self.safe_value(self.ohlcvs, symbol, {})
         rawTimeframe = dataType.split('_')[1]
@@ -740,6 +853,7 @@ class bingx(ccxt.async_support.bingx):
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
         :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/market.html#K-line%20Streams
         :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20K-Line%20Data
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/socket/market.html#Subscribe%20to%20Latest%20Trading%20Pair%20K-Line
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -749,8 +863,15 @@ class bingx(ccxt.async_support.bingx):
         """
         await self.load_markets()
         market = self.market(symbol)
-        marketType, query = self.handle_market_type_and_params('watchOHLCV', market, params)
-        url = self.safe_value(self.urls['api']['ws'], marketType)
+        marketType = None
+        subType = None
+        url = None
+        marketType, params = self.handle_market_type_and_params('watchOHLCV', market, params)
+        subType, params = self.handle_sub_type_and_params('watchOHLCV', market, params, 'linear')
+        if marketType == 'swap':
+            url = self.safe_string(self.urls['api']['ws'], subType)
+        else:
+            url = self.safe_string(self.urls['api']['ws'], marketType)
         if url is None:
             raise BadRequest(self.id + ' watchOHLCV is not supported for ' + marketType + ' markets.')
         options = self.safe_value(self.options, marketType, {})
@@ -766,10 +887,10 @@ class bingx(ccxt.async_support.bingx):
         if marketType == 'swap':
             request['reqType'] = 'sub'
         subscriptionArgs: dict = {
-            'limit': limit,
+            'interval': rawTimeframe,
             'params': params,
         }
-        result = await self.watch(url, messageHash, self.extend(request, query), subscriptionHash, subscriptionArgs)
+        result = await self.watch(url, messageHash, self.extend(request, params), subscriptionHash, subscriptionArgs)
         ohlcv = result[2]
         if self.newUpdates:
             limit = ohlcv.getLimit(symbol, limit)
@@ -777,11 +898,12 @@ class bingx(ccxt.async_support.bingx):
 
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
-        :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/account.html#Subscription%20order%20update%20data
-        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
         watches information on multiple orders made by the user
-        :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
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/account.html#Subscription%20order%20update%20data
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Order%20update%20push
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/socket/account.html#Order%20update%20push
+        :param str [symbol]: unified market symbol of the market orders are made in
+        :param int [since]: the earliest time in ms to watch orders for
         :param int [limit]: the maximum number of order structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
@@ -789,11 +911,13 @@ class bingx(ccxt.async_support.bingx):
         await self.load_markets()
         await self.authenticate()
         type = None
+        subType = None
         market = None
         if symbol is not None:
             market = self.market(symbol)
             symbol = market['symbol']
         type, params = self.handle_market_type_and_params('watchOrders', market, params)
+        subType, params = self.handle_sub_type_and_params('watchOrders', market, params, 'linear')
         isSpot = (type == 'spot')
         spotHash = 'spot:private'
         swapHash = 'swap:private'
@@ -803,14 +927,21 @@ class bingx(ccxt.async_support.bingx):
         messageHash = spotMessageHash if isSpot else swapMessageHash
         if market is not None:
             messageHash += ':' + symbol
-        url = self.urls['api']['ws'][type] + '?listenKey=' + self.options['listenKey']
-        request = None
         uuid = self.uuid()
-        if isSpot:
+        baseUrl = None
+        request = None
+        if type == 'swap':
+            if subType == 'inverse':
+                raise NotSupported(self.id + ' watchOrders is not supported for inverse swap markets yet')
+            baseUrl = self.safe_string(self.urls['api']['ws'], subType)
+        else:
+            baseUrl = self.safe_string(self.urls['api']['ws'], type)
             request = {
                 'id': uuid,
+                'reqType': 'sub',
                 'dataType': 'spot.executionReport',
             }
+        url = baseUrl + '?listenKey=' + self.options['listenKey']
         orders = await self.watch(url, messageHash, request, subscriptionHash)
         if self.newUpdates:
             limit = orders.getLimit(symbol, limit)
@@ -818,40 +949,50 @@ class bingx(ccxt.async_support.bingx):
 
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/account.html#Subscription%20order%20update%20data
-        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
         watches information on multiple trades made by the user
-        :param str symbol: unified market symbol of the market trades were made in
-        :param int [since]: the earliest time in ms to trades orders for
-        :param int [limit]: the maximum number of trades structures to retrieve
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/account.html#Subscription%20order%20update%20data
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Order%20update%20push
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/socket/account.html#Order%20update%20push
+        :param str [symbol]: unified market symbol of the market the trades are made in
+        :param int [since]: the earliest time in ms to watch trades for
+        :param int [limit]: the maximum number of trade structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         await self.load_markets()
         await self.authenticate()
         type = None
+        subType = None
         market = None
         if symbol is not None:
             market = self.market(symbol)
             symbol = market['symbol']
-        type, params = self.handle_market_type_and_params('watchOrders', market, params)
+        type, params = self.handle_market_type_and_params('watchMyTrades', market, params)
+        subType, params = self.handle_sub_type_and_params('watchMyTrades', market, params, 'linear')
         isSpot = (type == 'spot')
-        spotSubHash = 'spot:private'
-        swapSubHash = 'swap:private'
-        subscriptionHash = spotSubHash if isSpot else swapSubHash
+        spotHash = 'spot:private'
+        swapHash = 'swap:private'
+        subscriptionHash = spotHash if isSpot else swapHash
         spotMessageHash = 'spot:mytrades'
         swapMessageHash = 'swap:mytrades'
         messageHash = spotMessageHash if isSpot else swapMessageHash
         if market is not None:
             messageHash += ':' + symbol
-        url = self.urls['api']['ws'][type] + '?listenKey=' + self.options['listenKey']
-        request = None
         uuid = self.uuid()
-        if isSpot:
+        baseUrl = None
+        request = None
+        if type == 'swap':
+            if subType == 'inverse':
+                raise NotSupported(self.id + ' watchMyTrades is not supported for inverse swap markets yet')
+            baseUrl = self.safe_string(self.urls['api']['ws'], subType)
+        else:
+            baseUrl = self.safe_string(self.urls['api']['ws'], type)
             request = {
                 'id': uuid,
+                'reqType': 'sub',
                 'dataType': 'spot.executionReport',
             }
+        url = baseUrl + '?listenKey=' + self.options['listenKey']
         trades = await self.watch(url, messageHash, request, subscriptionHash)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
@@ -859,16 +1000,19 @@ class bingx(ccxt.async_support.bingx):
 
     async def watch_balance(self, params={}) -> Balances:
         """
+        query for balance and get the amount of funds available for trading or funds locked in orders
         :see: https://bingx-api.github.io/docs/#/en-us/spot/socket/account.html#Subscription%20account%20balance%20push
         :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
-        query for balance and get the amount of funds available for trading or funds locked in orders
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/socket/account.html#Account%20balance%20and%20position%20update%20push
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
         await self.load_markets()
         await self.authenticate()
         type = None
+        subType = None
         type, params = self.handle_market_type_and_params('watchBalance', None, params)
+        subType, params = self.handle_sub_type_and_params('watchBalance', None, params, 'linear')
         isSpot = (type == 'spot')
         spotSubHash = 'spot:balance'
         swapSubHash = 'swap:private'
@@ -876,16 +1020,22 @@ class bingx(ccxt.async_support.bingx):
         swapMessageHash = 'swap:balance'
         messageHash = spotMessageHash if isSpot else swapMessageHash
         subscriptionHash = spotSubHash if isSpot else swapSubHash
-        url = self.urls['api']['ws'][type] + '?listenKey=' + self.options['listenKey']
         request = None
+        baseUrl = None
         uuid = self.uuid()
-        if type == 'spot':
+        if type == 'swap':
+            if subType == 'inverse':
+                raise NotSupported(self.id + ' watchBalance is not supported for inverse swap markets yet')
+            baseUrl = self.safe_string(self.urls['api']['ws'], subType)
+        else:
+            baseUrl = self.safe_string(self.urls['api']['ws'], type)
             request = {
                 'id': uuid,
                 'dataType': 'ACCOUNT_UPDATE',
             }
+        url = baseUrl + '?listenKey=' + self.options['listenKey']
         client = self.client(url)
-        self.set_balance_cache(client, type, subscriptionHash, params)
+        self.set_balance_cache(client, type, subType, subscriptionHash, params)
         fetchBalanceSnapshot = None
         awaitBalanceSnapshot = None
         fetchBalanceSnapshot, params = self.handle_option_and_params(params, 'watchBalance', 'fetchBalanceSnapshot', True)
@@ -894,7 +1044,7 @@ class bingx(ccxt.async_support.bingx):
             await client.future(type + ':fetchBalanceSnapshot')
         return await self.watch(url, messageHash, request, subscriptionHash)
 
-    def set_balance_cache(self, client: Client, type, subscriptionHash, params):
+    def set_balance_cache(self, client: Client, type, subType, subscriptionHash, params):
         if subscriptionHash in client.subscriptions:
             return
         fetchBalanceSnapshot = self.handle_option_and_params(params, 'watchBalance', 'fetchBalanceSnapshot', True)
@@ -902,12 +1052,12 @@ class bingx(ccxt.async_support.bingx):
             messageHash = type + ':fetchBalanceSnapshot'
             if not (messageHash in client.futures):
                 client.future(messageHash)
-                self.spawn(self.load_balance_snapshot, client, messageHash, type)
+                self.spawn(self.load_balance_snapshot, client, messageHash, type, subType)
         else:
             self.balance[type] = {}
 
-    async def load_balance_snapshot(self, client, messageHash, type):
-        response = await self.fetch_balance({'type': type})
+    async def load_balance_snapshot(self, client, messageHash, type, subType):
+        response = await self.fetch_balance({'type': type, 'subType': subType})
         self.balance[type] = self.extend(response, self.safe_value(self.balance, type, {}))
         # don't remove the future from the .futures cache
         future = client.futures[messageHash]
@@ -941,7 +1091,7 @@ class bingx(ccxt.async_support.bingx):
         try:
             await self.userAuthPrivatePutUserDataStream({'listenKey': listenKey})  # self.extend the expiry
         except Exception as error:
-            types = ['spot', 'swap']
+            types = ['spot', 'linear', 'inverse']
             for i in range(0, len(types)):
                 type = types[i]
                 url = self.urls['api']['ws'][type] + '?listenKey=' + listenKey