ccxt-ir 4.3.46.0.2__py2.py3-none-any.whl → 4.5.0__py2.py3-none-any.whl

ccxt/pro/bingx.py

@@ -5,23 +5,23 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
-from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Any, Balances, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import NetworkError
-from ccxt.base.precise import Precise
 
 
 class bingx(ccxt.async_support.bingx):
 
-    def describe(self):
+    def describe(self) -> Any:
         return self.deep_extend(super(bingx, self).describe(), {
             'has': {
                 'ws': True,
                 'watchTrades': True,
+                'watchTradesForSymbols': False,
                 'watchOrderBook': True,
                 'watchOrderBookForSymbols': True,
                 'watchOHLCV': True,
@@ -36,12 +36,13 @@ 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',
                     },
                 },
             },
             'options': {
-                'listenKeyRefreshRate': 3540000,  # 1 hour(59 mins so we have 1min to renew the token)
+                'listenKeyRefreshRate': 3540000,  # 1 hour(59 mins so we have 1 min to renew the token)
                 'ws': {
                     'gunzip': True,
                 },
@@ -85,6 +86,9 @@ class bingx(ccxt.async_support.bingx):
                     'depth': 100,  # 5, 10, 20, 50, 100
                     'interval': 500,  # 100, 200, 500, 1000
                 },
+                'watchTrades': {
+                    'ignoreDuplicates': True,
+                },
             },
             'streaming': {
                 'keepAlive': 1800000,  # 30 minutes
@@ -94,17 +98,26 @@ 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/swapV2/socket/market.html#Subscribe%20to%2024-hour%20price%20changes
+
+        https://bingx-api.github.io/docs/#/en-us/spot/socket/market.html#Subscribe%20to%2024-hour%20Price%20Change
+        https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20to%2024-hour%20price%20changes
+        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('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.')
+        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()
@@ -114,7 +127,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):
         #
@@ -237,7 +250,9 @@ class bingx(ccxt.async_support.bingx):
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
-        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20to%2024-hour%20price%20changes%20of%20all%20trading%20pairs
+
+        https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20to%2024-hour%20price%20changes%20of%20all%20trading%20pairs
+
         :param str[] symbols: unified symbol of the market to watch the tickers for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -246,12 +261,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:
@@ -261,7 +280,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,
@@ -279,7 +298,9 @@ class bingx(ccxt.async_support.bingx):
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
         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/swapV2/socket/market.html#Subscribe%20Market%20Depth%20Data%20of%20all%20trading%20pairs
+
+        https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20Market%20Depth%20Data%20of%20all%20trading%20pairs
+
         :param str[] symbols: unified array of symbols
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -288,12 +309,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)
@@ -308,7 +333,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,
@@ -328,6 +353,9 @@ 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
+
+        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
@@ -340,14 +368,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)):
@@ -362,7 +395,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,
@@ -403,37 +436,51 @@ 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/#/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
+
+        https://bingx-api.github.io/docs/#/spot/socket/market.html#Subscribe%20to%20tick-by-tick
+        https://bingx-api.github.io/docs/#/swapV2/socket/market.html#Subscribe%20the%20Latest%20Trade%20Detail
+        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
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict[]: a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure
+        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
         market = self.market(symbol)
-        marketType, query = 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.')
-        messageHash = market['id'] + '@trade'
+        symbol = market['symbol']
+        marketType = None
+        subType = None
+        url = None
+        marketType, params = self.handle_market_type_and_params('watchTrades', market, params)
+        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()
         request: dict = {
             'id': uuid,
-            'dataType': messageHash,
+            'dataType': rawHash,
         }
         if marketType == 'swap':
             request['reqType'] = 'sub'
-        trades = await self.watch(url, messageHash, self.extend(request, query), messageHash)
+        trades = await self.watch(url, messageHash, self.extend(request, params), messageHash)
         if self.newUpdates:
             limit = trades.getLimit(symbol, limit)
-        return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+        result = self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
+        if self.handle_option('watchTrades', 'ignoreDuplicates', True):
+            filtered = self.remove_repeated_trades_from_array(result)
+            filtered = self.sort_by(filtered, 'timestamp')
+            return filtered
+        return result
 
     def handle_trades(self, client: Client, message):
         #
-        # spot
-        # first snapshot
+        # spot: first snapshot
         #
         #    {
         #      "id": "d83b78ce-98be-4dc2-b847-12fe471b5bc5",
@@ -442,7 +489,7 @@ class bingx(ccxt.async_support.bingx):
         #      "timestamp": 1690214699854
         #    }
         #
-        # subsequent updates
+        # spot: subsequent updates
         #
         #     {
         #         "code": 0,
@@ -460,9 +507,7 @@ class bingx(ccxt.async_support.bingx):
         #         "success": True
         #     }
         #
-        #
-        # swap
-        # first snapshot
+        # linear swap: first snapshot
         #
         #    {
         #        "id": "2aed93b1-6e1e-4038-aeba-f5eeaec2ca48",
