ccxt 4.3.94__py2.py3-none-any.whl → 4.3.96__py2.py3-none-any.whl

ccxt/mexc.py

@@ -462,164 +462,82 @@ class mexc(Exchange, ImplicitAPI):
                     'LTC': 'LTC',
                 },
                 'networks': {
-                    'ABBC': 'ABBC',
+                    'TRC20': 'TRX',
+                    'TON': 'TONCOIN',
+                    'AVAXC': 'AVAX_CCHAIN',
+                    'ERC20': 'ETH',
                     'ACA': 'ACALA',
-                    'ADA': 'Cardano(ADA)',
-                    'AE': 'AE',
-                    'ALGO': 'Algorand(ALGO)',
-                    'ALPH': 'Alephium(ALPH)',
-                    'AME': 'AME',
-                    'AOK': 'AOK',
-                    'APT': 'APTOS(APT)',
-                    'AR': 'AR',
-                    'ARB': 'Arbitrum One(ARB)',
-                    'ARBNOVA': 'ARBNOVA',
-                    'ARBONE': 'ArbitrumOne(ARB)',
-                    'ARK': 'ARK',
+                    # 'ADA': 'Cardano(ADA)',
+                    # 'AE': 'AE',
+                    # 'ALGO': 'Algorand(ALGO)',
+                    # 'ALPH': 'Alephium(ALPH)',
+                    # 'ARB': 'Arbitrum One(ARB)',
+                    # 'ARBONE': 'ArbitrumOne(ARB)',
                     'ASTR': 'ASTAR',  # ASTAREVM is different
-                    'ATOM': 'Cosmos(ATOM)',
-                    'AVAXC': 'Avalanche C Chain(AVAX CCHAIN)',
-                    'AVAXX': 'Avalanche X Chain(AVAX XCHAIN)',
-                    'AZERO': 'Aleph Zero(AZERO)',
-                    'BCH': 'Bitcoin Cash(BCH)',
-                    'BDX': 'BDX',
-                    'BEAM': 'BEAM',
-                    'BEP2': 'BNB Beacon Chain(BEP2)',
-                    'BEP20': 'BNB Smart Chain(BEP20)',
-                    'BITCI': 'BITCI',
-                    'BNC': 'BNC',
-                    'BNCDOT': 'BNCPOLKA',
-                    'BOBA': 'BOBA',
-                    'BSC': 'BEP20(BSC)',
-                    'BSV': 'Bitcoin SV(BSV)',
-                    'BTC': 'Bitcoin(BTC)',
+                    # 'ATOM': 'Cosmos(ATOM)',
+                    # 'AVAXC': 'Avalanche C Chain(AVAX CCHAIN)',
+                    # 'AVAXX': 'Avalanche X Chain(AVAX XCHAIN)',
+                    # 'AZERO': 'Aleph Zero(AZERO)',
+                    # 'BCH': 'Bitcoin Cash(BCH)',
+                    # 'BNCDOT': 'BNCPOLKA',
+                    # 'BSV': 'Bitcoin SV(BSV)',
+                    # 'BTC': 'Bitcoin(BTC)',
                     'BTM': 'BTM2',
-                    'CELO': 'CELO',
-                    'CFX': 'CFX',
-                    'CHZ': 'Chiliz Legacy Chain(CHZ)',
-                    'CHZ2': 'Chiliz Chain(CHZ2)',
-                    'CKB': 'CKB',
-                    'CLORE': 'Clore.ai(CLORE)',
+                    # 'CHZ': 'Chiliz Legacy Chain(CHZ)',
+                    # 'CHZ2': 'Chiliz Chain(CHZ2)',
+                    # 'CLORE': 'Clore.ai(CLORE)',
                     'CRC20': 'CRONOS',
-                    'CSPR': 'CSPR',
-                    'DASH': 'DASH',
-                    'DC': 'Dogechain(DC)',
-                    'DCR': 'DCR',
-                    'DNX': 'Dynex(DNX)',
-                    'DOGE': 'Dogecoin(DOGE)',
-                    'DOT': 'Polkadot(DOT)',
-                    'DYM': 'Dymension(DYM)',
-                    'EDG': 'EDG',
-                    'EGLD': 'EGLD',
-                    'EOS': 'EOS',
-                    'ERC20': 'Ethereum(ERC20)',
-                    'ETC': 'Ethereum Classic(ETC)',
+                    # 'DC': 'Dogechain(DC)',
+                    # 'DNX': 'Dynex(DNX)',
+                    # 'DOGE': 'Dogecoin(DOGE)',
+                    # 'DOT': 'Polkadot(DOT)',
+                    # 'DYM': 'Dymension(DYM)',
                     'ETHF': 'ETF',
-                    'ETHW': 'ETHW',
-                    'EVER': 'EVER',
-                    'FET': 'FET',
-                    'FIL': 'FIL',
-                    'FIO': 'FIO',
-                    'FLOW': 'FLOW',
-                    'FSN': 'FSN',
-                    'FTM': 'Fantom(FTM)',
-                    'FUSE': 'FUSE',
-                    'GLMR': 'GLMR',
-                    'GRIN': 'GRIN',
-                    'HBAR': 'Hedera(HBAR)',
-                    'HIVE': 'HIVE',
                     'HRC20': 'HECO',
-                    'HYDRA': 'HYDRA',
-                    'ICP': 'Internet Computer(ICP)',
-                    'INDEX': 'Index Chain',
-                    'IOST': 'IOST',
-                    'IOTA': 'IOTA',
-                    'IOTX': 'IOTX',
-                    'IRIS': 'IRIS',
-                    'KAR': 'KAR',
-                    'KAS': 'Kaspa(KAS)',
-                    'KAVA': 'KAVA',
-                    'KDA': 'KDA',
-                    'KILT': 'KILT',
-                    'KLAY': 'Klaytn(KLAY)',
-                    'KMA': 'KMA',
-                    'KSM': 'KSM',
-                    'LAT': 'LAT',
-                    'LAVA': 'Elysium(LAVA)',
-                    'LTC': 'Litecoin(LTC)',
-                    'LUNA': 'Terra(LUNA)',
-                    'MASS': 'MASS',
-                    'MATIC': 'Polygon(MATIC)',
-                    'MCOIN': 'Mcoin Network',
-                    'METIS': 'METIS',
-                    'MINA': 'MINA',
-                    'MNT': 'Mantle(MNT)',
-                    'MOVR': 'MOVR',
-                    'MTRG': 'Meter(MTRG)',
-                    'NAS': 'NAS',
-                    'NEAR': 'NEAR Protocol(NEAR)',
-                    'NEBL': 'NEBL',
-                    'NEM': 'NEM',
-                    'NEO': 'NEO',
-                    'NEO3': 'NEO3',
-                    'NEOXA': 'Neoxa Network',
-                    'NULS': 'NULS',
+                    # 'KLAY': 'Klaytn(KLAY)',
                     'OASIS': 'ROSE',
-                    'OASYS': 'OASYS',
                     'OKC': 'OKT',
-                    'OMN': 'Omega Network(OMN)',
-                    'OMNI': 'OMNI',
-                    'ONE': 'ONE',
-                    'ONT': 'ONT',
-                    'OPTIMISM': 'Optimism(OP)',
-                    'OSMO': 'OSMO',
-                    'PLCU': 'PLCU',
-                    'POKT': 'POKT',
-                    'QKC': 'QKC',
-                    'QTUM': 'QTUM',
-                    'RAP20': 'RAP20' + ' ' + '(Rangers Mainnet)',
-                    'REI': 'REI',
                     'RSK': 'RBTC',
-                    'RVN': 'Ravencoin(RVN)',
-                    'SATOX': 'Satoxcoin(SATOX)',
-                    'SC': 'SC',
-                    'SCRT': 'SCRT',
-                    'SDN': 'SDN',
-                    'SGB': 'SGB',
-                    'SOL': 'Solana(SOL)',
-                    'STAR': 'STAR',
-                    'STARK': 'Starknet(STARK)',
-                    'STEEM': 'STEEM',
-                    'SYS': 'SYS',
-                    'TAO': 'Bittensor(TAO)',
-                    'TIA': 'Celestia(TIA)',
-                    'TOMO': 'TOMO',
-                    'TON': 'Toncoin(TON)',
-                    'TRC10': 'TRC10',
-                    'TRC20': 'Tron(TRC20)',
-                    'UGAS': 'UGAS(Ultrain)',
-                    'VET': 'VeChain(VET)',
-                    'VEX': 'Vexanium(VEX)',
-                    'VSYS': 'VSYS',
-                    'WAVES': 'WAVES',
-                    'WAX': 'WAX',
-                    'WEMIX': 'WEMIX',
-                    'XCH': 'Chia(XCH)',
-                    'XDC': 'XDC',
-                    'XEC': 'XEC',
-                    'XLM': 'Stellar(XLM)',
-                    'XMR': 'Monero(XMR)',
-                    'XNA': 'Neurai(XNA)',
-                    'XPR': 'XPR Network',
-                    'XRD': 'XRD',
-                    'XRP': 'Ripple(XRP)',
-                    'XTZ': 'XTZ',
-                    'XVG': 'XVG',
-                    'XYM': 'XYM',
-                    'ZEC': 'ZEC',
-                    'ZEN': 'ZEN',
-                    'ZIL': 'Zilliqa(ZIL)',
-                    'ZTG': 'ZTG',
+                    # 'RVN': 'Ravencoin(RVN)',
+                    # 'SATOX': 'Satoxcoin(SATOX)',
+                    # 'SC': 'SC',
+                    # 'SCRT': 'SCRT',
+                    # 'SDN': 'SDN',
+                    # 'SGB': 'SGB',
+                    # 'SOL': 'Solana(SOL)',
+                    # 'STAR': 'STAR',
+                    # 'STARK': 'Starknet(STARK)',
+                    # 'STEEM': 'STEEM',
+                    # 'SYS': 'SYS',
+                    # 'TAO': 'Bittensor(TAO)',
+                    # 'TIA': 'Celestia(TIA)',
+                    # 'TOMO': 'TOMO',
+                    # 'TON': 'Toncoin(TON)',
+                    # 'TRC10': 'TRC10',
+                    # 'TRC20': 'Tron(TRC20)',
+                    # 'UGAS': 'UGAS(Ultrain)',
+                    # 'VET': 'VeChain(VET)',
+                    # 'VEX': 'Vexanium(VEX)',
+                    # 'VSYS': 'VSYS',
+                    # 'WAVES': 'WAVES',
+                    # 'WAX': 'WAX',
+                    # 'WEMIX': 'WEMIX',
+                    # 'XCH': 'Chia(XCH)',
+                    # 'XDC': 'XDC',
+                    # 'XEC': 'XEC',
+                    # 'XLM': 'Stellar(XLM)',
+                    # 'XMR': 'Monero(XMR)',
+                    # 'XNA': 'Neurai(XNA)',
+                    # 'XPR': 'XPR Network',
+                    # 'XRD': 'XRD',
+                    # 'XRP': 'Ripple(XRP)',
+                    # 'XTZ': 'XTZ',
+                    # 'XVG': 'XVG',
+                    # 'XYM': 'XYM',
+                    # 'ZEC': 'ZEC',
+                    # 'ZEN': 'ZEN',
+                    # 'ZIL': 'Zilliqa(ZIL)',
+                    # 'ZTG': 'ZTG',
                     # todo: uncomment below after concensus
                     # 'ALAYA': 'ATP',
                     # 'ANDUSCHAIN': 'DEB',
@@ -891,6 +809,8 @@ class mexc(Exchange, ImplicitAPI):
     def fetch_status(self, params={}):
         """
         the latest known information on the availability of the exchange API
+        :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#test-connectivity
+        :see: https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-server-time
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `status structure <https://docs.ccxt.com/#/?id=exchange-status-structure>`
         """
@@ -924,6 +844,8 @@ class mexc(Exchange, ImplicitAPI):
     def fetch_time(self, params={}):
         """
         fetches the current integer timestamp in milliseconds from the exchange server
+        :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#check-server-time
+        :see: https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-server-time
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns int: the current integer timestamp in milliseconds from the exchange server
         """
@@ -1011,7 +933,7 @@ class mexc(Exchange, ImplicitAPI):
             chains = self.safe_value(currency, 'networkList', [])
             for j in range(0, len(chains)):
                 chain = chains[j]
-                networkId = self.safe_string_2(chain, 'network', 'netWork')
+                networkId = self.safe_string_2(chain, 'netWork', 'network')
                 network = self.network_id_to_code(networkId)
                 isDepositEnabled = self.safe_bool(chain, 'depositEnable', False)
                 isWithdrawEnabled = self.safe_bool(chain, 'withdrawEnable', False)
@@ -1080,6 +1002,8 @@ class mexc(Exchange, ImplicitAPI):
     def fetch_markets(self, params={}) -> List[Market]:
         """
         retrieves data on all markets for mexc
+        :see: https://mexcdevelop.github.io/apidocs/spot_v3_en/#exchange-information
+        :see: https://mexcdevelop.github.io/apidocs/contract_v1_en/#get-the-contract-information
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
@@ -4120,7 +4044,7 @@ class mexc(Exchange, ImplicitAPI):
         #
         address = self.safe_string(depositAddress, 'address')
         currencyId = self.safe_string(depositAddress, 'coin')
-        networkId = self.safe_string(depositAddress, 'network')
+        networkId = self.safe_string(depositAddress, 'netWork')
         self.check_address(address)
         return {
             'currency': self.safe_currency_code(currencyId, currency),
@@ -4844,14 +4768,14 @@ class mexc(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
+        self.load_markets()
+        currency = self.currency(code)
         tag, params = self.handle_withdraw_tag_and_params(tag, params)
         networks = self.safe_dict(self.options, 'networks', {})
         network = self.safe_string_2(params, 'network', 'netWork')  # self line allows the user to specify either ERC20 or ETH
         network = self.safe_string(networks, network, network)  # handle ETH > ERC-20 alias
-        network = self.network_id_to_code(network)
+        network = self.network_code_to_id(network, currency['code'])
         self.check_address(address)
-        self.load_markets()
-        currency = self.currency(code)
         request: dict = {
             'coin': currency['id'],
             'address': address,

ccxt/okx.py

@@ -133,7 +133,6 @@ class okx(Exchange, ImplicitAPI):
                 'fetchOrderBooks': False,
                 'fetchOrders': False,
                 'fetchOrderTrades': True,
-                'fetchPermissions': None,
                 'fetchPosition': True,
                 'fetchPositionHistory': 'emulated',
                 'fetchPositions': True,
@@ -348,6 +347,7 @@ class okx(Exchange, ImplicitAPI):
                         'account/account-position-risk': 2,
                         'account/bills': 5 / 3,
                         'account/bills-archive': 5 / 3,
+                        'account/bills-history-archive': 2,
                         'account/config': 4,
                         'account/max-size': 1,
                         'account/max-avail-size': 1,
@@ -502,6 +502,7 @@ class okx(Exchange, ImplicitAPI):
                         'account/fixed-loan/amend-borrowing-order': 5,
                         'account/fixed-loan/manual-reborrow': 5,
                         'account/fixed-loan/repay-borrowing-order': 5,
+                        'account/bills-history-archive': 72000,  # 12 req/day
                         # subaccount
                         'users/subaccount/modify-apikey': 10,
                         'asset/subaccount/transfer': 10,

ccxt/p2b.py

@@ -83,7 +83,6 @@ class p2b(Exchange, ImplicitAPI):
                 'fetchOrderBooks': False,
                 'fetchOrders': True,
                 'fetchOrderTrades': True,
-                'fetchPermissions': False,
                 'fetchPosition': False,
                 'fetchPositionHistory': False,
                 'fetchPositionMode': False,

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.94'
+__version__ = '4.3.96'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -959,13 +959,21 @@ class binance(ccxt.async_support.binance):
             error = UnsubscribeError(self.id + ' ' + subHash)
             client.reject(error, subHash)
             client.resolve(True, unsubHash)
-            self.clean_cache(subscription)
+        self.clean_cache(subscription)
 
     def clean_cache(self, subscription: dict):
         topic = self.safe_string(subscription, 'topic')
         symbols = self.safe_list(subscription, 'symbols', [])
         symbolsLength = len(symbols)
-        if symbolsLength > 0:
+        if topic == 'ohlcv':
+            symbolsAndTimeFrames = self.safe_list(subscription, 'symbolsAndTimeframes', [])
+            for i in range(0, len(symbolsAndTimeFrames)):
+                symbolAndTimeFrame = symbolsAndTimeFrames[i]
+                symbol = self.safe_string(symbolAndTimeFrame, 0)
+                timeframe = self.safe_string(symbolAndTimeFrame, 1)
+                if timeframe in self.ohlcvs[symbol]:
+                    del self.ohlcvs[symbol][timeframe]
+        elif symbolsLength > 0:
             for i in range(0, len(symbols)):
                 symbol = symbols[i]
                 if topic == 'trade':
@@ -1388,6 +1396,86 @@ class binance(ccxt.async_support.binance):
         filtered = self.filter_by_since_limit(candles, since, limit, 0, True)
         return self.create_ohlcv_object(symbol, timeframe, filtered)
 
+    async def un_watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], params={}):
+        """
+        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://binance-docs.github.io/apidocs/spot/en/#kline-candlestick-data
+        :see: https://binance-docs.github.io/apidocs/futures/en/#kline-candlestick-data
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#kline-candlestick-data
+        :param str[][] symbolsAndTimeframes: array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param dict [params.timezone]: if provided, kline intervals are interpreted in that timezone instead of UTC, example '+08:00'
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        klineType = None
+        klineType, params = self.handle_param_string_2(params, 'channel', 'name', 'kline')
+        symbols = self.get_list_from_object_values(symbolsAndTimeframes, 0)
+        marketSymbols = self.market_symbols(symbols, None, False, False, True)
+        firstMarket = self.market(marketSymbols[0])
+        type = firstMarket['type']
+        if firstMarket['contract']:
+            type = 'future' if firstMarket['linear'] else 'delivery'
+        isSpot = (type == 'spot')
+        timezone = None
+        timezone, params = self.handle_param_string(params, 'timezone', None)
+        isUtc8 = (timezone is not None) and ((timezone == '+08:00') or Precise.string_eq(timezone, '8'))
+        rawHashes = []
+        subMessageHashes = []
+        messageHashes = []
+        for i in range(0, len(symbolsAndTimeframes)):
+            symAndTf = symbolsAndTimeframes[i]
+            symbolString = symAndTf[0]
+            timeframeString = symAndTf[1]
+            interval = self.safe_string(self.timeframes, timeframeString, timeframeString)
+            market = self.market(symbolString)
+            marketId = market['lowercaseId']
+            if klineType == 'indexPriceKline':
+                # weird behavior for index price kline we can't use the perp suffix
+                marketId = marketId.replace('_perp', '')
+            shouldUseUTC8 = (isUtc8 and isSpot)
+            suffix = '@+08:00'
+            utcSuffix = suffix if shouldUseUTC8 else ''
+            rawHashes.append(marketId + '@' + klineType + '_' + interval + utcSuffix)
+            subMessageHashes.append('ohlcv::' + market['symbol'] + '::' + timeframeString)
+            messageHashes.append('unsubscribe::ohlcv::' + market['symbol'] + '::' + timeframeString)
+        url = self.urls['api']['ws'][type] + '/' + self.stream(type, 'multipleOHLCV')
+        requestId = self.request_id(url)
+        request = {
+            'method': 'UNSUBSCRIBE',
+            'params': rawHashes,
+            'id': requestId,
+        }
+        subscribe = {
+            'unsubscribe': True,
+            'id': str(requestId),
+            'symbols': symbols,
+            'symbolsAndTimeframes': symbolsAndTimeframes,
+            'subMessageHashes': subMessageHashes,
+            'messageHashes': messageHashes,
+            'topic': 'ohlcv',
+        }
+        params = self.omit(params, 'callerMethodName')
+        return await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes, subscribe)
+
+    async def un_watch_ohlcv(self, symbol: str, timeframe='1m', params={}) -> Any:
+        """
+        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://binance-docs.github.io/apidocs/spot/en/#kline-candlestick-data
+        :see: https://binance-docs.github.io/apidocs/futures/en/#kline-candlestick-data
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#kline-candlestick-data
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param dict [params.timezone]: if provided, kline intervals are interpreted in that timezone instead of UTC, example '+08:00'
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        symbol = market['symbol']
+        params['callerMethodName'] = 'watchOHLCV'
+        return await self.un_watch_ohlcv_for_symbols([[symbol, timeframe]], params)
+
     def handle_ohlcv(self, client: Client, message):
         #
         #     {

ccxt/pro/bybit.py

@@ -609,6 +609,53 @@ class bybit(ccxt.async_support.bybit):
         filtered = self.filter_by_since_limit(stored, since, limit, 0, True)
         return self.create_ohlcv_object(symbol, timeframe, filtered)
 
+    async def un_watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], params={}):
+        """
+        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/kline
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/etp-kline
+        :param str[][] symbolsAndTimeframes: array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A list of candles ordered, open, high, low, close, volume
+        """
+        await self.load_markets()
+        symbols = self.get_list_from_object_values(symbolsAndTimeframes, 0)
+        marketSymbols = self.market_symbols(symbols, None, False, True, True)
+        firstSymbol = marketSymbols[0]
+        url = await self.get_url_by_market_type(firstSymbol, False, 'watchOHLCVForSymbols', params)
+        rawHashes = []
+        subMessageHashes = []
+        messageHashes = []
+        for i in range(0, len(symbolsAndTimeframes)):
+            data = symbolsAndTimeframes[i]
+            symbolString = self.safe_string(data, 0)
+            market = self.market(symbolString)
+            symbolString = market['symbol']
+            unfiedTimeframe = self.safe_string(data, 1)
+            timeframeId = self.safe_string(self.timeframes, unfiedTimeframe, unfiedTimeframe)
+            rawHashes.append('kline.' + timeframeId + '.' + market['id'])
+            subMessageHashes.append('ohlcv::' + symbolString + '::' + unfiedTimeframe)
+            messageHashes.append('unsubscribe::ohlcv::' + symbolString + '::' + unfiedTimeframe)
+        subExtension = {
+            'symbolsAndTimeframes': symbolsAndTimeframes,
+        }
+        return await self.un_watch_topics(url, 'ohlcv', symbols, messageHashes, subMessageHashes, rawHashes, params, subExtension)
+
+    async def un_watch_ohlcv(self, symbol: str, timeframe='1m', params={}) -> Any:
+        """
+        unWatches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/kline
+        :see: https://bybit-exchange.github.io/docs/v5/websocket/public/etp-kline
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        params['callerMethodName'] = 'watchOHLCV'
+        return await self.un_watch_ohlcv_for_symbols([[symbol, timeframe]], params)
+
     def handle_ohlcv(self, client: Client, message):
         #
         #     {
