ccxt 4.4.73__py2.py3-none-any.whl → 4.4.75__py2.py3-none-any.whl

ccxt/async_support/bitmart.py

@@ -104,7 +104,7 @@ class bitmart(Exchange, ImplicitAPI):
                 'fetchOrders': False,
                 'fetchOrderTrades': True,
                 'fetchPosition': True,
-                'fetchPositionMode': False,
+                'fetchPositionMode': True,
                 'fetchPositions': True,
                 'fetchStatus': True,
                 'fetchTicker': True,
@@ -126,6 +126,7 @@ class bitmart(Exchange, ImplicitAPI):
                 'repayIsolatedMargin': True,
                 'setLeverage': True,
                 'setMarginMode': False,
+                'setPositionMode': True,
                 'transfer': True,
                 'withdraw': True,
             },
@@ -231,6 +232,7 @@ class bitmart(Exchange, ImplicitAPI):
                         'contract/private/affilate/rebate-list': 10,
                         'contract/private/affilate/trade-list': 10,
                         'contract/private/transaction-history': 10,
+                        'contract/private/get-position-mode': 1,
                     },
                     'post': {
                         # sub-account endpoints
@@ -283,6 +285,7 @@ class bitmart(Exchange, ImplicitAPI):
                         'contract/private/modify-tp-sl-order': 2.5,
                         'contract/private/submit-trail-order': 2.5,  # weight is not provided by the exchange, is set order
                         'contract/private/cancel-trail-order': 1.5,  # weight is not provided by the exchange, is set order
+                        'contract/private/set-position-mode': 1,
                     },
                 },
             },
@@ -1205,7 +1208,7 @@ class bitmart(Exchange, ImplicitAPI):
         #     {
         #         "message": "OK",
         #         "code": 1000,
-        #         "trace": "619294ecef584282b26a3be322b1e01f.66.17403093228242228",
+        #         "trace": "619294ecef584282b26a3be322b1e01f.66.17403093228242229",
         #         "data": {
         #             "currencies": [
         #                 {
@@ -3847,10 +3850,11 @@ class bitmart(Exchange, ImplicitAPI):
         timestamp = self.safe_integer(transaction, 'apply_time')
         currencyId = self.safe_string(transaction, 'currency')
         networkId: Str = None
-        if currencyId.find('NFT') < 0:
-            parts = currencyId.split('-')
-            currencyId = self.safe_string(parts, 0)
-            networkId = self.safe_string(parts, 1)
+        if currencyId is not None:
+            if currencyId.find('NFT') < 0:
+                parts = currencyId.split('-')
+                currencyId = self.safe_string(parts, 0)
+                networkId = self.safe_string(parts, 1)
         code = self.safe_currency_code(currencyId, currency)
         status = self.parse_transaction_status(self.safe_string(transaction, 'status'))
         feeCost = self.safe_number(transaction, 'fee')
@@ -5212,6 +5216,66 @@ class bitmart(Exchange, ImplicitAPI):
                 addresses.append(address)
         return addresses
 
+    async def set_position_mode(self, hedged: bool, symbol: Str = None, params={}):
+        """
+        set hedged to True or False for a market
+
+        https://developer-pro.bitmart.com/en/futuresv2/#submit-leverage-signed
+
+        :param bool hedged: set to True to use dualSidePosition
+        :param str symbol: not used by bingx setPositionMode()
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: response from the exchange
+        """
+        await self.load_markets()
+        positionMode = None
+        if hedged:
+            positionMode = 'hedge_mode'
+        else:
+            positionMode = 'one_way_mode'
+        request: dict = {
+            'position_mode': positionMode,
+        }
+        #
+        # {
+        #     "code": 1000,
+        #     "trace": "0cc6f4c4-8b8c-4253-8e90-8d3195aa109c",
+        #     "message": "Ok",
+        #     "data": {
+        #       "position_mode":"one_way_mode"
+        #     }
+        # }
+        #
+        return await self.privatePostContractPrivateSetPositionMode(self.extend(request, params))
+
+    async def fetch_position_mode(self, symbol: Str = None, params={}):
+        """
+        fetchs the position mode, hedged or one way, hedged for binance is set identically for all linear markets or all inverse markets
+
+        https://developer-pro.bitmart.com/en/futuresv2/#get-position-mode-keyed
+
+        :param str symbol: not used
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an object detailing whether the market is in hedged or one-way mode
+        """
+        response = await self.privateGetContractPrivateGetPositionMode(params)
+        #
+        # {
+        #     "code": 1000,
+        #     "trace": "0cc6f4c4-8b8c-4253-8e90-8d3195aa109c",
+        #     "message": "Ok",
+        #     "data": {
+        #       "position_mode":"one_way_mode"
+        #     }
+        # }
+        #
+        data = self.safe_dict(response, 'data')
+        positionMode = self.safe_string(data, 'position_mode')
+        return {
+            'info': response,
+            'hedged': (positionMode == 'hedge_mode'),
+        }
+
     def nonce(self):
         return self.milliseconds() - self.options['timeDifference']
 

