ccxt 4.2.79__py2.py3-none-any.whl → 4.2.80__py2.py3-none-any.whl

ccxt/deribit.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.deribit import ImplicitAPI
 import hashlib
-from ccxt.base.types import Account, Balances, Currency, Greeks, Int, Market, MarketInterface, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Account, Balances, Currency, Greeks, Int, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -83,6 +83,8 @@ class deribit(Exchange, ImplicitAPI):
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenOrders': True,
+                'fetchOption': True,
+                'fetchOptionChain': True,
                 'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchOrders': False,
@@ -3270,6 +3272,155 @@ class deribit(Exchange, ImplicitAPI):
             'info': greeks,
         }
 
+    def fetch_option(self, symbol: str, params={}) -> Option:
+        """
+        fetches option data that is commonly found in an option chain
+        :see: https://docs.deribit.com/#public-get_book_summary_by_instrument
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `option chain structure <https://docs.ccxt.com/#/?id=option-chain-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        request = {
+            'instrument_name': market['id'],
+        }
+        response = self.publicGetGetBookSummaryByInstrument(self.extend(request, params))
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "result": [
+        #             {
+        #                 "mid_price": 0.04025,
+        #                 "volume_usd": 11045.12,
+        #                 "quote_currency": "BTC",
+        #                 "estimated_delivery_price": 65444.72,
+        #                 "creation_timestamp": 1711100949273,
+        #                 "base_currency": "BTC",
+        #                 "underlying_index": "BTC-27DEC24",
+        #                 "underlying_price": 73742.14,
+        #                 "volume": 4.0,
+        #                 "interest_rate": 0.0,
+        #                 "price_change": -6.9767,
+        #                 "open_interest": 274.2,
+        #                 "ask_price": 0.042,
+        #                 "bid_price": 0.0385,
+        #                 "instrument_name": "BTC-27DEC24-240000-C",
+        #                 "mark_price": 0.04007735,
+        #                 "last": 0.04,
+        #                 "low": 0.04,
+        #                 "high": 0.043
+        #             }
+        #         ],
+        #         "usIn": 1711100949273223,
+        #         "usOut": 1711100949273580,
+        #         "usDiff": 357,
+        #         "testnet": False
+        #     }
+        #
+        result = self.safe_list(response, 'result', [])
+        chain = self.safe_dict(result, 0, {})
+        return self.parse_option(chain, None, market)
+
+    def fetch_option_chain(self, code: str, params={}) -> OptionChain:
+        """
+        fetches data for an underlying asset that is commonly found in an option chain
+        :see: https://docs.deribit.com/#public-get_book_summary_by_currency
+        :param str currency: base currency to fetch an option chain for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a list of `option chain structures <https://docs.ccxt.com/#/?id=option-chain-structure>`
+        """
+        self.load_markets()
+        currency = self.currency(code)
+        request = {
+            'currency': currency['id'],
+            'kind': 'option',
+        }
+        response = self.publicGetGetBookSummaryByCurrency(self.extend(request, params))
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "result": [
+        #             {
+        #                 "mid_price": 0.4075,
+        #                 "volume_usd": 2836.83,
+        #                 "quote_currency": "BTC",
+        #                 "estimated_delivery_price": 65479.26,
+        #                 "creation_timestamp": 1711101594477,
+        #                 "base_currency": "BTC",
+        #                 "underlying_index": "BTC-28JUN24",
+        #                 "underlying_price": 68827.27,
+        #                 "volume": 0.1,
+        #                 "interest_rate": 0.0,
+        #                 "price_change": 0.0,
+        #                 "open_interest": 364.1,
+        #                 "ask_price": 0.411,
+        #                 "bid_price": 0.404,
+        #                 "instrument_name": "BTC-28JUN24-42000-C",
+        #                 "mark_price": 0.40752052,
+        #                 "last": 0.423,
+        #                 "low": 0.423,
+        #                 "high": 0.423
+        #             }
+        #         ],
+        #         "usIn": 1711101594456388,
+        #         "usOut": 1711101594484065,
+        #         "usDiff": 27677,
+        #         "testnet": False
+        #     }
+        #
+        result = self.safe_list(response, 'result', [])
+        return self.parse_option_chain(result, 'base_currency', 'instrument_name')
+
+    def parse_option(self, chain, currency: Currency = None, market: Market = None):
+        #
+        #     {
+        #         "mid_price": 0.04025,
+        #         "volume_usd": 11045.12,
+        #         "quote_currency": "BTC",
+        #         "estimated_delivery_price": 65444.72,
+        #         "creation_timestamp": 1711100949273,
+        #         "base_currency": "BTC",
+        #         "underlying_index": "BTC-27DEC24",
+        #         "underlying_price": 73742.14,
+        #         "volume": 4.0,
+        #         "interest_rate": 0.0,
+        #         "price_change": -6.9767,
+        #         "open_interest": 274.2,
+        #         "ask_price": 0.042,
+        #         "bid_price": 0.0385,
+        #         "instrument_name": "BTC-27DEC24-240000-C",
+        #         "mark_price": 0.04007735,
+        #         "last": 0.04,
+        #         "low": 0.04,
+        #         "high": 0.043
+        #     }
+        #
+        marketId = self.safe_string(chain, 'instrument_name')
+        market = self.safe_market(marketId, market)
+        currencyId = self.safe_string(chain, 'base_currency')
+        code = self.safe_currency_code(currencyId, currency)
+        timestamp = self.safe_integer(chain, 'timestamp')
+        return {
+            'info': chain,
+            'currency': code['code'],
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'impliedVolatility': None,
+            'openInterest': self.safe_number(chain, 'open_interest'),
+            'bidPrice': self.safe_number(chain, 'bid_price'),
+            'askPrice': self.safe_number(chain, 'ask_price'),
+            'midPrice': self.safe_number(chain, 'mid_price'),
+            'markPrice': self.safe_number(chain, 'mark_price'),
+            'lastPrice': self.safe_number(chain, 'last'),
+            'underlyingPrice': self.safe_number(chain, 'underlying_price'),
+            'change': None,
+            'percentage': self.safe_number(chain, 'price_change'),
+            'baseVolume': self.safe_number(chain, 'volume'),
+            'quoteVolume': self.safe_number(chain, 'volume_usd'),
+        }
+
     def nonce(self):
         return self.milliseconds()
 

ccxt/gate.py

@@ -3959,8 +3959,13 @@ class gate(Exchange, ImplicitAPI):
             'account': account,
         }
         if amount is not None:
-            amountKey = 'amount' if (market['spot']) else 'size'
-            request[amountKey] = self.amount_to_precision(symbol, amount)
+            if market['spot']:
+                request['amount'] = self.amount_to_precision(symbol, amount)
+            else:
+                if side == 'sell':
+                    request['size'] = Precise.string_neg(self.amount_to_precision(symbol, amount))
+                else:
+                    request['size'] = self.amount_to_precision(symbol, amount)
         if price is not None:
             request['price'] = self.price_to_precision(symbol, price)
         response = None
@@ -4690,8 +4695,8 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = None if (symbol is None) else self.market(symbol)
-        stop = self.safe_value(params, 'stop')
-        params = self.omit(params, 'stop')
+        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        params = self.omit(params, ['stop', 'trigger'])
         type, query = self.handle_market_type_and_params('cancelAllOrders', market, params)
         request, requestParams = self.multi_order_spot_prepare_request(market, stop, query) if (type == 'spot') else self.prepare_request(market, type, query)
         response = None
@@ -4985,7 +4990,7 @@ class gate(Exchange, ImplicitAPI):
             'unrealizedPnl': self.parse_number(unrealisedPnl),
             'realizedPnl': self.safe_number(position, 'realised_pnl'),
             'contracts': self.parse_number(Precise.string_abs(size)),
-            'contractSize': self.safe_value(market, 'contractSize'),
+            'contractSize': self.safe_number(market, 'contractSize'),
             # 'realisedPnl': position['realised_pnl'],
             'marginRatio': None,
             'liquidationPrice': self.safe_number(position, 'liq_price'),

ccxt/hyperliquid.py

@@ -754,6 +754,8 @@ class hyperliquid(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
+        vaultAddress = self.safe_string(params, 'vaultAddress')
+        params = self.omit(params, 'vaultAddress')
         symbol = market['symbol']
         order = {
             'symbol': symbol,
@@ -763,7 +765,10 @@ class hyperliquid(Exchange, ImplicitAPI):
             'price': price,
             'params': params,
         }
-        response = self.create_orders([order], params)
+        globalParams = {}
+        if vaultAddress is not None:
+            globalParams['vaultAddress'] = vaultAddress
+        response = self.create_orders([order], globalParams)
         first = self.safe_dict(response, 0)
         return first
 
@@ -807,7 +812,6 @@ class hyperliquid(Exchange, ImplicitAPI):
             amount = self.safe_string(rawOrder, 'amount')
             price = self.safe_string(rawOrder, 'price')
             orderParams = self.safe_dict(rawOrder, 'params', {})
-            orderParams = self.extend(params, orderParams)
             clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
             slippage = self.safe_string(orderParams, 'slippage', defaultSlippage)
             defaultTimeInForce = 'ioc' if (isMarket) else 'gtc'
@@ -847,6 +851,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 orderType['limit'] = {
                     'tif': timeInForce,
                 }
+            orderParams = self.omit(orderParams, ['clientOrderId', 'slippage', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'timeInForce', 'client_id'])
             orderObj = {
                 'a': self.parse_to_int(market['baseId']),
                 'b': isBuy,
@@ -858,8 +863,8 @@ class hyperliquid(Exchange, ImplicitAPI):
             }
             if clientOrderId is not None:
                 orderObj['c'] = clientOrderId
-            orderReq.append(orderObj)
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+            orderReq.append(self.extend(orderObj, orderParams))
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         orderAction = {
             'type': 'order',
             'orders': orderReq,
@@ -875,6 +880,9 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -957,10 +965,13 @@ class hyperliquid(Exchange, ImplicitAPI):
                     'o': self.parse_to_numeric(ids[i]),
                 })
         cancelAction['cancels'] = cancelReq
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(cancelAction, nonce, vaultAddress)
         request['action'] = cancelAction
         request['signature'] = signature
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1066,7 +1077,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'type': 'batchModify',
             'modifies': [modifyReq],
         }
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(modifyAction, nonce, vaultAddress)
         request = {
             'action': modifyAction,
@@ -1074,6 +1085,9 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1643,7 +1657,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'isolated': isIsolated,
             'hedged': None,
             'side': side,
-            'contracts': self.parse_number(quantity),
+            'contracts': self.safe_number(entry, 'szi'),
             'contractSize': None,
             'entryPrice': self.safe_number(entry, 'entryPx'),
             'markPrice': None,
@@ -1687,6 +1701,10 @@ class hyperliquid(Exchange, ImplicitAPI):
             'leverage': leverage,
         }
         vaultAddress = self.safe_string(params, 'vaultAddress')
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            if vaultAddress.startswith('0x'):
+                vaultAddress = vaultAddress.replace('0x', '')
         signature = self.sign_l1_action(updateAction, nonce, vaultAddress)
         request = {
             'action': updateAction,
@@ -1694,6 +1712,8 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1729,7 +1749,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'isCross': isCross,
             'leverage': leverage,
         }
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(updateAction, nonce, vaultAddress)
         request = {
             'action': updateAction,
@@ -1737,6 +1757,9 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1784,7 +1807,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'isBuy': True,
             'ntli': sz,
         }
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(updateAction, nonce, vaultAddress)
         request = {
             'action': updateAction,
@@ -1792,6 +1815,9 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1882,6 +1908,13 @@ class hyperliquid(Exchange, ImplicitAPI):
         response = self.privatePostExchange(self.extend(request, params))
         return response
 
+    def format_vault_address(self, address: Str = None):
+        if address is None:
+            return None
+        if address.startswith('0x'):
+            return address.replace('0x', '')
+        return address
+
     def handle_public_address(self, methodName: str, params: dict):
         userAux = None
         userAux, params = self.handle_option_and_params(params, methodName, 'user')

ccxt/mexc.py

@@ -899,8 +899,8 @@ class mexc(Exchange, ImplicitAPI):
                     '30032': InvalidOrder,  # Cannot exceed the maximum position
                     '30041': InvalidOrder,  # current order type can not place order
                     '60005': ExchangeError,  # your account is abnormal
-                    '700001': AuthenticationError,  # API-key format invalid
-                    '700002': AuthenticationError,  # Signature for self request is not valid
+                    '700001': AuthenticationError,  # {"code":700002,"msg":"Signature for self request is not valid."}  # same message for expired API keys
+                    '700002': AuthenticationError,  # Signature for self request is not valid  # or the API secret is incorrect
                     '700004': BadRequest,  # Param 'origClientOrderId' or 'orderId' must be sent, but both were empty/null
                     '700005': InvalidNonce,  # recvWindow must less than 60000
                     '700006': BadRequest,  # IP non white list

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.79'
+__version__ = '4.2.80'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -89,7 +89,7 @@ class binance(ccxt.async_support.binance):
                     'future': 200,
                     'delivery': 200,
                 },
-                'streamBySubscriptionsHash': {},
+                'streamBySubscriptionsHash': self.create_safe_dictionary(),
                 'streamIndex': -1,
                 # get updates every 1000ms or 100ms
                 # or every 0ms in real-time for futures
@@ -97,7 +97,7 @@ class binance(ccxt.async_support.binance):
                 'tradesLimit': 1000,
                 'ordersLimit': 1000,
                 'OHLCVLimit': 1000,
-                'requestId': {},
+                'requestId': self.create_safe_dictionary(),
                 'watchOrderBookLimit': 1000,  # default limit
                 'watchTrades': {
                     'name': 'trade',  # 'trade' or 'aggTrade'
@@ -131,14 +131,14 @@ class binance(ccxt.async_support.binance):
         })
 
     def request_id(self, url):
-        options = self.safe_value(self.options, 'requestId', {})
+        options = self.safe_dict(self.options, 'requestId', self.create_safe_dictionary())
         previousValue = self.safe_integer(options, url, 0)
         newValue = self.sum(previousValue, 1)
         self.options['requestId'][url] = newValue
         return newValue
 
     def stream(self, type, subscriptionHash, numSubscriptions=1):
-        streamBySubscriptionsHash = self.safe_value(self.options, 'streamBySubscriptionsHash', {})
+        streamBySubscriptionsHash = self.safe_dict(self.options, 'streamBySubscriptionsHash', self.create_safe_dictionary())
         stream = self.safe_string(streamBySubscriptionsHash, subscriptionHash)
         if stream is None:
             streamIndex = self.safe_integer(self.options, 'streamIndex', -1)
@@ -151,7 +151,7 @@ class binance(ccxt.async_support.binance):
             self.options['streamBySubscriptionsHash'][subscriptionHash] = stream
             subscriptionsByStreams = self.safe_value(self.options, 'numSubscriptionsByStream')
             if subscriptionsByStreams is None:
-                self.options['numSubscriptionsByStream'] = {}
+                self.options['numSubscriptionsByStream'] = self.create_safe_dictionary()
             subscriptionsByStream = self.safe_integer(self.options['numSubscriptionsByStream'], stream, 0)
             newNumSubscriptions = subscriptionsByStream + numSubscriptions
             subscriptionLimitByStream = self.safe_integer(self.options['subscriptionLimitByStream'], type, 200)

ccxt/pro/bitopro.py

@@ -364,7 +364,8 @@ class bitopro(ccxt.async_support.bitopro):
                 },
             },
         }
-        self.options = self.extend(defaultOptions, self.options)
+        # self.options = self.extend(defaultOptions, self.options)
+        self.extend_exchange_options(defaultOptions)
         originalHeaders = self.options['ws']['options']['headers']
         headers = {
             'X-BITOPRO-API': 'ccxt',

ccxt/pro/gemini.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Int, Order, OrderBook, Str, Tickers, Trade
+from ccxt.base.types import Int, Order, OrderBook, Str, Strings, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -393,7 +393,7 @@ class gemini(ccxt.async_support.gemini):
         orderbook = await self.helper_for_watch_multiple_construct('orderbook', symbols, params)
         return orderbook.limit()
 
-    async def watch_bids_asks(self, symbols: List[str], limit: Int = None, params={}) -> Tickers:
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
         """
         watches best bid & ask for symbols
         :see: https://docs.gemini.com/websocket-api/#multi-market-data
