ccxt 4.3.33__py2.py3-none-any.whl → 4.3.34__py2.py3-none-any.whl

ccxt/pro/binance.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Int, Liquidation, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ArgumentsRequired
@@ -23,6 +23,10 @@ class binance(ccxt.async_support.binance):
             'has': {
                 'ws': True,
                 'watchBalance': True,
+                'watchLiquidations': True,
+                'watchLiquidationsForSymbols': True,
+                'watchMyLiquidations': True,
+                'watchMyLiquidationsForSymbols': True,
                 'watchBidsAsks': True,
                 'watchMyTrades': True,
                 'watchOHLCV': True,
@@ -107,6 +111,8 @@ class binance(ccxt.async_support.binance):
                 # get updates every 1000ms or 100ms
                 # or every 0ms in real-time for futures
                 'watchOrderBookRate': 100,
+                'liquidationsLimit': 1000,
+                'myLiquidationsLimit': 1000,
                 'tradesLimit': 1000,
                 'ordersLimit': 1000,
                 'OHLCVLimit': 1000,
@@ -131,6 +137,9 @@ class binance(ccxt.async_support.binance):
                     'fetchBalanceSnapshot': False,  # or True
                     'awaitBalanceSnapshot': True,  # whether to wait for the balance snapshot before providing updates
                 },