ccxt/async_support/bitopro.py

@@ -36,19 +36,29 @@ class bitopro(Exchange, ImplicitAPI):
                 'swap': False,
                 'future': False,
                 'option': False,
+                'addMargin': False,
+                'borrowCrossMargin': False,
+                'borrowIsolatedMargin': False,
+                'borrowMargin': False,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
                 'cancelOrders': True,
                 'closeAllPositions': False,
                 'closePosition': False,
                 'createOrder': True,
+                'createOrderWithTakeProfitAndStopLoss': False,
+                'createOrderWithTakeProfitAndStopLossWs': False,
                 'createReduceOnlyOrder': False,
                 'createStopOrder': True,
                 'createTriggerOrder': True,
                 'editOrder': False,
                 'fetchBalance': True,
+                'fetchBorrowInterest': False,
+                'fetchBorrowRate': False,
                 'fetchBorrowRateHistories': False,
                 'fetchBorrowRateHistory': False,
+                'fetchBorrowRates': False,
+                'fetchBorrowRatesPerSymbol': False,
                 'fetchClosedOrders': True,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
@@ -59,19 +69,39 @@ class bitopro(Exchange, ImplicitAPI):
                 'fetchDepositWithdrawFee': 'emulated',
                 'fetchDepositWithdrawFees': True,
                 'fetchFundingHistory': False,
+                'fetchFundingInterval': False,
+                'fetchFundingIntervals': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
                 'fetchFundingRates': False,
+                'fetchGreeks': False,
                 'fetchIndexOHLCV': False,
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
+                'fetchIsolatedPositions': False,
+                'fetchLeverage': False,
+                'fetchLeverages': False,
+                'fetchLeverageTiers': False,
+                'fetchLiquidations': False,
+                'fetchLongShortRatio': False,
+                'fetchLongShortRatioHistory': False,
+                'fetchMarginAdjustmentHistory': False,
                 'fetchMarginMode': False,
+                'fetchMarginModes': False,
+                'fetchMarketLeverageTiers': False,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': False,
+                'fetchMarkPrices': False,
+                'fetchMyLiquidations': False,
+                'fetchMySettlementHistory': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
+                'fetchOpenInterest': False,
                 'fetchOpenInterestHistory': False,
+                'fetchOpenInterests': False,
                 'fetchOpenOrders': True,
+                'fetchOption': False,
+                'fetchOptionChain': False,
                 'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchOrders': False,
@@ -84,6 +114,7 @@ class bitopro(Exchange, ImplicitAPI):
                 'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
+                'fetchSettlementHistory': False,
                 'fetchTicker': True,
                 'fetchTickers': True,
                 'fetchTime': False,
@@ -94,10 +125,16 @@ class bitopro(Exchange, ImplicitAPI):
                 'fetchTransactions': False,
                 'fetchTransfer': False,
                 'fetchTransfers': False,
+                'fetchVolatilityHistory': False,
                 'fetchWithdrawal': True,
                 'fetchWithdrawals': True,
+                'reduceMargin': False,
+                'repayCrossMargin': False,
+                'repayIsolatedMargin': False,
                 'setLeverage': False,
+                'setMargin': False,
                 'setMarginMode': False,
+                'setPositionMode': False,
                 'transfer': False,
                 'withdraw': True,
             },

ccxt/async_support/blofin.py

@@ -66,7 +66,7 @@ class blofin(Exchange, ImplicitAPI):
                 'fetchBorrowRateHistory': False,
                 'fetchCanceledOrders': False,
                 'fetchClosedOrder': False,
