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

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,

ccxt/pro/gate.py

@@ -6,13 +6,14 @@
 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 AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InvalidNonce
+from ccxt.base.precise import Precise
 
 
 class gate(ccxt.async_support.gate):
@@ -30,6 +31,10 @@ class gate(ccxt.async_support.gate):
                 'watchOHLCV': True,
                 'watchBalance': True,
                 'watchOrders': True,
+                'watchLiquidations': False,
+                'watchLiquidationsForSymbols': False,
+                'watchMyLiquidations': True,
+                'watchMyLiquidationsForSymbols': True,
                 'watchPositions': True,
             },
             'urls': {
@@ -963,6 +968,172 @@ class gate(ccxt.async_support.gate):
             client.resolve(self.orders, messageHash)
         client.resolve(self.orders, 'orders')
 
+    async def watch_my_liquidations(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the public liquidations of a trading pair
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#liquidates-api
+        :see: https://www.gate.io/docs/developers/delivery/ws/en/#liquidates-api
+        :see: https://www.gate.io/docs/developers/options/ws/en/#liquidates-channel
+        :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] = None, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the private liquidations of a trading pair
+        :see: https://www.gate.io/docs/developers/futures/ws/en/#liquidates-api
+        :see: https://www.gate.io/docs/developers/delivery/ws/en/#liquidates-api
+        :see: https://www.gate.io/docs/developers/options/ws/en/#liquidates-channel
+        :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 gate 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)
+        market = self.get_market_from_symbols(symbols)
+        type = None
+        query = None
+        type, query = self.handle_market_type_and_params('watchMyLiquidationsForSymbols', market, params)
+        typeId = self.get_supported_mapping(type, {
+            'future': 'futures',
+            'swap': 'futures',
+            'option': 'options',
+        })
+        subType = None
+        subType, query = self.handle_sub_type_and_params('watchMyLiquidationsForSymbols', market, query)
+        isInverse = (subType == 'inverse')
+        url = self.get_url_by_market_type(type, isInverse)
+        payload = []
+        messageHash = ''
+        if self.is_empty(symbols):
+            if typeId != 'futures' and not isInverse:
+                raise BadRequest(self.id + ' watchMyLiquidationsForSymbols() does not support listening to all symbols, you must call watchMyLiquidations() instead for each symbol you wish to watch.')
+            messageHash = 'myLiquidations'
+            payload.append('not all')
+        else:
+            symbolsLength = len(symbols)
+            if symbolsLength != 1:
+                raise BadRequest(self.id + ' watchMyLiquidationsForSymbols() only allows one symbol at a time. To listen to several symbols call watchMyLiquidationsForSymbols() several times.')
+            messageHash = 'myLiquidations::' + symbols[0]
+            payload.append(market['id'])
+        channel = typeId + '.liquidates'
+        newLiquidations = await self.subscribe_private(url, messageHash, payload, channel, query, True)
+        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 / delivery
+        #     {
+        #         "channel":"futures.liquidates",
+        #         "event":"update",
+        #         "time":1541505434,
+        #         "time_ms":1541505434123,
+        #         "result":[
+        #            {
+        #               "entry_price":209,
+        #               "fill_price":215.1,
+        #               "left":0,
+        #               "leverage":0.0,
+        #               "liq_price":213,
+        #               "margin":0.007816722941,
+        #               "mark_price":213,
+        #               "order_id":4093362,
+        #               "order_price":215.1,
+        #               "size":-124,
+        #               "time":1541486601,
+        #               "time_ms":1541486601123,
+        #               "contract":"BTC_USD",
+        #               "user":"1040xxxx"
+        #            }
+        #         ]
+        #     }
+        # option
+        #    {
+        #        "channel":"options.liquidates",
+        #        "event":"update",
+        #        "time":1630654851,
+        #        "result":[
+        #           {
+        #              "user":"1xxxx",
+        #              "init_margin":1190,
+        #              "maint_margin":1042.5,
+        #              "order_margin":0,
+        #              "time":1639051907,
+        #              "time_ms":1639051907000
+        #           }
+        #        ]
+        #    }
+        #
+        rawLiquidations = self.safe_list(message, 'result', [])
+        newLiquidations = []
+        for i in range(0, len(rawLiquidations)):
+            rawLiquidation = rawLiquidations[i]
+            liquidation = self.parse_ws_liquidation(rawLiquidation)
+            symbol = self.safe_string(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
+            client.resolve(liquidations, 'myLiquidations::' + symbol)
+        client.resolve(newLiquidations, 'myLiquidations')
+
+    def parse_ws_liquidation(self, liquidation, market=None):
+        #
+        # future / delivery
+        #    {
+        #        "entry_price": 209,
+        #        "fill_price": 215.1,
+        #        "left": 0,
+        #        "leverage": 0.0,
+        #        "liq_price": 213,
+        #        "margin": 0.007816722941,
+        #        "mark_price": 213,
+        #        "order_id": 4093362,
+        #        "order_price": 215.1,
+        #        "size": -124,
+        #        "time": 1541486601,
+        #        "time_ms": 1541486601123,
+        #        "contract": "BTC_USD",
+        #        "user": "1040xxxx"
+        #    }
+        # option
+        #    {
+        #        "user": "1xxxx",
+        #        "init_margin": 1190,
+        #        "maint_margin": 1042.5,
+        #        "order_margin": 0,
+        #        "time": 1639051907,
+        #        "time_ms": 1639051907000
+        #    }
+        #
+        marketId = self.safe_string(liquidation, 'contract')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_integer(liquidation, 'time_ms')
+        originalSize = self.safe_string(liquidation, 'size')
+        left = self.safe_string(liquidation, 'left')
+        amount = Precise.string_abs(Precise.string_sub(originalSize, left))
+        return self.safe_liquidation({
+            'info': liquidation,
+            'symbol': self.safe_symbol(marketId, market),
+            'contracts': self.parse_number(amount),
+            'contractSize': self.safe_number(market, 'contractSize'),
+            'price': self.safe_number(liquidation, 'fill_price'),
+            'baseValue': None,
+            'quoteValue': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+        })
+
     def handle_error_message(self, client: Client, message):
         # {
         #     "time": 1647274664,
@@ -1126,6 +1297,7 @@ class gate(ccxt.async_support.gate):
             'trades': self.handle_trades,
             'order_book_update': self.handle_order_book,
             'balances': self.handle_balance,
+            'liquidates': self.handle_liquidation,
         }
         method = self.safe_value(v4Methods, channelType)
         if method is not None:

