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

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/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,
@@ -160,7 +164,7 @@ class okx(ccxt.async_support.okx):
                 self.deep_extend(firstArgument, params),
             ],
         }
-        return await self.watch(url, messageHash, request, messageHash)
+        return self.watch(url, messageHash, request, messageHash)
 
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
@@ -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_liquidation.py

@@ -0,0 +1,50 @@
+import os
+import sys
+
+root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+sys.path.append(root)
+
+# ----------------------------------------------------------------------------
+
+# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+
+# ----------------------------------------------------------------------------
+# -*- coding: utf-8 -*-
+
+from ccxt.base.precise import Precise  # noqa E402
+from ccxt.test.base import test_shared_methods  # noqa E402
+
+def test_liquidation(exchange, skipped_properties, method, entry, symbol):
+    format = {
+        'info': {},
+        'symbol': 'ETH/BTC',
+        'contracts': exchange.parse_number('1.234'),
+        'contractSize': exchange.parse_number('1.234'),
+        'price': exchange.parse_number('1.234'),
+        'baseValue': exchange.parse_number('1.234'),
+        'quoteValue': exchange.parse_number('1.234'),
+        'timestamp': 1502962946216,
+        'datetime': '2017-09-01T00:00:00',
+    }
+    # todo: atm, many exchanges fail, so temporarily decrease stict mode
+    empty_allowed_for = ['timestamp', 'datetime', 'quoteValue', 'baseValue', 'previousClose', 'price', 'contractSize', 'contracts']
+    test_shared_methods.assert_structure(exchange, skipped_properties, method, entry, format, empty_allowed_for)
+    test_shared_methods.assert_timestamp_and_datetime(exchange, skipped_properties, method, entry)
+    log_text = test_shared_methods.log_template(exchange, method, entry)
+    test_shared_methods.assert_greater(exchange, skipped_properties, method, entry, 'contracts', '0')
+    test_shared_methods.assert_greater(exchange, skipped_properties, method, entry, 'contractSize', '0')
+    test_shared_methods.assert_greater(exchange, skipped_properties, method, entry, 'price', '0')
+    test_shared_methods.assert_greater(exchange, skipped_properties, method, entry, 'baseValue', '0')
+    test_shared_methods.assert_greater(exchange, skipped_properties, method, entry, 'quoteValue', '0')
+    contracts = exchange.safe_string(entry, 'contracts')
+    contract_size = exchange.safe_string(entry, 'contractSize')
+    price = exchange.safe_string(entry, 'price')
+    base_value = exchange.safe_string(entry, 'baseValue')
+    if contracts and contract_size:
+        assert Precise.string_eq(base_value, Precise.string_mul(contracts, contract_size)), 'baseValue == contracts * contractSize' + log_text
+        if price:
+            assert Precise.string_eq(base_value, Precise.string_mul(Precise.string_mul(contracts, contract_size), price)), 'quoteValue == contracts * contractSize * price' + log_text
+    # if singular was called, then symbol needs to be asserted
+    if method == 'watchLiquidations' or method == 'fetchLiquidations':
+        test_shared_methods.assert_symbol(exchange, skipped_properties, method, entry, 'symbol', symbol)

ccxt/timex.py

@@ -1142,7 +1142,7 @@ class timex(Exchange, ImplicitAPI):
         result = self.safe_value(response, 0, {})
         return self.parse_trading_fee(result, market)
 
-    def parse_market(self, market) -> Market:
+    def parse_market(self, market: dict) -> Market:
         #
         #     {
         #         "symbol": "ETHBTC",
@@ -1572,7 +1572,7 @@ class timex(Exchange, ImplicitAPI):
             headers = {'authorization': secret}
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
-    def handle_errors(self, statusCode, statusText, url, method, responseHeaders, responseBody, response, requestHeaders, requestBody):
+    def handle_errors(self, statusCode: int, statusText: str, url: str, method: str, responseHeaders: dict, responseBody, response, requestHeaders, requestBody):
         if response is None:
             return None
         if statusCode >= 400:

ccxt/tokocrypto.py

@@ -2331,7 +2331,7 @@ class tokocrypto(Exchange, ImplicitAPI):
                 url += '?' + self.urlencode(params)
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
-    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 (code == 418) or (code == 429):
             raise DDoSProtection(self.id + ' ' + str(code) + ' ' + reason + ' ' + body)
         # error response in a form: {"code": -1013, "msg": "Invalid quantity."}

ccxt/tradeogre.py

@@ -581,7 +581,7 @@ class tradeogre(Exchange, ImplicitAPI):
                 body = self.urlencode(params)
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
-    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
         if not ('success' in response):

ccxt/upbit.py

@@ -423,7 +423,7 @@ class upbit(Exchange, ImplicitAPI):
         #
         return self.parse_markets(response)
 
-    def parse_market(self, market) -> Market:
+    def parse_market(self, market: dict) -> Market:
         id = self.safe_string(market, 'market')
         quoteId, baseId = id.split('-')
         base = self.safe_currency_code(baseId)
@@ -1261,7 +1261,7 @@ class upbit(Exchange, ImplicitAPI):
         #
         return self.parse_transaction(response, currency)
 
-    def parse_transaction_status(self, status):
+    def parse_transaction_status(self, status: Str):
         statuses: dict = {
             'submitting': 'pending',  # 처리 중
             'submitted': 'pending',  # 처리 완료
@@ -1801,7 +1801,7 @@ class upbit(Exchange, ImplicitAPI):
                 headers['Content-Type'] = 'application/json'
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
-    def handle_errors(self, httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody):
+    def handle_errors(self, httpCode: 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
         #