-                'fetchClosedOrders': False,
+                'fetchClosedOrders': True,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
                 'fetchCurrencies': False,

ccxt/async_support/bybit.py

@@ -2390,6 +2390,7 @@ class bybit(Exchange, ImplicitAPI):
         :returns dict: an array of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
+        code = self.safe_string_n(params, ['code', 'currency', 'baseCoin'])
         market = None
         parsedSymbols = None
         if symbols is not None:
@@ -2411,6 +2412,12 @@ class bybit(Exchange, ImplicitAPI):
                     currentType = market['type']
                 elif market['type'] != currentType:
                     raise BadRequest(self.id + ' fetchTickers can only accept a list of symbols of the same type')
+                if market['option']:
+                    if code is not None and code != market['base']:
+                        raise BadRequest(self.id + ' fetchTickers the base currency must be the same for all symbols, self endpoint only supports one base currency at a time. Read more about it here: https://bybit-exchange.github.io/docs/v5/market/tickers')
+                    if code is None:
+                        code = market['base']
+                    params = self.omit(params, ['code', 'currency'])
                 parsedSymbols.append(market['symbol'])
         request: dict = {
             # 'symbol': market['id'],
@@ -2430,7 +2437,9 @@ class bybit(Exchange, ImplicitAPI):
             request['category'] = 'spot'
         elif type == 'option':
             request['category'] = 'option'
-            request['baseCoin'] = self.safe_string(params, 'baseCoin', 'BTC')
+            if code is None:
+                code = 'BTC'
+            request['baseCoin'] = code
         elif type == 'swap' or type == 'future' or subType is not None:
             request['category'] = subType
         response = await self.publicGetV5MarketTickers(self.extend(request, params))

ccxt/async_support/coinlist.py

@@ -171,6 +171,7 @@ class coinlist(Exchange, ImplicitAPI):
                         'v1/leaderboard': 1,
                         'v1/affiliate/{competition_code}': 1,
                         'v1/competition/{competition_id}': 1,
+                        'v1/symbols/{symbol}/funding': 1,
                     },
                 },
                 'private': {
@@ -194,6 +195,7 @@ class coinlist(Exchange, ImplicitAPI):
                         'v1/credits': 1,  # not unified
                         'v1/positions': 1,
                         'v1/accounts/{trader_id}/competitions': 1,
+                        'v1/closedPositions': 1,
                     },
                     'post': {
                         'v1/keys': 1,  # not unified
@@ -212,6 +214,9 @@ class coinlist(Exchange, ImplicitAPI):
                         'v1/orders/{order_id}': 1,
                         'v1/orders/bulk': 1,  # not unified
                     },