+                'watchLiquidationsForSymbols': {
+                    'defaultType': 'swap',
+                },
                 'watchPositions': {
                     'fetchPositionsSnapshot': True,  # or False
                     'awaitPositionsSnapshot': True,  # whether to wait for the positions snapshot before providing updates
@@ -159,7 +168,7 @@ class binance(ccxt.async_support.binance):
         self.options['requestId'][url] = newValue
         return newValue
 
-    def stream(self, type, subscriptionHash, numSubscriptions=1):
+    def stream(self, type: Str, subscriptionHash: Str, numSubscriptions=1):
         streamBySubscriptionsHash = self.safe_dict(self.options, 'streamBySubscriptionsHash', self.create_safe_dictionary())
         stream = self.safe_string(streamBySubscriptionsHash, subscriptionHash)
         if stream is None:
@@ -182,6 +191,324 @@ class binance(ccxt.async_support.binance):
             self.options['numSubscriptionsByStream'][stream] = subscriptionsByStream + numSubscriptions
         return stream
 
+    async def watch_liquidations(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the public liquidations of a trading pair
+        :see: https://binance-docs.github.io/apidocs/futures/en/#liquidation-order-streams
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#liquidation-order-streams
+        :param str symbol: unified CCXT market symbol
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the bitmex api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        return self.watch_liquidations_for_symbols([symbol], since, limit, params)
+
+    async def watch_liquidations_for_symbols(self, symbols: List[str] = None, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the public liquidations of a trading pair
+        :see: https://binance-docs.github.io/apidocs/futures/en/#all-market-liquidation-order-streams
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#all-market-liquidation-order-streams
+        :param str symbol: unified CCXT market symbol
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the bitmex api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        await self.load_markets()
+        subscriptionHashes = []
+        messageHashes = []
+        streamHash = 'liquidations'
+        symbols = self.market_symbols(symbols, None, True, True)
+        if self.is_empty(symbols):
+            subscriptionHashes.append('!' + 'forceOrder@arr')
+            messageHashes.append('liquidations')
+        else:
+            for i in range(0, len(symbols)):
+                market = self.market(symbols[i])
+                subscriptionHashes.append(market['id'] + '@forceOrder')
+                messageHashes.append('liquidations::' + symbols[i])
+            streamHash += '::' + ','.join(symbols)
+        firstMarket = self.get_market_from_symbols(symbols)
+        type = None
+        type, params = self.handle_market_type_and_params('watchLiquidationsForSymbols', firstMarket, params)
+        if type == 'spot':
+            raise BadRequest(self.id + 'watchLiquidationsForSymbols is not supported for swap symbols')
+        subType = None
+        subType, params = self.handle_sub_type_and_params('watchLiquidationsForSymbols', firstMarket, params)
+        if self.isLinear(type, subType):
+            type = 'future'
+        elif self.isInverse(type, subType):
+            type = 'delivery'
+        numSubscriptions = len(subscriptionHashes)
+        url = self.urls['api']['ws'][type] + '/' + self.stream(type, streamHash, numSubscriptions)
+        requestId = self.request_id(url)
+        request = {
+            'method': 'SUBSCRIBE',
+            'params': subscriptionHashes,
+            'id': requestId,
+        }
+        subscribe = {
+            'id': requestId,
+        }
+        newLiquidations = await self.watch_multiple(url, messageHashes, self.extend(request, params), subscriptionHashes, subscribe)
+        if self.newUpdates:
+            return newLiquidations
+        return self.filter_by_symbols_since_limit(self.liquidations, symbols, since, limit, True)
+
+    def handle_liquidation(self, client: Client, message):
+        #
+        # future
+        #    {
+        #        "e":"forceOrder",
+        #        "E":1698871323061,
+        #        "o":{
+        #           "s":"BTCUSDT",
+        #           "S":"BUY",
+        #           "o":"LIMIT",
+        #           "f":"IOC",
+        #           "q":"1.437",
+        #           "p":"35100.81",
+        #           "ap":"34959.70",
+        #           "X":"FILLED",
+        #           "l":"1.437",
+        #           "z":"1.437",
+        #           "T":1698871323059
+        #        }
+        #    }
+        # delivery
+        #    {
+        #        "e":"forceOrder",              # Event Type
+        #        "E": 1591154240950,            # Event Time
+        #        "o":{
+        #            "s":"BTCUSD_200925",       # Symbol
+        #            "ps": "BTCUSD",            # Pair
+        #            "S":"SELL",                # Side
+        #            "o":"LIMIT",               # Order Type
+        #            "f":"IOC",                 # Time in Force
+        #            "q":"1",                   # Original Quantity
+        #            "p":"9425.5",              # Price
+        #            "ap":"9496.5",             # Average Price
+        #            "X":"FILLED",              # Order Status
+        #            "l":"1",                   # Order Last Filled Quantity
+        #            "z":"1",                   # Order Filled Accumulated Quantity
+        #            "T": 1591154240949,        # Order Trade Time
+        #        }
+        #    }
+        #
+        rawLiquidation = self.safe_value(message, 'o', {})
+        marketId = self.safe_string(rawLiquidation, 's')
+        market = self.safe_market(marketId, None, '', 'contract')
+        symbol = market['symbol']
+        liquidation = self.parse_ws_liquidation(rawLiquidation, market)
+        liquidations = self.safe_value(self.liquidations, symbol)
+        if liquidations is None:
+            limit = self.safe_integer(self.options, 'liquidationsLimit', 1000)
+            liquidations = ArrayCache(limit)
+        liquidations.append(liquidation)
+        self.liquidations[symbol] = liquidations
+        client.resolve([liquidation], 'liquidations')
+        client.resolve([liquidation], 'liquidations::' + symbol)
+
+    def parse_ws_liquidation(self, liquidation, market=None):
+        #
+        # future
+        #    {
+        #        "s":"BTCUSDT",
+        #        "S":"BUY",
+        #        "o":"LIMIT",
+        #        "f":"IOC",
+        #        "q":"1.437",
+        #        "p":"35100.81",
+        #        "ap":"34959.70",
+        #        "X":"FILLED",
+        #        "l":"1.437",
+        #        "z":"1.437",
+        #        "T":1698871323059
+        #    }
+        # delivery
+        #    {
+        #        "s":"BTCUSD_200925",       # Symbol
+        #        "ps": "BTCUSD",            # Pair
+        #        "S":"SELL",                # Side
+        #        "o":"LIMIT",               # Order Type
+        #        "f":"IOC",                 # Time in Force
+        #        "q":"1",                   # Original Quantity
+        #        "p":"9425.5",              # Price
+        #        "ap":"9496.5",             # Average Price
+        #        "X":"FILLED",              # Order Status
+        #        "l":"1",                   # Order Last Filled Quantity
+        #        "z":"1",                   # Order Filled Accumulated Quantity
+        #        "T": 1591154240949,        # Order Trade Time
+        #    }
+        # myLiquidation
+        #    {
+        #        "s":"BTCUSDT",              # Symbol
+        #        "c":"TEST",                 # Client Order Id
+        #          # special client order id:
+        #          # starts with "autoclose-": liquidation order
+        #          # "adl_autoclose": ADL auto close order
+        #          # "settlement_autoclose-": settlement order for delisting or delivery
+        #        "S":"SELL",                 # Side
+        #        "o":"TRAILING_STOP_MARKET",  # Order Type
+        #        "f":"GTC",                  # Time in Force
+        #        "q":"0.001",                # Original Quantity
+        #        "p":"0",                    # Original Price
+        #        "ap":"0",                   # Average Price
+        #        "sp":"7103.04",             # Stop Price. Please ignore with TRAILING_STOP_MARKET order
+        #        "x":"NEW",                  # Execution Type
+        #        "X":"NEW",                  # Order Status
+        #        "i":8886774,                # Order Id
+        #        "l":"0",                    # Order Last Filled Quantity
+        #        "z":"0",                    # Order Filled Accumulated Quantity
+        #        "L":"0",                    # Last Filled Price
+        #        "N":"USDT",                 # Commission Asset, will not push if no commission
+        #        "n":"0",                    # Commission, will not push if no commission
+        #        "T":1568879465650,          # Order Trade Time
+        #        "t":0,                      # Trade Id
+        #        "b":"0",                    # Bids Notional
+        #        "a":"9.91",                 # Ask Notional
+        #        "m":false,                  # Is self trade the maker side?
+        #        "R":false,                  # Is self reduce only
+        #        "wt":"CONTRACT_PRICE",      # Stop Price Working Type
+        #        "ot":"TRAILING_STOP_MARKET",// Original Order Type
+        #        "ps":"LONG",                # Position Side
+        #        "cp":false,                 # If Close-All, pushed with conditional order
+        #        "AP":"7476.89",             # Activation Price, only puhed with TRAILING_STOP_MARKET order
+        #        "cr":"5.0",                 # Callback Rate, only puhed with TRAILING_STOP_MARKET order
+        #        "pP": False,                # If price protection is turned on
+        #        "si": 0,                    # ignore
+        #        "ss": 0,                    # ignore
+        #        "rp":"0",                   # Realized Profit of the trade
+        #        "V":"EXPIRE_TAKER",         # STP mode
+        #        "pm":"OPPONENT",            # Price match mode
+        #        "gtd":0                     # TIF GTD order auto cancel time
+        #    }
+        #
+        marketId = self.safe_string(liquidation, 's')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_integer(liquidation, 'T')
+        return self.safe_liquidation({
+            'info': liquidation,
+            'symbol': self.safe_symbol(marketId, market),
+            'contracts': self.safe_number(liquidation, 'l'),
+            'contractSize': self.safe_number(market, 'contractSize'),
+            'price': self.safe_number(liquidation, 'ap'),
+            'baseValue': None,
+            'quoteValue': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+        })
+
+    async def watch_my_liquidations(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the private liquidations of a trading pair
+        :see: https://binance-docs.github.io/apidocs/futures/en/#event-order-update
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#event-order-update
+        :param str symbol: unified CCXT market symbol
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the bitmex api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        return self.watch_my_liquidations_for_symbols([symbol], since, limit, params)
+
+    async def watch_my_liquidations_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the private liquidations of a trading pair
+        :see: https://binance-docs.github.io/apidocs/futures/en/#event-order-update
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#event-order-update
+        :param str symbol: unified CCXT market symbol
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the bitmex api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True, True, True)
+        market = self.get_market_from_symbols(symbols)
+        messageHashes = ['myLiquidations']
+        if not self.is_empty(symbols):
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                messageHashes.append('myLiquidations::' + symbol)
+        type = None
+        type, params = self.handle_market_type_and_params('watchMyLiquidationsForSymbols', market, params)
+        subType = None
+        subType, params = self.handle_sub_type_and_params('watchMyLiquidationsForSymbols', market, params)
+        if self.isLinear(type, subType):
+            type = 'future'
+        elif self.isInverse(type, subType):
+            type = 'delivery'
+        await self.authenticate(params)
+        url = self.urls['api']['ws'][type] + '/' + self.options[type]['listenKey']
+        message = None
+        newLiquidations = await self.watch_multiple(url, messageHashes, message, [type])
+        if self.newUpdates:
+            return newLiquidations
+        return self.filter_by_symbols_since_limit(self.liquidations, symbols, since, limit)
+
+    def handle_my_liquidation(self, client: Client, message):
+        #
+        #    {
+        #        "s":"BTCUSDT",              # Symbol
+        #        "c":"TEST",                 # Client Order Id
+        #          # special client order id:
+        #          # starts with "autoclose-": liquidation order
+        #          # "adl_autoclose": ADL auto close order
+        #          # "settlement_autoclose-": settlement order for delisting or delivery
+        #        "S":"SELL",                 # Side
+        #        "o":"TRAILING_STOP_MARKET",  # Order Type
+        #        "f":"GTC",                  # Time in Force
+        #        "q":"0.001",                # Original Quantity
+        #        "p":"0",                    # Original Price
+        #        "ap":"0",                   # Average Price
+        #        "sp":"7103.04",             # Stop Price. Please ignore with TRAILING_STOP_MARKET order
+        #        "x":"NEW",                  # Execution Type
+        #        "X":"NEW",                  # Order Status
+        #        "i":8886774,                # Order Id
+        #        "l":"0",                    # Order Last Filled Quantity
+        #        "z":"0",                    # Order Filled Accumulated Quantity
+        #        "L":"0",                    # Last Filled Price
+        #        "N":"USDT",                 # Commission Asset, will not push if no commission
+        #        "n":"0",                    # Commission, will not push if no commission
+        #        "T":1568879465650,          # Order Trade Time
+        #        "t":0,                      # Trade Id
+        #        "b":"0",                    # Bids Notional
+        #        "a":"9.91",                 # Ask Notional
+        #        "m":false,                  # Is self trade the maker side?
+        #        "R":false,                  # Is self reduce only
+        #        "wt":"CONTRACT_PRICE",      # Stop Price Working Type
+        #        "ot":"TRAILING_STOP_MARKET",// Original Order Type
+        #        "ps":"LONG",                # Position Side
+        #        "cp":false,                 # If Close-All, pushed with conditional order
+        #        "AP":"7476.89",             # Activation Price, only puhed with TRAILING_STOP_MARKET order
+        #        "cr":"5.0",                 # Callback Rate, only puhed with TRAILING_STOP_MARKET order
+        #        "pP": False,                # If price protection is turned on
+        #        "si": 0,                    # ignore
+        #        "ss": 0,                    # ignore
+        #        "rp":"0",                   # Realized Profit of the trade
+        #        "V":"EXPIRE_TAKER",         # STP mode
+        #        "pm":"OPPONENT",            # Price match mode
+        #        "gtd":0                     # TIF GTD order auto cancel time
+        #    }
+        #
+        orderType = self.safe_string(message, 'o')
+        if orderType != 'LIQUIDATION':
+            return
+        marketId = self.safe_string(message, 's')
+        market = self.safe_market(marketId)
+        symbol = self.safe_symbol(marketId)
+        liquidation = self.parse_ws_liquidation(message, market)
+        myLiquidations = self.safe_value(self.myLiquidations, symbol)
+        if myLiquidations is None:
+            limit = self.safe_integer(self.options, 'myLiquidationsLimit', 1000)
+            myLiquidations = ArrayCache(limit)
+        myLiquidations.append(liquidation)
+        self.myLiquidations[symbol] = myLiquidations
+        client.resolve([liquidation], 'myLiquidations')
+        client.resolve([liquidation], 'myLiquidations::' + symbol)
+
     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
@@ -2590,6 +2917,7 @@ class binance(ccxt.async_support.binance):
             message = self.safe_dict(message, 'o', message)
         self.handle_my_trade(client, message)
         self.handle_order(client, message)
+        self.handle_my_liquidation(client, message)
 
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
         """
@@ -3131,6 +3459,7 @@ class binance(ccxt.async_support.binance):
             'ACCOUNT_UPDATE': self.handle_acount_update,
             'executionReport': self.handle_order_update,
             'ORDER_TRADE_UPDATE': self.handle_order_update,
+            'forceOrder': self.handle_liquidation,
         }
         event = self.safe_string(message, 'e')
         if isinstance(message, list):

ccxt/pro/bitmex.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Int, Liquidation, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -21,6 +21,10 @@ class bitmex(ccxt.async_support.bitmex):
             'has': {
                 'ws': True,
                 'watchBalance': True,
+                'watchLiquidations': True,
+                'watchLiquidationsForSymbols': True,
+                'watchMyLiquidations': None,
+                'watchMyLiquidationsForSymbols': None,
                 'watchMyTrades': True,
                 'watchOHLCV': True,
                 'watchOrderBook': True,
@@ -350,6 +354,98 @@ class bitmex(ccxt.async_support.bitmex):
             client.resolve(fullParsedTicker, 'alltickers')
         return message
 
+    async def watch_liquidations(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the public liquidations of a trading pair
+        :see: https://www.bitmex.com/app/wsAPI#Liquidation
+        :param str symbol: unified CCXT market symbol
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the bitmex api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        return self.watch_liquidations_for_symbols([symbol], since, limit, params)
+
+    async def watch_liquidations_for_symbols(self, symbols: List[str] = None, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the public liquidations of a trading pair
+        :see: https://www.bitmex.com/app/wsAPI#Liquidation
+        :param str symbol: unified CCXT market symbol
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the bitmex api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True, True)
+        messageHashes = []
+        subscriptionHashes = []
+        if self.is_empty(symbols):
+            subscriptionHashes.append('liquidation')
+            messageHashes.append('liquidations')
+        else:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                market = self.market(symbol)
+                subscriptionHashes.append('liquidation:' + market['id'])
+                messageHashes.append('liquidations::' + symbol)
+        url = self.urls['api']['ws']
+        request = {
+            'op': 'subscribe',
+            'args': subscriptionHashes,
+        }
+        newLiquidations = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), subscriptionHashes)
+        if self.newUpdates:
+            return newLiquidations
+        return self.filter_by_symbols_since_limit(self.liquidations, symbols, since, limit, True)
+
+    def handle_liquidation(self, client: Client, message):
+        #
+        #    {
+        #        "table":"liquidation",
+        #        "action":"partial",
+        #        "keys":[
+        #           "orderID"
+        #        ],
+        #        "types":{
+        #           "orderID":"guid",
+        #           "symbol":"symbol",
+        #           "side":"symbol",
+        #           "price":"float",
+        #           "leavesQty":"long"
+        #        },
+        #        "filter":{},
+        #        "data":[
+        #           {
+        #              "orderID":"e0a568ee-7830-4428-92c3-73e82b9576ce",
+        #              "symbol":"XPLAUSDT",
+        #              "side":"Sell",
+        #              "price":0.206,
+        #              "leavesQty":340
+        #           }
+        #        ]
+        #    }
+        #
+        rawLiquidations = self.safe_value(message, 'data', [])
+        newLiquidations = []
+        for i in range(0, len(rawLiquidations)):
+            rawLiquidation = rawLiquidations[i]
+            liquidation = self.parse_liquidation(rawLiquidation)
+            symbol = liquidation['symbol']
+            liquidations = self.safe_value(self.liquidations, symbol)
+            if liquidations is None:
+                limit = self.safe_integer(self.options, 'liquidationsLimit', 1000)
+                liquidations = ArrayCache(limit)
+            liquidations.append(liquidation)
+            self.liquidations[symbol] = liquidations
+            newLiquidations.append(liquidation)
+        client.resolve(newLiquidations, 'liquidations')
+        liquidationsBySymbol = self.index_by(newLiquidations, 'symbol')
+        symbols = list(liquidationsBySymbol.keys())
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            client.resolve(liquidationsBySymbol[symbol], 'liquidations::' + symbol)
+
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders
@@ -1541,6 +1637,7 @@ class bitmex(ccxt.async_support.bitmex):
                 'order': self.handle_orders,
                 'execution': self.handle_my_trades,
                 'margin': self.handle_balance,
+                'liquidation': self.handle_liquidation,
                 'position': self.handle_positions,
             }
             method = self.safe_value(methods, table)

ccxt/pro/bybit.py

@@ -7,7 +7,7 @@ import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import asyncio
 import hashlib
-from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Int, Liquidation, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -32,6 +32,10 @@ class bybit(ccxt.async_support.bybit):
                 'fetchTradesWs': False,
                 'fetchBalanceWs': False,
                 'watchBalance': True,
+                'watchLiquidations': True,
+                'watchLiquidationsForSymbols': False,
+                'watchMyLiquidations': False,
+                'watchMyLiquidationsForSymbols': False,
                 'watchMyTrades': True,
                 'watchOHLCV': True,
                 'watchOHLCVForSymbols': False,
@@ -1124,6 +1128,82 @@ class bybit(ccxt.async_support.bybit):
                 client.resolve(positions, messageHash)
         client.resolve(newPositions, 'positions')
 
+    async def watch_liquidations(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the public liquidations of a trading pair
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/liquidation
+        :param str symbol: unified CCXT market symbol
+        :param int [since]: the earliest time in ms to fetch liquidations for
+        :param int [limit]: the maximum number of liquidation structures to retrieve
+        :param dict [params]: exchange specific parameters for the bitmex api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        url = self.get_url_by_market_type(symbol, False, 'watchLiquidations', params)
+        params = self.clean_params(params)
+        messageHash = 'liquidations::' + symbol
+        topic = 'liquidation.' + market['id']
+        newLiquidation = await self.watch_topics(url, [messageHash], [topic], params)
+        if self.newUpdates:
+            return [newLiquidation]
+        return self.filter_by_symbols_since_limit(self.liquidations, [symbol], since, limit, True)
+
+    def handle_liquidation(self, client: Client, message):
+        #
+        #   {
+        #       "data": {
+        #           "price": "0.03803",
+        #           "side": "Buy",
+        #           "size": "1637",
+        #           "symbol": "GALAUSDT",
+        #           "updatedTime": 1673251091822
+        #       },
+        #       "topic": "liquidation.GALAUSDT",
+        #       "ts": 1673251091822,
+        #       "type": "snapshot"
+        #   }
+        #
+        rawLiquidation = self.safe_dict(message, 'data', {})
+        marketId = self.safe_string(rawLiquidation, 'symbol')
+        market = self.safe_market(marketId, None, '', 'contract')
+        symbol = self.safe_symbol(marketId)
+        liquidation = self.parse_ws_liquidation(rawLiquidation, market)
+        liquidations = self.safe_value(self.liquidations, symbol)
+        if liquidations is None:
+            limit = self.safe_integer(self.options, 'liquidationsLimit', 1000)
+            liquidations = ArrayCache(limit)
+        liquidations.append(liquidation)
+        self.liquidations[symbol] = liquidations
+        client.resolve([liquidation], 'liquidations')
+        client.resolve([liquidation], 'liquidations::' + symbol)
+
+    def parse_ws_liquidation(self, liquidation, market=None):
+        #
+        #    {
+        #        "price": "0.03803",
+        #        "side": "Buy",
+        #        "size": "1637",
+        #        "symbol": "GALAUSDT",
+        #        "updatedTime": 1673251091822
+        #    }
+        #
+        marketId = self.safe_string(liquidation, 'symbol')
+        market = self.safe_market(marketId, market, '', 'contract')
+        timestamp = self.safe_integer(liquidation, 'updatedTime')
+        return self.safe_liquidation({
+            'info': liquidation,
+            'symbol': self.safe_symbol(marketId, market),
+            'contracts': self.safe_number(liquidation, 'size'),
+            'contractSize': self.safe_number(market, 'contractSize'),
+            'price': self.safe_number(liquidation, 'price'),
+            'baseValue': None,
+            'quoteValue': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+        })
+
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
@@ -1830,6 +1910,7 @@ class bybit(ccxt.async_support.bybit):
             'ticketInfo': self.handle_my_trades,
             'user.openapi.perp.trade': self.handle_my_trades,
             'position': self.handle_positions,
+            'liquidation': self.handle_liquidation,
             'pong': self.handle_pong,
             'order.create': self.handle_order_ws,
             'order.amend': self.handle_order_ws,