ccxt 4.0.100__py2.py3-none-any.whl → 4.0.102__py2.py3-none-any.whl

ccxt/async_support/bitmart.py

@@ -76,6 +76,9 @@ class bitmart(Exchange, ImplicitAPI):
                 'fetchDepositWithdrawFee': True,
                 'fetchDepositWithdrawFees': False,
                 'fetchFundingHistory': None,
+                'fetchFundingRate': True,
+                'fetchFundingRateHistory': False,
+                'fetchFundingRates': False,
                 'fetchMarginMode': False,
                 'fetchMarkets': True,
                 'fetchMyTrades': True,
@@ -3084,6 +3087,69 @@ class bitmart(Exchange, ImplicitAPI):
         }
         return await self.privatePostContractPrivateSubmitLeverage(self.extend(request, params))
 
+    async def fetch_funding_rate(self, symbol: str, params={}):
+        """
+        fetch the current funding rate
+        see https://developer-pro.bitmart.com/en/futures/#get-current-funding-rate
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the bitmart api endpoint
+        :returns dict: a `funding rate structure <https://github.com/ccxt/ccxt/wiki/Manual#funding-rate-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        if not market['swap']:
+            raise BadSymbol(self.id + ' fetchFundingRate() supports swap contracts only')
+        request = {
+            'symbol': market['id'],
+        }
+        response = await self.publicGetContractPublicFundingRate(self.extend(request, params))
+        #
+        #     {
+        #         "code": 1000,
+        #         "message": "Ok",
+        #         "data": {
+        #             "timestamp": 1695184410697,
+        #             "symbol": "BTCUSDT",
+        #             "rate_value": "-0.00002614",
+        #             "expected_rate": "-0.00002"
+        #         },
+        #         "trace": "4cad855074654097ac7ba5257c47305d.54.16951844206655589"
+        #     }
+        #
+        data = self.safe_value(response, 'data', {})
+        return self.parse_funding_rate(data, market)
+
+    def parse_funding_rate(self, contract, market=None):
+        #
+        #     {
+        #         "timestamp": 1695184410697,
+        #         "symbol": "BTCUSDT",
+        #         "rate_value": "-0.00002614",
+        #         "expected_rate": "-0.00002"
+        #     }
+        #
+        marketId = self.safe_string(contract, 'symbol')
+        timestamp = self.safe_integer(contract, 'timestamp')
+        return {
+            'info': contract,
+            'symbol': self.safe_symbol(marketId, market),
+            'markPrice': None,
+            'indexPrice': None,
+            'interestRate': None,
+            'estimatedSettlePrice': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'fundingRate': self.safe_number(contract, 'expected_rate'),
+            'fundingTimestamp': None,
+            'fundingDatetime': None,
+            'nextFundingRate': None,
+            'nextFundingTimestamp': None,
+            'nextFundingDatetime': None,
+            'previousFundingRate': self.safe_number(contract, 'rate_value'),
+            'previousFundingTimestamp': None,
+            'previousFundingDatetime': None,
+        }
+
     def nonce(self):
         return self.milliseconds()
 

ccxt/async_support/bitstamp1.py

@@ -213,6 +213,17 @@ class bitstamp1(Exchange, ImplicitAPI):
         return self.parse_ticker(ticker, market)
 
     def parse_trade(self, trade, market=None):
+        #
+        # public trade
+        #
+        #        {
+        #            "amount": "0.00114000",
+        #            "date": "1694287856",
+        #            "price": "25865",
+        #            "tid": 298730788,
+        #            "type": 0
+        #        }
+        #
         timestamp = self.safe_timestamp_2(trade, 'date', 'datetime')
         side = 'buy' if (trade['type'] == 0) else 'sell'
         orderId = self.safe_string(trade, 'order_id')
@@ -254,6 +265,17 @@ class bitstamp1(Exchange, ImplicitAPI):
             'time': 'minute',
         }
         response = await self.publicGetTransactions(self.extend(request, params))
+        #
+        #    [
+        #        {
+        #            "amount": "0.00114000",
+        #            "date": "1694287856",
+        #            "price": "25865",
+        #            "tid": 298730788,
+        #            "type": 0
+        #        },
+        #    ]
+        #
         return self.parse_trades(response, market, since, limit)
 
     def parse_balance(self, response):

ccxt/async_support/bl3p.py

@@ -35,6 +35,9 @@ class bl3p(Exchange, ImplicitAPI):
                 'cancelOrder': True,
                 'createOrder': True,
                 'createReduceOnlyOrder': False,
+                'createStopLimitOrder': False,
+                'createStopMarketOrder': False,
+                'createStopOrder': False,
                 'fetchBalance': True,
                 'fetchBorrowRate': False,
                 'fetchBorrowRateHistories': False,
@@ -237,6 +240,16 @@ class bl3p(Exchange, ImplicitAPI):
         return self.parse_ticker(ticker, market)
 
     def parse_trade(self, trade, market=None):
+        #
+        # fetchTrades
+        #
+        #     {
+        #         "trade_id": "2518789",
+        #         "date": "1694348697745",
+        #         "amount_int": "2959153",
+        #         "price_int": "2416231440"
+        #     }
+        #
         id = self.safe_string(trade, 'trade_id')
         timestamp = self.safe_integer(trade, 'date')
         price = self.safe_string(trade, 'price_int')
@@ -271,6 +284,20 @@ class bl3p(Exchange, ImplicitAPI):
         response = await self.publicGetMarketTrades(self.extend({
             'market': market['id'],
         }, params))
+        #
+        #    {
+        #        "result": "success",
+        #        "data": {
+        #            "trades": [
+        #                {
+        #                    "trade_id": "2518789",
+        #                    "date": "1694348697745",
+        #                    "amount_int": "2959153",
+        #                    "price_int": "2416231440"
+        #                },
+        #            ]
+        #        }
+        #     }
         result = self.parse_trades(response['data']['trades'], market, since, limit)
         return result
 
@@ -329,12 +356,17 @@ class bl3p(Exchange, ImplicitAPI):
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
         """
         create a trade order