ccxt/pro/kraken.py

@@ -1230,7 +1230,7 @@ class kraken(ccxt.async_support.kraken):
         messageHashes = []
         for i in range(0, len(symbols)):
             messageHashes.append(self.get_message_hash(unifiedName, None, self.symbol(symbols[i])))
-        # for WS subscriptions, we can't use .market_ids(symbols), instead a custom is field needed
+        # for WS subscriptions, we can't use .marketIds(symbols), instead a custom is field needed
         markets = self.markets_for_symbols(symbols)
         wsMarketIds = []
         for i in range(0, len(markets)):

ccxt/pro/kucoinfutures.py

@@ -18,6 +18,10 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         return self.deep_extend(super(kucoinfutures, self).describe(), {
             'has': {
                 'ws': True,
+                'watchLiquidations': False,
+                'watchLiquidatinsForSymbols': False,
+                'watchMyLiquidations': None,
+                'watchMyLiquidationsForSymbols': None,
                 'watchTicker': True,
                 'watchTickers': True,
                 'watchBidsAsks': True,

ccxt/pro/okx.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, FundingRate, FundingRates, Trade
+from ccxt.base.types import Balances, Int, Liquidation, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -29,6 +29,10 @@ class okx(ccxt.async_support.okx):
                 'watchTradesForSymbols': True,
                 'watchOrderBookForSymbols': True,
                 'watchBalance': True,
+                'watchLiquidations': 'emulated',
+                'watchLiquidationsForSymbols': True,
+                'watchMyLiquidations': 'emulated',
+                'watchMyLiquidationsForSymbols': True,
                 'watchOHLCV': True,
                 'watchOHLCVForSymbols': True,
                 'watchOrders': True,
@@ -399,6 +403,240 @@ class okx(ccxt.async_support.okx):
                 client.resolve(tickers, messageHash)
         return message
 
+    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.okx.com/docs-v5/en/#public-data-websocket-liquidation-orders-channel
+        :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 okx 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)
+        messageHash = 'liquidations'
+        if symbols is not None:
+            messageHash += '::' + ','.join(symbols)
+        market = self.get_market_from_symbols(symbols)
+        type = None
+        type, params = self.handle_market_type_and_params('watchliquidationsForSymbols', market, params)
+        channel = 'liquidation-orders'
+        if type == 'spot':
+            type = 'SWAP'
+        elif type == 'future':
+            type = 'futures'
+        uppercaseType = type.upper()
+        request = {
+            'instType': uppercaseType,
+        }
+        newLiquidations = await self.subscribe('public', messageHash, channel, None, self.extend(request, params))
+        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):
+        #
+        #    {
+        #        "arg": {
+        #            "channel": "liquidation-orders",
+        #            "instType": "SWAP"
+        #        },
+        #        "data": [
+        #            {
+        #                "details": [
+        #                    {
+        #                        "bkLoss": "0",
+        #                        "bkPx": "0.007831",
+        #                        "ccy": "",
+        #                        "posSide": "short",
+        #                        "side": "buy",
+        #                        "sz": "13",
+        #                        "ts": "1692266434010"
+        #                    }
+        #                ],
+        #                "instFamily": "IOST-USDT",
+        #                "instId": "IOST-USDT-SWAP",
+        #                "instType": "SWAP",
+        #                "uly": "IOST-USDT"
+        #            }
+        #        ]
+        #    }
+        #
+        rawLiquidations = self.safe_list(message, 'data', [])
+        for i in range(0, len(rawLiquidations)):
+            rawLiquidation = rawLiquidations[i]
+            liquidation = self.parse_ws_liquidation(rawLiquidation)
+            symbol = self.safe_string(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
+            client.resolve([liquidation], 'liquidations')
+            client.resolve([liquidation], 'liquidations::' + symbol)
+
+    async def watch_my_liquidations_for_symbols(self, symbols: List[str] = None, since: Int = None, limit: Int = None, params={}) -> List[Liquidation]:
+        """
+        watch the private liquidations of a trading pair
+        :see: https://www.okx.com/docs-v5/en/#trading-account-websocket-balance-and-position-channel
+        :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 okx api endpoint
+        :returns dict: an array of `liquidation structures <https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure>`
+        """
+        await self.load_markets()
+        isStop = self.safe_value_2(params, 'stop', 'trigger', False)
+        params = self.omit(params, ['stop', 'trigger'])
+        await self.authenticate({'access': 'business' if isStop else 'private'})
+        symbols = self.market_symbols(symbols, None, True, True)
+        messageHash = 'myLiquidations'
+        if symbols is not None:
+            messageHash += '::' + ','.join(symbols)
+        channel = 'balance_and_position'
+        newLiquidations = await self.subscribe('private', messageHash, channel, None, params)
+        if self.newUpdates:
+            return newLiquidations
+        return self.filter_by_symbols_since_limit(self.liquidations, symbols, since, limit, True)
+
+    def handle_my_liquidation(self, client: Client, message):
+        #
+        #    {
+        #        "arg": {
+        #            "channel": "balance_and_position",
+        #            "uid": "77982378738415879"
+        #        },
+        #        "data": [{
+        #            "pTime": "1597026383085",
+        #            "eventType": "snapshot",
+        #            "balData": [{
+        #                "ccy": "BTC",
+        #                "cashBal": "1",
+        #                "uTime": "1597026383085"
+        #            }],
+        #            "posData": [{
+        #                "posId": "1111111111",
+        #                "tradeId": "2",
+        #                "instId": "BTC-USD-191018",
+        #                "instType": "FUTURES",
+        #                "mgnMode": "cross",
+        #                "posSide": "long",
+        #                "pos": "10",
+        #                "ccy": "BTC",
+        #                "posCcy": "",
+        #                "avgPx": "3320",
+        #                "uTIme": "1597026383085"
+        #            }],
+        #            "trades": [{
+        #                "instId": "BTC-USD-191018",
+        #                "tradeId": "2",
+        #            }]
+        #        }]
+        #    }
+        #
+        rawLiquidations = self.safe_list(message, 'data', [])
+        for i in range(0, len(rawLiquidations)):
+            rawLiquidation = rawLiquidations[i]
+            eventType = self.safe_string(rawLiquidation, 'eventType')
+            if eventType != 'liquidation':
+                return
+            liquidation = self.parse_ws_my_liquidation(rawLiquidation)
+            symbol = self.safe_string(liquidation, 'symbol')
+            liquidations = self.safe_value(self.liquidations, symbol)
+            if liquidations is None:
+                limit = self.safe_integer(self.options, 'myLiquidationsLimit', 1000)
+                liquidations = ArrayCache(limit)
+            liquidations.append(liquidation)
+            self.liquidations[symbol] = liquidations
+            client.resolve([liquidation], 'myLiquidations')
+            client.resolve([liquidation], 'myLiquidations::' + symbol)
+
+    def parse_ws_my_liquidation(self, liquidation, market=None):
+        #
+        #    {
+        #        "pTime": "1597026383085",
+        #        "eventType": "snapshot",
+        #        "balData": [{
+        #            "ccy": "BTC",
+        #            "cashBal": "1",
+        #            "uTime": "1597026383085"
+        #        }],
+        #        "posData": [{
+        #            "posId": "1111111111",
+        #            "tradeId": "2",
+        #            "instId": "BTC-USD-191018",
+        #            "instType": "FUTURES",
+        #            "mgnMode": "cross",
+        #            "posSide": "long",
+        #            "pos": "10",
+        #            "ccy": "BTC",
+        #            "posCcy": "",
+        #            "avgPx": "3320",
+        #            "uTIme": "1597026383085"
+        #        }],
+        #        "trades": [{
+        #            "instId": "BTC-USD-191018",
+        #            "tradeId": "2",
+        #        }]
+        #    }
+        #
+        posData = self.safe_list(liquidation, 'posData', [])
+        firstPosData = self.safe_dict(posData, 0, {})
+        marketId = self.safe_string(firstPosData, 'instId')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_integer(firstPosData, 'uTIme')
+        return self.safe_liquidation({
+            'info': liquidation,
+            'symbol': self.safe_symbol(marketId, market),
+            'contracts': self.safe_number(firstPosData, 'pos'),
+            'contractSize': self.safe_number(market, 'contractSize'),
+            'price': self.safe_number(liquidation, 'avgPx'),
+            'baseValue': None,
+            'quoteValue': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+        })
+
+    def parse_ws_liquidation(self, liquidation, market=None):
+        #
+        # public liquidation
+        #    {
+        #        "details": [
+        #            {
+        #                "bkLoss": "0",
+        #                "bkPx": "0.007831",
+        #                "ccy": "",
+        #                "posSide": "short",
+        #                "side": "buy",
+        #                "sz": "13",
+        #                "ts": "1692266434010"
+        #            }
+        #        ],
+        #        "instFamily": "IOST-USDT",
+        #        "instId": "IOST-USDT-SWAP",
+        #        "instType": "SWAP",
+        #        "uly": "IOST-USDT"
+        #    }
+        #
+        details = self.safe_list(liquidation, 'details', [])
+        liquidationDetails = self.safe_dict(details, 0, {})
+        marketId = self.safe_string(liquidation, 'instId')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_integer(liquidationDetails, 'ts')
+        return self.safe_liquidation({
+            'info': liquidation,
+            'symbol': self.safe_symbol(marketId, market),
+            'contracts': self.safe_number(liquidationDetails, 'sz'),
+            'contractSize': self.safe_number(market, 'contractSize'),
+            'price': self.safe_number(liquidationDetails, 'bkPx'),
+            'baseValue': None,
+            'quoteValue': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+        })
+
     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
@@ -819,6 +1057,9 @@ class okx(ccxt.async_support.okx):
         await self.authenticate()
         return await self.subscribe('private', 'account', 'account', None, params)
 
+    def handle_balance_and_position(self, client: Client, message):
+        self.handle_my_liquidation(client, message)
+
     def handle_balance(self, client: Client, message):
         #
         #     {
@@ -1600,6 +1841,8 @@ class okx(ccxt.async_support.okx):
                 # 'margin_account': self.handle_balance,
                 'orders': self.handle_orders,
                 'orders-algo': self.handle_orders,
+                'liquidation-orders': self.handle_liquidation,
+                'balance_and_position': self.handle_balance_and_position,
             }
             method = self.safe_value(methods, channel)
             if method is None:

ccxt/probit.py

@@ -276,7 +276,7 @@ class probit(Exchange, ImplicitAPI):
         markets = self.safe_value(response, 'data', [])
         return self.parse_markets(markets)
 
-    def parse_market(self, market) -> Market:
+    def parse_market(self, market: dict) -> Market:
         id = self.safe_string(market, 'id')
         baseId = self.safe_string(market, 'base_currency_id')
         quoteId = self.safe_string(market, 'quote_currency_id')
@@ -1511,7 +1511,7 @@ class probit(Exchange, ImplicitAPI):
             'info': transaction,
         }
 