+                    'put': {
+                        'v1/accounts/{trader_id}/alias': 1,
+                    },
                     'delete': {
                         'v1/keys/{key}': 1,  # not unified
                         'v1/orders': 1,
@@ -501,7 +506,7 @@ class coinlist(Exchange, ImplicitAPI):
         #     {
         #         "symbols": [
         #             {
-        #                 "symbol": "CQT-USDT",
+        #                 "symbol": "CQT-USDT",  # spot
         #                 "base_currency": "CQT",
         #                 "is_trader_geofenced": False,
         #                 "list_time": "2021-06-15T00:00:00.000Z",
@@ -526,6 +531,62 @@ class coinlist(Exchange, ImplicitAPI):
         return self.parse_markets(markets)
 
     def parse_market(self, market: dict) -> Market:
+        # perp
+        #   {
+        #       "symbol":"BTC-PERP",
+        #       "base_currency":"BTC",
+        #       "is_trader_geofenced":false,
+        #       "expiry_name":null,
+        #       "expiry_time":null,
+        #       "list_time":"2024-09-16T00:00:00.000Z",
+        #       "type":"perp-swap",
+        #       "series_code":"BTC",
+        #       "long_name":"Bitcoin",
+        #       "asset_class":"CRYPTO",
+        #       "minimum_price_increment":"0.01",
+        #       "minimum_size_increment":"0.0001",
+        #       "quote_currency":"USDT",
+        #       "multiplier":"1",
+        #       "contract_frequency":"FGHJKMNQUVXZ",
+        #       "index_code":".BTC-USDT",
+        #       "price_band_threshold_market":"0.05",
+        #       "price_band_threshold_limit":"0.25",
+        #       "maintenance_initial_ratio":"0.500000000000000000",
+        #       "liquidation_initial_ratio":"0.500000000000000000",
+        #       "last_price":"75881.36000000",
+        #       "fair_price":"76256.00000000",
+        #       "index_price":"77609.90000000",
+        #       "mark_price":"76237.75000000",
+        #       "mark_price_dollarizer":"0.99950000",
+        #       "funding_interval":{
+        #          "hours":"8"
+        #       },
+        #       "funding_rate_index_code":".BTC-USDT-FR8H",
+        #       "initial_margin_base":"0.200000000000000000",
+        #       "initial_margin_per_contract":"0.160000000000000000",
+        #       "position_limit":"5.0000"
+        #   }
+        # spot
+        #    {
+        #        "symbol": "CQT-USDT",  # spot
+        #        "base_currency": "CQT",
+        #        "is_trader_geofenced": False,
+        #        "list_time": "2021-06-15T00:00:00.000Z",
+        #        "type": "spot",
+        #        "series_code": "CQT-USDT-SPOT",
+        #        "long_name": "Covalent",
+        #        "asset_class": "CRYPTO",
+        #        "minimum_price_increment": "0.0001",
+        #        "minimum_size_increment": "0.0001",
+        #        "quote_currency": "USDT",
+        #        "index_code": null,
+        #        "price_band_threshold_market": "0.05",
+        #        "price_band_threshold_limit": "0.25",
+        #        "last_price": "0.12160000",
+        #        "fair_price": "0.12300000",
+        #        "index_price": null
+        #    }
+        isSwap = self.safe_string(market, 'type') == 'perp-swap'
         id = self.safe_string(market, 'symbol')
         baseId = self.safe_string(market, 'base_currency')
         quoteId = self.safe_string(market, 'quote_currency')
@@ -534,26 +595,40 @@ class coinlist(Exchange, ImplicitAPI):
         amountPrecision = self.safe_string(market, 'minimum_size_increment')
         pricePrecision = self.safe_string(market, 'minimum_price_increment')
         created = self.safe_string(market, 'list_time')
+        settledId = None
+        settled = None
+        linear = None
+        inverse = None
+        contractSize = None
+        symbol = base + '/' + quote
+        if isSwap:
+            contractSize = self.parse_number('1')
+            linear = True
+            inverse = False
+            settledId = quoteId
+            settled = quote
+            symbol = symbol + ':' + quote
+        type = 'swap' if isSwap else 'spot'
         return {
             'id': id,
-            'symbol': base + '/' + quote,
+            'symbol': symbol,
             'base': base,
             'quote': quote,
-            'settle': None,
+            'settle': settled,
             'baseId': baseId,
             'quoteId': quoteId,
-            'settleId': None,
-            'type': 'spot',
-            'spot': True,
+            'settleId': settledId,
+            'type': type,
+            'spot': not isSwap,
             'margin': False,
-            'swap': False,
+            'swap': isSwap,
             'future': False,
             'option': False,
             'active': True,
-            'contract': False,
-            'linear': None,
-            'inverse': None,
-            'contractSize': None,
+            'contract': isSwap,
+            'linear': linear,
+            'inverse': inverse,
+            'contractSize': contractSize,
             'expiry': None,
             'expiryDatetime': None,
             'strike': None,

ccxt/async_support/deribit.py

@@ -1321,13 +1321,32 @@ class deribit(Exchange, ImplicitAPI):
         await self.load_markets()
         symbols = self.market_symbols(symbols)
         code = self.safe_string_2(params, 'code', 'currency')
+        type = None
         params = self.omit(params, ['code'])
+        if symbols is not None:
+            for i in range(0, len(symbols)):
+                market = self.market(symbols[i])
+                if code is not None and code != market['base']:
+                    raise BadRequest(self.id + ' fetchTickers the base currency must be the same for all symbols, self endpoint only supports one base currency at a time. Read more about it here: https://docs.deribit.com/#public-get_book_summary_by_currency')
+                if code is None:
+                    code = market['base']
+                    type = market['type']
         if code is None:
             raise ArgumentsRequired(self.id + ' fetchTickers requires a currency/code(eg: BTC/ETH/USDT) parameter to fetch tickers for')
         currency = self.currency(code)
         request: dict = {
             'currency': currency['id'],
         }
+        if type is not None:
+            requestType = None
+            if type == 'spot':
+                requestType = 'spot'
+            elif type == 'future' or (type == 'contract'):
+                requestType = 'future'
+            elif type == 'option':
+                requestType = 'option'
+            if requestType is not None:
+                request['kind'] = requestType
         response = await self.publicGetGetBookSummaryByCurrency(self.extend(request, params))
         #
         #     {

ccxt/async_support/gate.py

@@ -1485,6 +1485,10 @@ class gate(Exchange, ImplicitAPI):
         takerPercent = self.safe_string(market, 'taker_fee_rate')
         makerPercent = self.safe_string(market, 'maker_fee_rate', takerPercent)
         isLinear = quote == settle
+        contractSize = self.safe_string(market, 'quanto_multiplier')
+        # exception only for one market: https://api.gateio.ws/api/v4/futures/btc/contracts
+        if contractSize == '0':
+            contractSize = '1'  # 1 USD in WEB: https://i.imgur.com/MBBUI04.png
         return {
             'id': id,
             'symbol': symbol,
@@ -1506,7 +1510,7 @@ class gate(Exchange, ImplicitAPI):
             'inverse': not isLinear,
             'taker': self.parse_number(Precise.string_div(takerPercent, '100')),  # Fee is in %, so divide by 100
             'maker': self.parse_number(Precise.string_div(makerPercent, '100')),
-            'contractSize': self.safe_number(market, 'quanto_multiplier'),
+            'contractSize': self.parse_number(contractSize),
             'expiry': expiry,
             'expiryDatetime': self.iso8601(expiry),
             'strike': None,
@@ -1819,9 +1823,9 @@ class gate(Exchange, ImplicitAPI):
             partFirst = self.safe_string(parts, 0)
             # if there's an underscore then the second part is always the chain name(except the _OLD suffix)
             currencyName = currencyId if currencyId.endswith('_OLD') else partFirst
-            withdrawEnabled = not self.safe_bool(entry, 'withdraw_disabled')
-            depositEnabled = not self.safe_bool(entry, 'deposit_disabled')
-            tradeDisabled = not self.safe_bool(entry, 'trade_disabled')
+            withdrawDisabled = self.safe_bool(entry, 'withdraw_disabled', False)
+            depositDisabled = self.safe_bool(entry, 'deposit_disabled', False)
+            tradeDisabled = self.safe_bool(entry, 'trade_disabled', False)
             precision = self.parse_number('0.0001')  # temporary safe default, because no value provided from API
             code = self.safe_currency_code(currencyName)
             # check leveraged tokens(e.g. BTC3S, ETH5L)
@@ -1849,8 +1853,8 @@ class gate(Exchange, ImplicitAPI):
                     },
                 },
                 'active': not tradeDisabled,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
+                'deposit': not depositDisabled,
+                'withdraw': not withdrawDisabled,
                 'fee': None,
                 'precision': precision,
             }