+        see https://github.com/BitonicNL/bl3p-api/blob/master/examples/nodejs/example.md#21---create-an-order
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of currency you want to trade in units of base currency
         :param float [price]: the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the bl3p api endpoint
+         *
+         * EXCHANGE SPECIFIC PARAMETERS
+        :param int [params.amount_funds]: maximal EUR amount to spend(*1e5)
+        :param str [params.fee_currency]: 'EUR' or 'BTC'
         :returns dict: an `order structure <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
         """
         market = self.market(symbol)

ccxt/async_support/bybit.py

@@ -742,7 +742,7 @@ class bybit(Exchange, ImplicitAPI):
                     '110023': InvalidOrder,  # This contract only supports position reduction operation, please contact customer service for details
                     '110024': InvalidOrder,  # You have an existing position, so position mode cannot be switched
                     '110025': InvalidOrder,  # Position mode is not modified
-                    '110026': InvalidOrder,  # Cross/isolated margin mode is not modified
+                    '110026': BadRequest,  # Cross/isolated margin mode is not modified
                     '110027': InvalidOrder,  # Margin is not modified
                     '110028': InvalidOrder,  # Open orders exist, so you cannot change position mode
                     '110029': InvalidOrder,  # Hedge mode is not available for self symbol
@@ -2338,26 +2338,27 @@ class bybit(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit  # max 1000, default 1000
         request['interval'] = self.safe_string(self.timeframes, timeframe, timeframe)
-        method = None
+        response = None
         if market['spot']:
             request['category'] = 'spot'
-            method = 'publicGetV5MarketKline'
+            response = await self.publicGetV5MarketKline(self.extend(request, params))
         else:
             price = self.safe_string(params, 'price')
             params = self.omit(params, 'price')
-            methods = {
-                'mark': 'publicGetV5MarketMarkPriceKline',
-                'index': 'publicGetV5MarketIndexPriceKline',
-                'premiumIndex': 'publicGetV5MarketPremiumIndexPriceKline',
-            }
-            method = self.safe_value(methods, price, 'publicGetV5MarketKline')
             if market['linear']:
                 request['category'] = 'linear'
             elif market['inverse']:
                 request['category'] = 'inverse'
             else:
                 raise NotSupported(self.id + ' fetchOHLCV() is not supported for option markets')
-        response = await getattr(self, method)(self.extend(request, params))
+            if price == 'mark':
+                response = await self.publicGetV5MarketMarkPriceKline(self.extend(request, params))
+            elif price == 'index':
+                response = await self.publicGetV5MarketIndexPriceKline(self.extend(request, params))
+            elif price == 'premiumIndex':
+                response = await self.publicGetV5MarketPremiumIndexPriceKline(self.extend(request, params))
+            else:
+                response = await self.publicGetV5MarketKline(self.extend(request, params))
         #
         #     {
         #         "retCode": 0,
@@ -3459,6 +3460,7 @@ class bybit(Exchange, ImplicitAPI):
         :param boolean [params.isLeverage]: *unified spot only* False then spot trading True then margin trading
         :param str [params.tpslMode]: *contract only* 'full' or 'partial'
         :param str [params.mmp]: *option only* market maker protection
+        :param int [params.triggerDirection]: *contract only* conditional orders, 1: triggered when market price rises to triggerPrice, 2: triggered when market price falls to triggerPrice
         :returns dict: an `order structure <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
         """
         await self.load_markets()
@@ -3549,7 +3551,6 @@ class bybit(Exchange, ImplicitAPI):
         isBuy = side == 'buy'
         ascending = not isBuy if stopLossTriggerPrice else isBuy
         if triggerPrice is not None:
-            request['triggerDirection'] = 2 if ascending else 1
             request['triggerPrice'] = self.price_to_precision(symbol, triggerPrice)
         elif isStopLossTriggerOrder or isTakeProfitTriggerOrder:
             request['triggerDirection'] = 2 if ascending else 1
@@ -3558,11 +3559,11 @@ class bybit(Exchange, ImplicitAPI):
             request['reduceOnly'] = True
         elif isStopLoss or isTakeProfit:
             if isStopLoss:
-                stopLossTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
-                request['stopLoss'] = self.price_to_precision(symbol, stopLossTriggerPrice)
+                slTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
+                request['stopLoss'] = self.price_to_precision(symbol, slTriggerPrice)
             if isTakeProfit:
-                takeProfitTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
-                request['takeProfit'] = self.price_to_precision(symbol, takeProfitTriggerPrice)
+                tpTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
+                request['takeProfit'] = self.price_to_precision(symbol, tpTriggerPrice)
         if market['spot']:
             # only works for spot market
             if triggerPrice is not None:
@@ -3656,11 +3657,11 @@ class bybit(Exchange, ImplicitAPI):
                 request['basePrice'] = Precise.string_sub(preciseStopPrice, delta) if isStopLossTriggerOrder else Precise.string_add(preciseStopPrice, delta)
             elif isStopLoss or isTakeProfit:
                 if isStopLoss:
-                    stopLossTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
-                    request['stopLoss'] = self.price_to_precision(symbol, stopLossTriggerPrice)
+                    slTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
+                    request['stopLoss'] = self.price_to_precision(symbol, slTriggerPrice)
                 if isTakeProfit:
-                    takeProfitTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
-                    request['takeProfit'] = self.price_to_precision(symbol, takeProfitTriggerPrice)
+                    tpTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
+                    request['takeProfit'] = self.price_to_precision(symbol, tpTriggerPrice)
             else:
                 request['orderFilter'] = 'Order'
         clientOrderId = self.safe_string(params, 'clientOrderId')
@@ -3670,8 +3671,11 @@ class bybit(Exchange, ImplicitAPI):
             # mandatory field for options
             request['orderLinkId'] = self.uuid16()
         params = self.omit(params, ['stopPrice', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'postOnly', 'clientOrderId'])
-        method = 'privatePostOptionUsdcOpenapiPrivateV1PlaceOrder' if market['option'] else 'privatePostPerpetualUsdcOpenapiPrivateV1PlaceOrder'
-        response = await getattr(self, method)(self.extend(request, params))
+        response = None
+        if market['option']:
+            response = await self.privatePostOptionUsdcOpenapiPrivateV1PlaceOrder(self.extend(request, params))
+        else:
+            response = await self.privatePostPerpetualUsdcOpenapiPrivateV1PlaceOrder(self.extend(request, params))
         #
         #     {
         #         "retCode":0,
@@ -3711,11 +3715,10 @@ class bybit(Exchange, ImplicitAPI):
             request['orderQty'] = self.amount_to_precision(symbol, amount)
         if price is not None:
             request['orderPrice'] = self.price_to_precision(symbol, price)
-        method = None
+        response = None
         if market['option']:
-            method = 'privatePostOptionUsdcOpenapiPrivateV1ReplaceOrder'
+            response = await self.privatePostOptionUsdcOpenapiPrivateV1ReplaceOrder(self.extend(request, params))
         else:
-            method = 'privatePostPerpetualUsdcOpenapiPrivateV1ReplaceOrder'
             isStop = self.safe_value(params, 'stop', False)
             triggerPrice = self.safe_value_2(params, 'stopPrice', 'triggerPrice')
             stopLossPrice = self.safe_value(params, 'stopLossPrice')
@@ -3732,7 +3735,7 @@ class bybit(Exchange, ImplicitAPI):
                 if takeProfitPrice is not None:
                     request['takeProfit'] = self.price_to_precision(symbol, takeProfitPrice)
             params = self.omit(params, ['stop', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice'])
-        response = await getattr(self, method)(self.extend(request, params))
+            response = await self.privatePostPerpetualUsdcOpenapiPrivateV1ReplaceOrder(self.extend(request, params))
         #
         #    {
         #        "retCode": 0,
@@ -3812,11 +3815,11 @@ class bybit(Exchange, ImplicitAPI):
             request['triggerPrice'] = self.price_to_precision(symbol, triggerPrice)
         if isStopLoss or isTakeProfit:
             if isStopLoss:
-                stopLossTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
-                request['stopLoss'] = self.price_to_precision(symbol, stopLossTriggerPrice)
+                slTriggerPrice = self.safe_value_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
+                request['stopLoss'] = self.price_to_precision(symbol, slTriggerPrice)
             if isTakeProfit:
-                takeProfitTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
-                request['takeProfit'] = self.price_to_precision(symbol, takeProfitTriggerPrice)
+                tpTriggerPrice = self.safe_value_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
+                request['takeProfit'] = self.price_to_precision(symbol, tpTriggerPrice)
         clientOrderId = self.safe_string(params, 'clientOrderId')
         if clientOrderId is not None:
             request['orderLinkId'] = clientOrderId
@@ -3851,15 +3854,14 @@ class bybit(Exchange, ImplicitAPI):
         }
         isStop = self.safe_value(params, 'stop', False)
         params = self.omit(params, ['stop'])
-        method = None
         if id is not None:  # The user can also use argument params["order_link_id"]
             request['orderId'] = id
+        response = None
         if market['option']:
-            method = 'privatePostOptionUsdcOpenapiPrivateV1CancelOrder'
+            response = await self.privatePostOptionUsdcOpenapiPrivateV1CancelOrder(self.extend(request, params))
         else:
-            method = 'privatePostPerpetualUsdcOpenapiPrivateV1CancelOrder'
             request['orderFilter'] = 'StopOrder' if isStop else 'Order'
-        response = await getattr(self, method)(self.extend(request, params))
+            response = await self.privatePostPerpetualUsdcOpenapiPrivateV1CancelOrder(self.extend(request, params))
         #
         #     {
         #         "retCode": 0,
@@ -4937,13 +4939,16 @@ class bybit(Exchange, ImplicitAPI):
         else:
             if since is not None:
                 request['start_date'] = self.yyyymmdd(since)
-        method = 'privateGetV5AccountTransactionLog' if (enableUnified[1]) else 'privateGetV2PrivateWalletFundRecords'
         if code is not None:
             currency = self.currency(code)
             request[currencyKey] = currency['id']
         if limit is not None:
             request['limit'] = limit
-        response = await getattr(self, method)(self.extend(request, params))
+        response = None
+        if enableUnified[1]:
+            response = await self.privateGetV5AccountTransactionLog(self.extend(request, params))
+        else:
+            response = await self.privateGetV2PrivateWalletFundRecords(self.extend(request, params))
         #
         #     {
         #         "ret_code": 0,
@@ -5624,18 +5629,85 @@ class bybit(Exchange, ImplicitAPI):
         })
 
     async def set_margin_mode(self, marginMode, symbol: Optional[str] = None, params={}):
+        """
+        set margin mode(account) or trade mode(symbol)
+        see https://bybit-exchange.github.io/docs/v5/account/set-margin-mode
+        see https://bybit-exchange.github.io/docs/v5/position/cross-isolate
+        :param str marginMode: account mode must be either [isolated, cross, portfolio], trade mode must be either [isolated, cross]
+        :param str symbol: unified market symbol of the market the position is held in, default is None
+        :param dict [params]: extra parameters specific to the bybit api endpoint
+        :param str [params.leverage]: the rate of leverage, is required if setting trade mode(symbol)
+        :returns dict: response from the exchange
+        """
         await self.load_markets()
         enableUnifiedMargin, enableUnifiedAccount = await self.is_unified_enabled()
         isUnifiedAccount = (enableUnifiedMargin or enableUnifiedAccount)
-        if marginMode == 'ISOLATED_MARGIN':
-            if not isUnifiedAccount:
-                raise NotSupported(self.id + ' setMarginMode() Normal Account not support ISOLATED_MARGIN')
-        elif (marginMode != 'REGULAR_MARGIN') and (marginMode != 'PORTFOLIO_MARGIN'):
-            raise NotSupported(self.id + ' setMarginMode() marginMode must be either ISOLATED_MARGIN or REGULAR_MARGIN or PORTFOLIO_MARGIN')
-        request = {
-            'setMarginMode': marginMode,
-        }
-        response = await self.privatePostV5AccountSetMarginMode(self.extend(request, params))
+        market = None
+        response = None
+        if isUnifiedAccount:
+            if marginMode == 'isolated':
+                marginMode = 'ISOLATED_MARGIN'
+            elif marginMode == 'cross':
+                marginMode = 'REGULAR_MARGIN'
+            elif marginMode == 'portfolio':
+                marginMode = 'PORTFOLIO_MARGIN'
+            else:
+                raise NotSupported(self.id + ' setMarginMode() marginMode must be either [isolated, cross, portfolio]')
+            request = {
+                'setMarginMode': marginMode,
+            }
+            response = await self.privatePostV5AccountSetMarginMode(self.extend(request, params))
+        else:
+            if symbol is None:
+                raise ArgumentsRequired(self.id + ' setMarginMode() requires a symbol parameter for non unified account')
+            market = self.market(symbol)
+            isUsdcSettled = market['settle'] == 'USDC'
+            if isUsdcSettled:
+                if marginMode == 'cross':
+                    marginMode = 'REGULAR_MARGIN'
+                elif marginMode == 'portfolio':
+                    marginMode = 'PORTFOLIO_MARGIN'
+                else:
+                    raise NotSupported(self.id + ' setMarginMode() for usdc market marginMode must be either [cross, portfolio]')
+                request = {
+                    'setMarginMode': marginMode,
+                }
+                response = await self.privatePostV5AccountSetMarginMode(self.extend(request, params))
+            else:
+                type = None
+                type, params = self.get_bybit_type('setPositionMode', market, params)
+                tradeMode = None
+                if marginMode == 'cross':
+                    tradeMode = 0
+                elif marginMode == 'isolated':
+                    tradeMode = 1
+                else:
+                    raise NotSupported(self.id + ' setMarginMode() with symbol marginMode must be either [isolated, cross]')
+                sellLeverage = None
+                buyLeverage = None
+                leverage = self.safe_string(params, 'leverage')
+                if leverage is None:
+                    sellLeverage = self.safe_string_2(params, 'sell_leverage', 'sellLeverage')
+                    buyLeverage = self.safe_string_2(params, 'buy_leverage', 'buyLeverage')
+                    if sellLeverage is None and buyLeverage is None:
+                        raise ArgumentsRequired(self.id + ' setMarginMode() requires a leverage parameter or sell_leverage and buy_leverage parameters')
+                    if buyLeverage is None:
+                        buyLeverage = sellLeverage
+                    if sellLeverage is None:
+                        sellLeverage = buyLeverage
+                    params = self.omit(params, ['buy_leverage', 'sell_leverage', 'sellLeverage', 'buyLeverage'])
+                else:
+                    sellLeverage = leverage
+                    buyLeverage = leverage
+                    params = self.omit(params, 'leverage')
+                request = {
+                    'category': type,
+                    'symbol': market['id'],
+                    'tradeMode': tradeMode,
+                    'buyLeverage': buyLeverage,
+                    'sellLeverage': sellLeverage,
+                }
+                response = await self.privatePostV5PositionSwitchIsolated(self.extend(request, params))
         return response
 
     async def set_leverage(self, leverage, symbol: Optional[str] = None, params={}):
@@ -5665,21 +5737,21 @@ class bybit(Exchange, ImplicitAPI):
             'buyLeverage': leverage,
             'sellLeverage': leverage,
         }
-        method = None
+        response = None
         if isUsdcSettled and not isUnifiedAccount:
             request['leverage'] = leverage
-            method = 'privatePostPerpetualUsdcOpenapiPrivateV1PositionLeverageSave'
+            response = await self.privatePostPerpetualUsdcOpenapiPrivateV1PositionLeverageSave(self.extend(request, params))
         else:
             request['buyLeverage'] = leverage
             request['sellLeverage'] = leverage
-            method = 'privatePostV5PositionSetLeverage'
             if market['linear']:
                 request['category'] = 'linear'
             elif market['inverse']:
                 request['category'] = 'inverse'
             else:
                 raise NotSupported(self.id + ' setLeverage() only support linear and inverse market')
-        return await getattr(self, method)(self.extend(request, params))
+            response = await self.privatePostV5PositionSetLeverage(self.extend(request, params))
+        return response
 
     async def set_position_mode(self, hedged, symbol: Optional[str] = None, params={}):
         """