@@ -851,7 +851,8 @@ class gemini(ccxt.async_support.gemini):
                 },
             },
         }
-        self.options = self.extend(defaultOptions, self.options)
+        # self.options = self.extend(defaultOptions, self.options)
+        self.extend_exchange_options(defaultOptions)
         originalHeaders = self.options['ws']['options']['headers']
         headers = {
             'X-GEMINI-APIKEY': self.apiKey,

ccxt/pro/phemex.py

@@ -27,6 +27,10 @@ class phemex(ccxt.async_support.phemex):
                 'watchOrderBook': True,
                 'watchOHLCV': True,
                 'watchPositions': None,  # TODO
+                # mutli-endpoints are not supported: https://github.com/ccxt/ccxt/pull/21490
+                'watchOrderBookForSymbols': False,
+                'watchTradesForSymbols': False,
+                'watchOHLCVForSymbols': False,
             },
             'urls': {
                 'test': {
@@ -536,9 +540,10 @@ class phemex(ccxt.async_support.phemex):
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
+        :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Spot-API-en.md#subscribe-orderbook
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#subscribe-orderbook-for-new-model
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Contract-API-en.md#subscribe-30-levels-orderbook
-        :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Spot-API-en.md#subscribe-orderbook
+        :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Contract-API-en.md#subscribe-full-orderbook
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return

ccxt/test/base/test_ohlcv.py

@@ -21,8 +21,9 @@ def test_ohlcv(exchange, skipped_properties, method, entry, symbol, now):
     test_shared_methods.assert_timestamp_and_datetime(exchange, skipped_properties, method, entry, now, 0)
     log_text = test_shared_methods.log_template(exchange, method, entry)
     #
-    length = len(entry)
-    assert length >= 6, 'ohlcv array length should be >= 6;' + log_text
+    assert len(entry) >= 6, 'ohlcv array length should be >= 6;' + log_text
+    if not ('roundTimestamp' in skipped_properties):
+        test_shared_methods.assert_round_minute_timestamp(exchange, skipped_properties, method, entry, 0)
     high = exchange.safe_string(entry, 2)
     low = exchange.safe_string(entry, 3)
     test_shared_methods.assert_less_or_equal(exchange, skipped_properties, method, entry, '1', high)

ccxt/test/base/test_shared_methods.py

@@ -343,3 +343,11 @@ def assert_non_emtpy_array(exchange, skipped_properties, method, entry, hint=Non
     if not ('emptyResponse' in skipped_properties):
         return
     assert len(entry) > 0, 'response is expected to be a non-empty array' + log_text + ' (add \"emptyResponse\" in skip-tests.json to skip this check)'
+
+
+def assert_round_minute_timestamp(exchange, skipped_properties, method, entry, key):
+    if key in skipped_properties:
+        return
+    log_text = log_template(exchange, method, entry)
+    ts = exchange.safe_string(entry, key)
+    assert Precise.string_mod(ts, '60000') == '0', 'timestamp should be a multiple of 60 seconds (1 minute)' + log_text

ccxt/test/base/test_ticker.py

@@ -39,7 +39,13 @@ def test_ticker(exchange, skipped_properties, method, entry, symbol):
         'quoteVolume': exchange.parse_number('1.234'),
     }
     # todo: atm, many exchanges fail, so temporarily decrease stict mode
-    empty_allowed_for = ['timestamp', 'datetime', 'open', 'high', 'low', 'close', 'last', 'ask', 'bid', 'bidVolume', 'askVolume', 'baseVolume', 'quoteVolume', 'previousClose', 'vwap', 'change', 'percentage', 'average']
+    empty_allowed_for = ['timestamp', 'datetime', 'open', 'high', 'low', 'close', 'last', 'baseVolume', 'quoteVolume', 'previousClose', 'vwap', 'change', 'percentage', 'average']
+    # trick csharp-transpiler for string
+    if not 'BidsAsks' in str(method):
+        empty_allowed_for.append('bid')
+        empty_allowed_for.append('ask')
+        empty_allowed_for.append('bidVolume')
+        empty_allowed_for.append('askVolume')
     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)