@@ -6366,7 +6370,7 @@ class gate(Exchange, ImplicitAPI):
                     queryString = self.urlencode(query)
                     # https://github.com/ccxt/ccxt/issues/25570
                     if queryString.find('currencies=') >= 0 and queryString.find('%2C') >= 0:
-                        queryString = queryString.replace('%2', ',')
+                        queryString = queryString.replace('%2C', ',')
                     url += '?' + queryString
                 if method == 'PATCH':
                     body = self.json(query)

ccxt/async_support/hitbtc.py

@@ -44,7 +44,7 @@ class hitbtc(Exchange, ImplicitAPI):
                 'margin': True,
                 'swap': True,
                 'future': False,
-                'option': None,
+                'option': False,
                 'addMargin': True,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
@@ -76,6 +76,7 @@ class hitbtc(Exchange, ImplicitAPI):
                 'fetchFundingRate': True,
                 'fetchFundingRateHistory': True,
                 'fetchFundingRates': True,
+                'fetchGreeks': False,
                 'fetchIndexOHLCV': True,
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
@@ -88,6 +89,7 @@ class hitbtc(Exchange, ImplicitAPI):
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': True,
                 'fetchMyLiquidations': False,
+                'fetchMySettlementHistory': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,
@@ -95,6 +97,8 @@ class hitbtc(Exchange, ImplicitAPI):
                 'fetchOpenInterests': True,
                 'fetchOpenOrder': True,
                 'fetchOpenOrders': True,