ccxt/async_support/coinbasepro.py

@@ -799,6 +799,17 @@ class coinbasepro(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit  # default 100
         response = await self.publicGetProductsIdTrades(self.extend(request, params))
+        #
+        #    [
+        #        {
+        #            "trade_id": "15035219",
+        #            "side": "sell",
+        #            "size": "0.27426731",
+        #            "price": "25820.42000000",
+        #            "time": "2023-09-10T13:47:41.447577Z"
+        #        },
+        #    ]
+        #
         return self.parse_trades(response, market, since, limit)
 
     async def fetch_trading_fees(self, params={}):

ccxt/async_support/currencycom.py

@@ -1054,7 +1054,7 @@ class currencycom(Exchange, ImplicitAPI):
             # 'limit': 500,  # default 500, max 1000
         }
         if limit is not None:
-            request['limit'] = limit  # default 500, max 1000
+            request['limit'] = min(limit, 1000)  # default 500, max 1000
         if since is not None:
             request['startTime'] = since
         response = await self.publicGetV2AggTrades(self.extend(request, params))

ccxt/async_support/gemini.py

@@ -238,6 +238,7 @@ class gemini(Exchange, ImplicitAPI):
                     'InsufficientFunds': InsufficientFunds,  # The order was rejected because of insufficient funds
                     'InvalidJson': BadRequest,  # The JSON provided is invalid
                     'InvalidNonce': InvalidNonce,  # The nonce was not greater than the previously used nonce, or was not present