@@ -472,8 +517,7 @@ class bingx(ccxt.async_support.bingx):
         #        "data": null
         #    }
         #
-        # subsequent updates
-        #
+        # linear swap: subsequent updates
         #
         #    {
         #        "code": 0,
@@ -490,13 +534,40 @@ 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', [])
-        messageHash = self.safe_string(message, 'dataType')
-        marketId = messageHash.split('@')[0]
+        rawHash = self.safe_string(message, 'dataType')
+        marketId = rawHash.split('@')[0]
         isSwap = client.url.find('swap') >= 0
         marketType = 'swap' if isSwap else 'spot'
         market = self.safe_market(marketId, None, None, marketType)
         symbol = market['symbol']
+        messageHash = 'trade::' + symbol
         trades = None
         if isinstance(data, list):
             trades = self.parse_trades(data, market)
@@ -514,8 +585,11 @@ class bingx(ccxt.async_support.bingx):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
-        :see: https://bingx-api.github.io/docs/#/spot/socket/market.html#Subscribe%20Market%20Depth%20Data
-        :see: https://bingx-api.github.io/docs/#/swapV2/socket/market.html#Subscribe%20Market%20Depth%20Data
+
+        https://bingx-api.github.io/docs/#/en-us/spot/socket/market.html#Subscribe%20Market%20Depth%20Data
+        https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20Market%20Depth%20Data
+        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
@@ -523,17 +597,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()
@@ -543,59 +623,93 @@ 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,
+        #         "data":
+        #         {
+        #             "asks":[
+        #                 ["84119.73","0.000011"],
+        #                 ["84116.52","0.000014"],
+        #                 ["84116.40","0.000039"]
+        #             ],
+        #             "bids":[
+        #                 ["83656.98","2.570805"],
+        #                 ["83655.51","0.000347"],
+        #                 ["83654.59","0.000082"]
+        #             ],
+        #             "lastUpdateId":13565694850
+        #         },
+        #         "dataType":"BTC-USDT@depth100",
+        #         "success":true,
+        #         "timestamp":1743241379958
+        #     }
         #
-        #    {
-        #        "code": 0,
-        #        "dataType": "BTC-USDT@depth20",
-        #        "data": {
-        #          "bids": [
-        #            ['28852.9', "34.2621"],
-        #            ...
-        #          ],
-        #          "asks": [
-        #            ['28864.9', "23.4079"],
-        #            ...
-        #          ]
-        #        },
-        #        "dataType": "BTC-USDT@depth20",
-        #        "success": True
-        #    }
+        # linear swap
         #
-        # swap
+        #     {
+        #         "code":0,
+        #         "dataType":"BTC-USDT@depth100@500ms",
+        #         "ts":1743241563651,
+        #         "data":
+        #         {
+        #             "bids":[
+        #                 ["83363.2","0.1908"],
+        #                 ["83360.0","0.0003"],
+        #                 ["83356.5","0.0245"],
+        #             ],
+        #             "asks":[
+        #                 ["83495.0","0.0024"],
+        #                 ["83490.0","0.0001"],
+        #                 ["83488.0","0.0004"],
+        #             ]
+        #         }
+        #     }
         #
+        # inverse swap
         #
-        #    {
-        #        "code": 0,
-        #        "dataType": "BTC-USDT@depth20@100ms",  #or "all@depth20@100ms"
-        #        "data": {
-        #          "bids": [
-        #            ['28852.9', "34.2621"],
-        #            ...
-        #          ],
-        #          "asks": [
-        #            ['28864.9', "23.4079"],
-        #            ...
-        #          ],
-        #          "symbol": "BTC-USDT",  # self key exists only in "all" subscription
-        #        }
-        #    }
+        #     {
+        #         "code":0,
+        #         "dataType":"BTC-USD@depth100",
+        #         "data":{
+        #             "symbol":"BTC-USD",
+        #             "bids":[
+        #                 {"p":"83411.2","a":"2.979216","v":"2485.0"},
+        #                 {"p":"83411.1","a":"1.592114","v":"1328.0"},
+        #                 {"p":"83410.8","a":"2.656730","v":"2216.0"},
+        #             ],
+        #             "asks":[
+        #                 {"p":"88200.0","a":"0.344671","v":"304.0"},
+        #                 {"p":"88023.8","a":"0.045442","v":"40.0"},
+        #                 {"p":"88001.0","a":"0.003409","v":"3.0"},
+        #             ],
+        #             "aggPrecision":"0.1",
+        #             "timestamp":1743242290710
+        #         }
+        #     }
         #
         data = self.safe_dict(message, 'data', {})
         dataType = self.safe_string(message, 'dataType')
@@ -607,16 +721,24 @@ class bingx(ccxt.async_support.bingx):
         marketType = 'swap' if isSwap else 'spot'
         market = self.safe_market(marketId, None, None, marketType)
         symbol = market['symbol']