-    def parse_transaction_status(self, status):
+    def parse_transaction_status(self, status: Str):
         statuses: dict = {
             'requested': 'pending',
             'pending': 'pending',
@@ -1720,7 +1720,7 @@ class probit(Exchange, ImplicitAPI):
         self.options['expires'] = self.sum(self.milliseconds(), expiresIn * 1000)
         return response
 
-    def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
+    def handle_errors(self, code: int, reason: str, url: str, method: str, headers: dict, body: str, response, requestHeaders, requestBody):
         if response is None:
             return None  # fallback to default error handler
         if 'errorCode' in response:

ccxt/test/base/__init__.py

@@ -14,6 +14,7 @@ from ccxt.test.base.test_funding_rate_history import test_funding_rate_history #
 from ccxt.test.base.test_last_price import test_last_price # noqa E402
 from ccxt.test.base.test_ledger_entry import test_ledger_entry # noqa E402
 from ccxt.test.base.test_leverage_tier import test_leverage_tier # noqa E402
+from ccxt.test.base.test_liquidation import test_liquidation # noqa E402
 from ccxt.test.base.test_margin_mode import test_margin_mode # noqa E402
 from ccxt.test.base.test_margin_modification import test_margin_modification # noqa E402
 from ccxt.test.base.test_market import test_market # noqa E402

ccxt/test/base/test_crypto.py

@@ -42,7 +42,7 @@ assert hash(encode('sexyfish'), 'md5', 'hex') == 'c8a35464aa9d5683585786f44d5889
 assert hash(encode(''), 'sha1', 'hex') == 'da39a3ee5e6b4b0d3255bfef95601890afd80709'
 assert hash(encode('nutella'), 'sha1', 'hex') == 'b3d60a34b744159793c483b067c56d8affc5111a'
 assert hmac(encode('hello'), encode('there'), hashlib.sha256, 'hex') == '551e1c1ecbce0fe9b643745a376584a6289f5f43a46861b315fac9edc8d52a26'
-assert hmac(encode('a message'), encode('a secret'), 'md5', 'hex') == '0bfa503bdbc7358185fcd49b4869e23d'
+assert hmac(encode('a message'), encode('a secret'), hashlib.md5, 'hex') == '0bfa503bdbc7358185fcd49b4869e23d'
 
 # ---------------------------------------------------------------------------------------------------------------------