+                    'InvalidApiKey': AuthenticationError,  # Invalid API key
                     'InvalidOrderType': InvalidOrder,  # An unknown order type was provided
                     'InvalidPrice': InvalidOrder,  # For new orders, the price was invalid
                     'InvalidQuantity': InvalidOrder,  # A negative or otherwise invalid quantity was specified

ccxt/async_support/huobi.py

@@ -2446,7 +2446,7 @@ class huobi(Exchange, ImplicitAPI):
             fieldName = 'contract_code'
         request[fieldName] = market['id']
         if limit is not None:
-            request['size'] = limit  # max 2000
+            request['size'] = min(limit, 2000)  # max 2000
         response = await getattr(self, method)(self.extend(request, params))
         #
         #     {

ccxt/async_support/huobijp.py

@@ -850,7 +850,7 @@ class huobijp(Exchange, ImplicitAPI):
             'symbol': market['id'],
         }
         if limit is not None:
-            request['size'] = limit
+            request['size'] = min(limit, 2000)
         response = await self.marketGetHistoryTrade(self.extend(request, params))
         #
         #     {

ccxt/async_support/idex.py

@@ -504,7 +504,7 @@ class idex(Exchange, ImplicitAPI):
         if since is not None:
             request['start'] = since
         if limit is not None:
-            request['limit'] = limit
+            request['limit'] = min(limit, 1000)
         # [
         #   {
         #     fillId: 'b5467d00-b13e-3fa9-8216-dd66735550fc',