-        if self.safe_value(self.orderbooks, symbol) is None:
+        orderbook = self.safe_value(self.orderbooks, symbol)
+        if orderbook is None:
             # limit = [5, 10, 20, 50, 100]
             subscriptionHash = dataType
             subscription = client.subscriptions[subscriptionHash]
             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
+        timestamp = self.safe_integer_2(message, 'timestamp', 'ts')
+        timestamp = self.safe_integer_2(data, 'timestamp', 'ts', timestamp)
+        if market['inverse']:
+            snapshot = self.parse_order_book(data, symbol, timestamp, 'bids', 'asks', 'p', 'a')
+        else:
+            snapshot = self.parse_order_book(data, symbol, timestamp, 'bids', 'asks', 0, 1)
+        nonce = self.safe_integer(data, 'lastUpdateId')
+        snapshot['nonce'] = nonce
         orderbook.reset(snapshot)
-        self.orderbooks[symbol] = orderbook
         messageHash = self.get_message_hash('orderbook', symbol)
         client.resolve(orderbook, messageHash)
         # resolve for "all"
@@ -637,8 +759,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'),
@@ -650,7 +774,7 @@ class bingx(ccxt.async_support.bingx):
 
     def handle_ohlcv(self, client: Client, message):
         #
-        # spot
+        # spot:
         #
         #   {
         #       "code": 0,
@@ -676,7 +800,8 @@ class bingx(ccxt.async_support.bingx):
         #       "success": True
         #   }
         #
-        # swap
+        # linear swap:
+        #
         #    {
         #        "code": 0,
         #        "dataType": "BTC-USDT@kline_1m",
@@ -693,20 +818,42 @@ class bingx(ccxt.async_support.bingx):
         #        ]
         #    }
         #
-        data = self.safe_list(message, 'data', [])
-        candles = None
-        if isinstance(data, list):
-            candles = data
-        else:
-            candles = [self.safe_list(data, 'K', [])]
-        dataType = self.safe_string(message, 'dataType')
+        # 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
+        dataType = self.safe_string(message, 'dataType')
         parts = dataType.split('@')
         firstPart = parts[0]
         isAllEndpoint = (firstPart == 'all')
         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]
@@ -734,8 +881,11 @@ class bingx(ccxt.async_support.bingx):
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         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/#/spot/socket/market.html#K%E7%BA%BF%20Streams
-        :see: https://bingx-api.github.io/docs/#/swapV2/socket/market.html#Subscribe%20K-Line%20Data
+
+        https://bingx-api.github.io/docs/#/en-us/spot/socket/market.html#K-line%20Streams
+        https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20K-Line%20Data
+        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
@@ -745,8 +895,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, {})
@@ -762,10 +919,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)
@@ -773,11 +930,14 @@ 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/#/spot/socket/account.html#Subscription%20order%20update%20data
-        :see: https://bingx-api.github.io/docs/#/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
+
+        https://bingx-api.github.io/docs/#/en-us/spot/socket/account.html#Subscription%20order%20update%20data
+        https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Order%20update%20push
+        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>`
@@ -785,11 +945,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'
@@ -799,14 +961,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)
@@ -814,40 +983,52 @@ 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/#/spot/socket/account.html#Subscription%20order%20update%20data
-        :see: https://bingx-api.github.io/docs/#/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
+
+        https://bingx-api.github.io/docs/#/en-us/spot/socket/account.html#Subscription%20order%20update%20data
+        https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Order%20update%20push
+        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]{@link https://docs.ccxt.com/#/?id=trade-structure
+        :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)
@@ -855,16 +1036,21 @@ class bingx(ccxt.async_support.bingx):
 
     async def watch_balance(self, params={}) -> Balances:
         """
-        :see: https://bingx-api.github.io/docs/#/spot/socket/account.html#Subscription%20order%20update%20data
-        :see: https://bingx-api.github.io/docs/#/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
+
+        https://bingx-api.github.io/docs/#/en-us/spot/socket/account.html#Subscription%20account%20balance%20push
+        https://bingx-api.github.io/docs/#/en-us/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
+        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'
@@ -872,16 +1058,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)
@@ -890,7 +1082,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)
@@ -898,12 +1090,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]
@@ -937,7 +1129,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
@@ -1212,11 +1404,10 @@ class bingx(ccxt.async_support.bingx):
             balance = data[i]
             currencyId = self.safe_string(balance, 'a')
             code = self.safe_currency_code(currencyId)
-            account = self.balance[type][code] if (code in self.balance[type]) else self.account()
+            account = self.account()
+            account['info'] = balance
+            account['used'] = self.safe_string(balance, 'lk')
             account['free'] = self.safe_string(balance, 'wb')
-            balanceChange = self.safe_string(balance, 'bc')
-            if account['used'] is not None:
-                account['used'] = Precise.string_sub(self.safe_string(account, 'used'), balanceChange)
             self.balance[type][code] = account
         self.balance[type] = self.safe_balance(self.balance[type])
         client.resolve(self.balance[type], type + ':balance')