ccxt-ir 4.9.14__py2.py3-none-any.whl → 4.9.16__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.9.14'
+__version__ = '4.9.16'
 
 # ----------------------------------------------------------------------------
 
@@ -210,6 +210,7 @@ from ccxt.ramzinex import ramzinex                                    # noqa: F4
 from ccxt.sarmayex import sarmayex                                    # noqa: F401
 from ccxt.sarrafex import sarrafex                                    # noqa: F401
 from ccxt.tabdeal import tabdeal                                      # noqa: F401
+from ccxt.tehran_exchange import tehran_exchange                      # noqa: F401
 from ccxt.tetherland import tetherland                                # noqa: F401
 from ccxt.timex import timex                                          # noqa: F401
 from ccxt.tokocrypto import tokocrypto                                # noqa: F401
@@ -356,6 +357,7 @@ exchanges = [
     'sarmayex',
     'sarrafex',
     'tabdeal',
+    'tehran_exchange',
     'tetherland',
     'timex',
     'tokocrypto',

ccxt/abantether.py

@@ -185,8 +185,8 @@ class abantether(Exchange, ImplicitAPI):
             'baseId': baseId,
             'quoteId': quoteId,
             'settleId': None,
-            'type': 'spot',
-            'spot': True,
+            'type': 'otc',
+            'spot': False,
             'margin': False,
             'swap': False,
             'future': False,

ccxt/abstract/tehran_exchange.py

@@ -0,0 +1,6 @@
+from ccxt.base.types import Entry
+
+
+class ImplicitAPI:
+    public_get_otc_v1_market_pair = publicGetOtcV1MarketPair = Entry('otc/v1/market/pair', 'public', 'GET', {'cost': 1})
+    public_get_otc_v1_market_order_pair_price = publicGetOtcV1MarketOrderPairPrice = Entry('otc/v1/market/order/pair/price', 'public', 'GET', {'cost': 1})

ccxt/abstract/toobit.py

@@ -4,3 +4,4 @@ from ccxt.base.types import Entry
 class ImplicitAPI:
     public_get_quote_v1_ticker_24hr = publicGetQuoteV1Ticker24hr = Entry('quote/v1/ticker/24hr', 'public', 'GET', {'cost': 1})
     public_get_quote_v1_klines = publicGetQuoteV1Klines = Entry('quote/v1/klines', 'public', 'GET', {'cost': 1})
+    public_get_api_v1_exchangeinfo = publicGetApiV1ExchangeInfo = Entry('/api/v1/exchangeInfo', 'public', 'GET', {'cost': 1})

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.9.14'
+__version__ = '4.9.16'
 
 # -----------------------------------------------------------------------------
 
@@ -190,6 +190,7 @@ from ccxt.async_support.ramzinex import ramzinex
 from ccxt.async_support.sarmayex import sarmayex                                # noqa: F401
 from ccxt.async_support.sarrafex import sarrafex                                # noqa: F401
 from ccxt.async_support.tabdeal import tabdeal                                  # noqa: F401
+from ccxt.async_support.tehran_exchange import tehran_exchange                  # noqa: F401
 from ccxt.async_support.tetherland import tetherland                            # noqa: F401
 from ccxt.async_support.timex import timex                                      # noqa: F401
 from ccxt.async_support.tokocrypto import tokocrypto                            # noqa: F401
@@ -336,6 +337,7 @@ exchanges = [
     'sarmayex',
     'sarrafex',
     'tabdeal',
+    'tehran_exchange',
     'tetherland',
     'timex',
     'tokocrypto',

ccxt/async_support/abantether.py

@@ -185,8 +185,8 @@ class abantether(Exchange, ImplicitAPI):
             'baseId': baseId,
             'quoteId': quoteId,
             'settleId': None,
-            'type': 'spot',
-            'spot': True,
+            'type': 'otc',
+            'spot': False,
             'margin': False,
             'swap': False,
             'future': False,

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.9.14'
+__version__ = '4.9.16'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/hamtapay.py

@@ -282,5 +282,8 @@ class hamtapay(Exchange, ImplicitAPI):
 
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         url = self.urls['api']['public'] + '/' + path
-        headers = {'Content-Type': 'application/json'}
+        headers = {
+            'Content-Type': 'application/json',
+            'Origin': 'https://hamtapay.net',
+        }
         return {'url': url, 'method': method, 'body': body, 'headers': headers}

ccxt/async_support/sarmayex.py

@@ -22,7 +22,7 @@ class sarmayex(Exchange, ImplicitAPI):
             'pro': False,
             'has': {
                 'CORS': None,
-                'spot': True,
+                'spot': False,
                 'margin': False,
                 'swap': False,
                 'future': False,
@@ -78,6 +78,7 @@ class sarmayex(Exchange, ImplicitAPI):
                 'fetchTradingFee': False,
                 'fetchTradingFees': False,
                 'fetchWithdrawals': False,
+                'otc': True,
                 'setLeverage': False,
                 'setMarginMode': False,
                 'transfer': False,
@@ -193,8 +194,8 @@ class sarmayex(Exchange, ImplicitAPI):
             'baseId': baseId,
             'quoteId': quoteId,
             'settleId': None,
-            'type': 'spot',
-            'spot': True,
+            'type': 'otc',
+            'spot': False,
             'margin': False,
             'swap': False,
             'future': False,

ccxt/async_support/tehran_exchange.py

@@ -0,0 +1,317 @@
+# -*- coding: utf-8 -*-
+
+# 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
+
+from ccxt.async_support.base.exchange import Exchange
+from ccxt.abstract.tehran_exchange import ImplicitAPI
+from ccxt.base.types import Any, Market, Strings, Ticker, Tickers
+from typing import List
+
+
+class tehran_exchange(Exchange, ImplicitAPI):
+
+    def describe(self) -> Any:
+        return self.deep_extend(super(tehran_exchange, self).describe(), {
+            'id': 'tehran_exchange',
+            'name': 'Tehran Exchange',
+            'countries': ['IR'],
+            'rateLimit': 1000,
+            'version': '1',
+            'certified': False,
+            'pro': False,
+            'has': {
+                'CORS': None,
+                'spot': True,
+                'margin': False,
+                'swap': False,
+                'future': False,
+                'option': False,
+                'addMargin': False,
+                'cancelAllOrders': False,
+                'cancelOrder': False,
+                'cancelOrders': False,
+                'createDepositAddress': False,
+                'createOrder': False,
+                'createStopLimitOrder': False,
+                'createStopMarketOrder': False,
+                'createStopOrder': False,
+                'editOrder': False,
+                'fetchBalance': False,
+                'fetchBorrowInterest': False,
+                'fetchBorrowRateHistories': False,
+                'fetchBorrowRateHistory': False,
+                'fetchClosedOrders': False,
+                'fetchCrossBorrowRate': False,
+                'fetchCrossBorrowRates': False,
+                'fetchCurrencies': False,
+                'fetchDepositAddress': False,
+                'fetchDeposits': False,
+                'fetchFundingHistory': False,
+                'fetchFundingRate': False,
+                'fetchFundingRateHistory': False,
+                'fetchFundingRates': False,
+                'fetchIndexOHLCV': False,
+                'fetchIsolatedBorrowRate': False,
+                'fetchIsolatedBorrowRates': False,
+                'fetchL2OrderBook': False,
+                'fetchLedger': False,
+                'fetchLedgerEntry': False,
+                'fetchLeverageTiers': False,
+                'fetchMarkets': True,
+                'fetchMarkOHLCV': False,
+                'fetchMyTrades': False,
+                'fetchOHLCV': False,
+                'fetchOpenInterestHistory': False,
+                'fetchOpenOrders': False,
+                'fetchOrder': False,
+                'fetchOrderBook': False,
+                'fetchOrders': False,
+                'fetchOrderTrades': 'emulated',
+                'fetchPositions': False,
+                'fetchPremiumIndexOHLCV': False,
+                'fetchTicker': True,
+                'fetchTickers': True,
+                'fetchTime': False,
+                'fetchTrades': False,
+                'fetchTradingFee': False,
+                'fetchTradingFees': False,
+                'fetchWithdrawals': False,
+                'setLeverage': False,
+                'setMarginMode': False,
+                'transfer': False,
+                'withdraw': False,
+            },
+            'comment': 'This comment is optional',
+            'urls': {
+                'logo': 'https://cdn.arz.digital/cr-odin/img/exchanges/tehran_exchange/64x64.png',
+                'api': {
+                    'public': 'https://otc-api.tehran.exchange',
+                },
+                'www': 'https://tehran.exchange',
+                'doc': [
+                    'https://tehran.exchange',
+                ],
+            },
+            'api': {
+                'public': {
+                    'get': {
+                        'otc/v1/market/pair': 1,
+                        'otc/v1/market/order/pair/price': 1,
+                    },
+                },
+            },
+            'fees': {
+                'trading': {
+                    'tierBased': False,
+                    'percentage': True,
+                    'maker': self.parse_number('0.0025'),
+                    'taker': self.parse_number('0.0025'),
+                },
+            },
+        })
+
+    async def fetch_markets(self, params={}) -> List[Market]:
+        """
+        retrieves data on all markets for tehran_exchange
+        https://otc-api.tehran.exchange/otc/v1/market/pair
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: an array of objects representing market data
+        """
+        response = await self.publicGetOtcV1MarketPair(params)
+        data = self.safe_dict(response, 'data', {})
+        pairs = self.safe_list(data, 'pairs', [])
+        result = []
+        for i in range(0, len(pairs)):
+            market = self.parse_market(pairs[i])
+            result.append(market)
+        return result
+
+    def parse_market(self, market) -> Market:
+        # {
+        #     "id": 6054,
+        #     "pair": "HBAR_USDT",
+        #     "status": "TRADABLE",
+        #     "tradable": True,
+        #     "fiatOrder": False,
+        #     "quoteName": "Tether",
+        #     "baseName": "Hedera",
+        #     "quoteNameFa": "تتر",
+        #     "baseNameFa": "هدرا هش گراف ",
+        #     "quoteImageUrl": "https://s3-dev.tehranex.com/asset/coin_icon/64/usdt.png",
+        #     "baseImageUrl": "https://s3-dev.tehranex.com/asset/coin_icon/64/hbar.png",
+        #     "quoteSymbol": "USDT",
+        #     "baseSymbol": "HBAR",
+        #     "amountPrecision": 2,
+        #     "feePercentage": 0.25,
+        #     "providerFeePercentage": 0.05,
+        #     "maxQuoteAmount": 600000,
+        #     "minBaseAmount": 0.01,
+        #     "minQuoteAmount": 1,
+        #     "pricePrecision": 5,
+        #     "baseVirtualCurrencyId": 989,
+        #     "quoteVirtualCurrencyId": 1
+        # }
+        id = self.safe_string(market, 'pair')
+        baseId = self.safe_string(market, 'baseSymbol')
+        quoteId = self.safe_string(market, 'quoteSymbol')
+        base = self.safe_currency_code(baseId)
+        quote = self.safe_currency_code(quoteId)
+        status = self.safe_string(market, 'status')
+        tradable = self.safe_bool(market, 'tradable', False)
+        active = (status == 'TRADABLE') and tradable
+        amountPrecision = self.safe_integer(market, 'amountPrecision')
+        pricePrecision = self.safe_integer(market, 'pricePrecision')
+        minBaseAmount = self.safe_string(market, 'minBaseAmount')
+        minQuoteAmount = self.safe_string(market, 'minQuoteAmount')
+        maxQuoteAmount = self.safe_string(market, 'maxQuoteAmount')
+        return {
+            'id': id,
+            'symbol': base + '/' + quote,
+            'base': base,
+            'quote': quote,
+            'settle': None,
+            'baseId': baseId,
+            'quoteId': quoteId,
+            'settleId': None,
+            'type': 'spot',
+            'spot': True,
+            'margin': False,
+            'swap': False,
+            'future': False,
+            'option': False,
+            'active': active,
+            'contract': False,
+            'linear': None,
+            'inverse': None,
+            'contractSize': None,
+            'expiry': None,
+            'expiryDatetime': None,
+            'strike': None,
+            'optionType': None,
+            'precision': {
+                'amount': amountPrecision,
+                'price': pricePrecision,
+            },
+            'limits': {
+                'leverage': {
+                    'min': None,
+                    'max': None,
+                },
+                'amount': {
+                    'min': self.parse_number(minBaseAmount),
+                    'max': None,
+                },
+                'price': {
+                    'min': None,
+                    'max': None,
+                },
+                'cost': {
+                    'min': self.parse_number(minQuoteAmount),
+                    'max': self.parse_number(maxQuoteAmount),
+                },
+            },
+            'created': None,
+            'info': market,
+        }
+
+    async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+        https://otc-api.tehran.exchange/otc/v1/market/pair
+        https://otc-api.tehran.exchange/otc/v1/market/order/pair/price
+        :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        if symbols is not None:
+            symbols = self.market_symbols(symbols)
+        response = await self.publicGetOtcV1MarketPair(params)
+        data = self.safe_dict(response, 'data', {})
+        pairs = self.safe_list(data, 'pairs', [])
+        # filter symbols from pairs
+        filteredPairs = []
+        for i in range(0, len(pairs)):
+            pair = pairs[i]
+            pairId = self.safe_string(pair, 'pair')
+            symbol = self.safe_symbol(pairId)
+            if symbols.includes(symbol):
+                filteredPairs.append(pair)
+        result = {}
+        for i in range(0, len(filteredPairs)):
+            pairData = filteredPairs[i]
+            pairId = self.safe_string(pairData, 'pair')
+            # Fetch BUY price
+            request = {
+                'pair': pairId,
+                'side': 'BUY',
+                'basedOn': 'BASE',
+                'amount': 1,
+            }
+            priceResponse = await self.publicGetOtcV1MarketOrderPairPrice(request)
+            priceData = self.safe_dict(priceResponse, 'data', {})
+            price = self.safe_float(priceData, 'price', 0)
+            pairData['price'] = price
+            ticker = self.parse_ticker(pairData)
+            symbol = ticker['symbol']
+            result[symbol] = ticker
+        return self.filter_by_array_tickers(result, 'symbol', symbols)
+
+    async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
+        """
+        fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        https://otc-api.tehran.exchange/otc/v1/market/pair
+        :param str symbol: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        ticker = await self.fetch_tickers([symbol])
+        return ticker[self.safe_symbol(symbol)]
+
+    def parse_ticker(self, ticker, market: Market = None) -> Ticker:
+        # {
+        #     "id": 6054,
+        #     "pair": "HBAR_USDT",
+        #     "status": "TRADABLE",
+        #     "tradable": True,
+        #     "baseSymbol": "HBAR",
+        #     "quoteSymbol": "USDT",
+        #     ...
+        #     "price": 12345,
+        # }
+        marketType = 'spot'
+        baseSymbol = self.safe_string(ticker, 'baseSymbol')
+        quoteSymbol = self.safe_string(ticker, 'quoteSymbol')
+        marketId = baseSymbol + '/' + quoteSymbol
+        symbol = self.safe_symbol(marketId, market, None, marketType)
+        price = self.safe_float(ticker, 'price')
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': None,
+            'datetime': None,
+            'high': None,
+            'low': None,
+            'bid': price,
+            'bidVolume': None,
+            'ask': price,
+            'askVolume': None,
+            'open': None,
+            'close': price,
+            'last': price,
+            'previousClose': None,
+            'change': None,
+            'percentage': None,
+            'average': None,
+            'baseVolume': None,
+            'quoteVolume': None,
+            'info': ticker,
+        }, market)
+
+    def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
+        query = self.omit(params, self.extract_params(path))
+        url = self.urls['api']['public'] + '/' + path
+        if query:
+            url += '?' + self.urlencode(query)
+        headers = {'Content-Type': 'application/json'}
+        return {'url': url, 'method': method, 'body': body, 'headers': headers}

ccxt/async_support/toobit.py

@@ -113,6 +113,7 @@ class toobit(Exchange, ImplicitAPI):
                     'get': {
                         'quote/v1/ticker/24hr': 1,
                         'quote/v1/klines': 1,
+                        '/api/v1/exchangeInfo': 1,
                     },
                 },
             },
@@ -129,48 +130,98 @@ class toobit(Exchange, ImplicitAPI):
     async def fetch_markets(self, params={}) -> List[Market]:
         """
         retrieves data on all markets for toobit
-        https://apidocs.toobit.io/#tickers
+        https://api.toobit.com/api/v1/exchangeInfo
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
-        response = await self.publicGetQuoteV1Ticker24hr()
+        response = await self.publicGetApiV1ExchangeInfo()
+        symbols = self.safe_value(response, 'symbols', [])
         result = []
-        for i in range(0, len(response)):
-            volume = self.safe_float(response[i], 'v')
-            symbol = self.safe_value(response[i], 's')
-            if volume == 0 or symbol == 'TESTA1S3TESTX8Z9':
+        for i in range(0, len(symbols)):
+            symbolData = symbols[i]
+            status = self.safe_value(symbolData, 'status')
+            symbol = self.safe_value(symbolData, 'symbol')
+            if status != 'TRADING' or symbol == 'TESTA1S3TESTX8Z9':
                 continue
-            market = self.parse_market(response[i])
+            market = self.parse_market(symbolData)
             result.append(market)
         return result
 
     def parse_market(self, market) -> Market:
         #         {
-        # t: 1757164008834,
-        # s: "BTCUSDT",
-        # c: "110895.06",
-        # h: "113310.01",
-        # l: "110219.01",
-        # o: "112951.99",
-        # v: "3893.406649",
-        # qv: "433374169.27969515",
-        # pc: "-2056.93",
-        # pcp: "-0.0182"
-        # }
-        symbol = self.safe_value(market, 's')
-        baseId = symbol
-        quoteId = None
-        if symbol.endswith('USDT'):
-            baseId = symbol[0:-4]
-            quoteId = 'USDT'
-        elif symbol.endswith('USDC'):
-            baseId = symbol[0:-4]
-            quoteId = 'USDC'
+        #             "filters": [
+        #                 {
+        #                     "minPrice": "0.01",
+        #                     "maxPrice": "10000000.00000000",
+        #                     "tickSize": "0.01",
+        #                     "filterType": "PRICE_FILTER"
+        #                 },
+        #                 {
+        #                     "minQty": "0.0001",
+        #                     "maxQty": "4000",
+        #                     "stepSize": "0.0001",
+        #                     "filterType": "LOT_SIZE"
+        #                 },
+        #                 {
+        #                     "minNotional": "5",
+        #                     "filterType": "MIN_NOTIONAL"
+        #                 }
+        #             ],
+        #             "exchangeId": "301",
+        #             "symbol": "ETHUSDT",
+        #             "symbolName": "ETHUSDT",
+        #             "status": "TRADING",
+        #             "baseAsset": "ETH",
+        #             "baseAssetName": "ETH",
+        #             "baseAssetPrecision": "0.0001",
+        #             "quoteAsset": "USDT",
+        #             "quoteAssetName": "USDT",
+        #             "quotePrecision": "0.01",
+        #             "icebergAllowed": False,
+        #             "isAggregate": False,
+        #             "allowMargin": True
+        #         }
+        symbol = self.safe_value(market, 'symbol')
+        baseAsset = self.safe_value(market, 'baseAsset')
+        quoteAsset = self.safe_value(market, 'quoteAsset')
+        baseAssetPrecision = self.safe_value(market, 'baseAssetPrecision')
+        quotePrecision = self.safe_value(market, 'quotePrecision')
+        allowMargin = self.safe_value(market, 'allowMargin', False)
+        filters = self.safe_value(market, 'filters', [])
+        # Parse filters to extract limits and precision
+        minPrice = None
+        maxPrice = None
+        tickSize = None
+        minQty = None
+        maxQty = None
+        stepSize = None
+        minNotional = None
+        minAmount = None
+        maxAmount = None
+        for i in range(0, len(filters)):
+            filter = filters[i]
+            filterType = self.safe_value(filter, 'filterType')
+            if filterType == 'PRICE_FILTER':
+                minPrice = self.safe_number(filter, 'minPrice')
+                maxPrice = self.safe_number(filter, 'maxPrice')
+                tickSize = self.safe_number(filter, 'tickSize')
+            elif filterType == 'LOT_SIZE':
+                minQty = self.safe_number(filter, 'minQty')
+                maxQty = self.safe_number(filter, 'maxQty')
+                stepSize = self.safe_number(filter, 'stepSize')
+            elif filterType == 'MIN_NOTIONAL':
+                minNotional = self.safe_number(filter, 'minNotional')
+            elif filterType == 'TRADE_AMOUNT':
+                minAmount = self.safe_number(filter, 'minAmount')
+                maxAmount = self.safe_number(filter, 'maxAmount')
         id = symbol
-        base = self.safe_currency_code(baseId)
-        quote = self.safe_currency_code(quoteId)
-        baseId = baseId.lower()
-        quoteId = quoteId.lower()
+        base = self.safe_currency_code(baseAsset)
+        quote = self.safe_currency_code(quoteAsset)
+        baseId = baseAsset.lower()
+        quoteId = quoteAsset.lower()
+        # Calculate precision from step sizes and precision strings
+        amountPrecision = str(self.precision_from_string(stepSize)) if stepSize else self.precision_from_string(baseAssetPrecision)
+        pricePrecision = str(self.precision_from_string(tickSize)) if tickSize else self.precision_from_string(quotePrecision)
         return {
             'id': id,
             'symbol': base + '/' + quote,
@@ -182,7 +233,7 @@ class toobit(Exchange, ImplicitAPI):
             'settleId': None,
             'type': 'spot',
             'spot': True,
-            'margin': False,
+            'margin': allowMargin,
             'swap': False,
             'future': False,
             'option': False,
@@ -196,8 +247,8 @@ class toobit(Exchange, ImplicitAPI):
             'strike': None,
             'optionType': None,
             'precision': {
-                'amount': None,
-                'price': None,
+                'amount': amountPrecision,
+                'price': pricePrecision,
             },
             'limits': {
                 'leverage': {
@@ -205,16 +256,16 @@ class toobit(Exchange, ImplicitAPI):
                     'max': None,
                 },
                 'amount': {
-                    'min': None,
-                    'max': None,
+                    'min': minQty,
+                    'max': maxQty,
                 },
                 'price': {
-                    'min': None,
-                    'max': None,
+                    'min': minPrice,
+                    'max': maxPrice,
                 },
                 'cost': {
-                    'min': None,
-                    'max': None,
+                    'min': minNotional or minAmount,
+                    'max': maxAmount,
                 },
             },
             'created': None,
@@ -224,7 +275,7 @@ class toobit(Exchange, ImplicitAPI):
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        https://apidocs.toobit.io/#tickers
+        https://toobit-docs.github.io/apidocs/spot/v1/en/#tickers
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -246,7 +297,7 @@ class toobit(Exchange, ImplicitAPI):
     async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-        https://apidocs.toobit.io/#ticker
+        https://toobit-docs.github.io/apidocs/spot/v1/en/#ticker
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -315,7 +366,7 @@ class toobit(Exchange, ImplicitAPI):
     async def fetch_ohlcv(self, symbol: str, timeframe='1h', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-        https://apidocs.toobit.io/#chart
+        https://toobit-docs.github.io/apidocs/spot/v1/en/#chart
         :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