+                'fetchOption': False,
+                'fetchOptionChain': False,
                 'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchOrderBooks': True,
@@ -103,12 +107,14 @@ class hitbtc(Exchange, ImplicitAPI):
                 'fetchPosition': True,
                 'fetchPositions': True,
                 'fetchPremiumIndexOHLCV': True,
+                'fetchSettlementHistory': False,
                 'fetchTicker': True,
                 'fetchTickers': True,
                 'fetchTrades': True,
                 'fetchTradingFee': True,
                 'fetchTradingFees': True,
                 'fetchTransactions': 'emulated',
+                'fetchVolatilityHistory': False,
                 'fetchWithdrawals': True,
                 'reduceMargin': True,
                 'sandbox': True,

ccxt/async_support/okx.py

@@ -1294,6 +1294,7 @@ class okx(Exchange, ImplicitAPI):
                     },
                     'fetchOHLCV': {
                         'limit': 300,
+                        'historical': 100,
                     },
                 },
                 'spot': {
@@ -1824,31 +1825,31 @@ class okx(Exchange, ImplicitAPI):
             chainsLength = len(chains)
             for j in range(0, chainsLength):
                 chain = chains[j]
-                networkId = self.safe_string(chain, 'chain')  # USDT-BEP20, USDT-Avalance-C, etc
-                if networkId is not None:
-                    idParts = networkId.split('-')
-                    parts = self.array_slice(idParts, 1)
-                    chainPart = '-'.join(parts)
-                    networkCode = self.network_id_to_code(chainPart, currency['code'])
-                    networks[networkCode] = {
-                        'id': networkId,
-                        'network': networkCode,
-                        'active': None,
-                        'deposit': self.safe_bool(chain, 'canDep'),
-                        'withdraw': self.safe_bool(chain, 'canWd'),
-                        'fee': self.safe_number(chain, 'fee'),
-                        'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'wdTickSz'))),
-                        'limits': {
-                            'withdraw': {
-                                'min': self.safe_number(chain, 'minWd'),
-                                'max': self.safe_number(chain, 'maxWd'),
-                            },
-                        },
-                        'info': chain,
-                    }
-                else:
-                    # only happens for FIAT currency
+                # allow empty string for rare fiat-currencies, e.g. TRY
+                networkId = self.safe_string(chain, 'chain', '')  # USDT-BEP20, USDT-Avalance-C, etc
+                if networkId == '':
+                    # only happens for fiat 'TRY' currency
                     type = 'fiat'
+                idParts = networkId.split('-')
+                parts = self.array_slice(idParts, 1)
+                chainPart = '-'.join(parts)
+                networkCode = self.network_id_to_code(chainPart, currency['code'])
+                networks[networkCode] = {
+                    'id': networkId,
+                    'network': networkCode,
+                    'active': None,
+                    'deposit': self.safe_bool(chain, 'canDep'),
+                    'withdraw': self.safe_bool(chain, 'canWd'),
+                    'fee': self.safe_number(chain, 'fee'),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'wdTickSz'))),
+                    'limits': {
+                        'withdraw': {
+                            'min': self.safe_number(chain, 'minWd'),
+                            'max': self.safe_number(chain, 'maxWd'),
+                        },
+                    },
+                    'info': chain,
+                }
             firstChain = self.safe_dict(chains, 0, {})
             result[code] = self.safe_currency_structure({
                 'info': chains,
@@ -2385,6 +2386,8 @@ class okx(Exchange, ImplicitAPI):
         timezone = self.safe_string(options, 'timezone', 'UTC')
         if limit is None:
             limit = 100  # default 100, max 100
+        else:
+            limit = min(limit, 300)  # max 100
         duration = self.parse_timeframe(timeframe)
         bar = self.safe_string(self.timeframes, timeframe, timeframe)
         if (timezone == 'UTC') and (duration >= 21600):  # if utc and timeframe >= 6h
@@ -2402,6 +2405,7 @@ class okx(Exchange, ImplicitAPI):
             historyBorder = now - ((1440 - 1) * durationInMilliseconds)
             if since < historyBorder:
                 defaultType = 'HistoryCandles'
+                limit = min(limit, 100)  # max 100 for historical endpoint
             startTime = max(since - 1, 0)
             request['before'] = startTime
             request['after'] = self.sum(since, durationInMilliseconds * limit)