@@ -1997,7 +2044,7 @@ class bybit(ccxt.async_support.bybit):
         message = self.extend(request, params)
         return await self.watch_multiple(url, messageHashes, message, messageHashes)
 
-    async def un_watch_topics(self, url: str, topic: str, symbols: List[str], messageHashes: List[str], subMessageHashes: List[str], topics, params={}):
+    async def un_watch_topics(self, url: str, topic: str, symbols: List[str], messageHashes: List[str], subMessageHashes: List[str], topics, params={}, subExtension={}):
         reqId = self.request_id()
         request: dict = {
             'op': 'unsubscribe',
@@ -2012,7 +2059,7 @@ class bybit(ccxt.async_support.bybit):
             'symbols': symbols,
         }
         message = self.extend(request, params)
-        return await self.watch_multiple(url, messageHashes, message, messageHashes, subscription)
+        return await self.watch_multiple(url, messageHashes, message, messageHashes, self.extend(subscription, subExtension))
 
     async def authenticate(self, url, params={}):
         self.check_required_credentials()
@@ -2270,14 +2317,21 @@ class bybit(ccxt.async_support.bybit):
                     error = UnsubscribeError(self.id + ' ' + messageHash)
                     client.reject(error, subHash)
                     client.resolve(True, unsubHash)
-                    self.clean_cache(subscription)
+                self.clean_cache(subscription)
         return message
 
     def clean_cache(self, subscription: dict):
         topic = self.safe_string(subscription, 'topic')
         symbols = self.safe_list(subscription, 'symbols', [])
         symbolsLength = len(symbols)
-        if symbolsLength > 0:
+        if topic == 'ohlcv':
+            symbolsAndTimeFrames = self.safe_list(subscription, 'symbolsAndTimeframes', [])
+            for i in range(0, len(symbolsAndTimeFrames)):
+                symbolAndTimeFrame = symbolsAndTimeFrames[i]
+                symbol = self.safe_string(symbolAndTimeFrame, 0)
+                timeframe = self.safe_string(symbolAndTimeFrame, 1)
+                del self.ohlcvs[symbol][timeframe]
+        elif symbolsLength > 0:
             for i in range(0, len(symbols)):
                 symbol = symbols[i]
                 if topic == 'trade':