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

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/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.0.101'
+__version__ = '4.0.102'
 
 # -----------------------------------------------------------------------------
 

ccxt/binance.py

@@ -425,6 +425,7 @@ class binance(Exchange, ImplicitAPI):
                         'portfolio/interest-history': 0.6667,
                         'portfolio/asset-index-price': 0.1,
                         'portfolio/repay-futures-switch': 3,  # Weight(IP): 30 => cost = 0.1 * 30 = 3
+                        'portfolio/margin-asset-leverage': 5,  # Weight(IP): 50 => cost = 0.1 * 50 = 5
                         # staking
                         'staking/productList': 0.1,
                         'staking/position': 0.1,
@@ -437,6 +438,11 @@ class binance(Exchange, ImplicitAPI):
                         'lending/auto-invest/plan/list': 0.1,
                         'lending/auto-invest/plan/id': 0.1,
                         'lending/auto-invest/history/list': 0.1,
+                        'lending/auto-invest/index/info': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/index/user-summary': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/one-off/status': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/redeem/history': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/rebalance/history': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
                         # simple earn
                         'simple-earn/flexible/list': 15,
                         'simple-earn/locked/list': 15,
@@ -564,6 +570,8 @@ class binance(Exchange, ImplicitAPI):
                         'lending/auto-invest/plan/add': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
                         'lending/auto-invest/plan/edit': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
                         'lending/auto-invest/plan/edit-status': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/one-off': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
+                        'lending/auto-invest/redeem': 0.1,  # Weight(IP): 1 => cost = 0.1 * 1 = 0.1
                         # simple earn
                         'simple-earn/flexible/subscribe': 0.1,
                         'simple-earn/locked/subscribe': 0.1,

ccxt/bingx.py

@@ -153,6 +153,7 @@ class bingx(Exchange, ImplicitAPI):
                                 'quote/klines': 1,
                                 'quote/openInterest': 1,
                                 'quote/ticker': 1,
+                                'quote/bookTicker': 1,
                             },
                         },
                         'private': {
@@ -204,11 +205,17 @@ class bingx(Exchange, ImplicitAPI):
                         'private': {
                             'get': {
                                 'capital/config/getall': 3,
+                                'capital/deposit/address': 1,
+                                'capital/innerTransfer/records': 1,
+                                'capital/subAccount/deposit/address': 1,
+                                'capital/deposit/subHisrec': 1,
+                                'capital/subAccount/innerTransfer/records': 1,
                             },
                             'post': {
                                 'capital/withdraw/apply': 3,
                                 'capital/innerTransfer/apply': 3,
                                 'capital/subAccountInnerTransfer/apply': 3,
+                                'capital/deposit/createSubAddress': 1,
                             },
                         },
                     },
@@ -219,6 +226,7 @@ class bingx(Exchange, ImplicitAPI):
                             'get': {
                                 'list': 3,
                                 'assets': 3,
+                                'apiKey/query': 1,
                             },
                             'post': {
                                 'create': 3,
@@ -233,13 +241,42 @@ class bingx(Exchange, ImplicitAPI):
                 'account': {
                     'v1': {
                         'private': {
+                            'get': {
+                                'uid': 1,
+                            },
                             'post': {
-                                'uid': 3,
                                 'innerTransfer/authorizeSubAccount': 3,
                             },
                         },
                     },
                 },
+                'copyTrading': {
+                    'v1': {
+                        'private': {
+                            'get': {
+                                'swap/trace/currentTrack': 1,
+                            },
+                            'post': {
+                                'swap/trace/closeTrackOrder': 1,
+                                'swap/trace/setTPSL': 1,
+                            },
+                        },
+                    },
+                },
+                'api': {
+                    'v3': {
+                        'private': {
+                            'get': {
+                                'asset/transfer': 1,
+                                'capital/deposit/hisrec': 1,
+                                'capital/withdraw/history': 1,
+                            },
+                            'post': {
+                                'post/asset/transfer': 1,
+                            },
+                        },
+                    },
+                },
             },
             'timeframes': {
                 '1m': '1m',
@@ -1437,9 +1474,9 @@ class bingx(Exchange, ImplicitAPI):
         :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 bingx api endpoint
         :param bool [params.postOnly]: True to place a post only order
-        :param dict [params.triggerPrice]: triggerPrice at which the attached take profit / stop loss order will be triggered(swap markets only)
-        :param float [params.stopLossPrice]: stop loss trigger price(swap markets only)
-        :param float [params.takeProfitPrice]: take profit trigger price(swap markets only)
+        :param float [params.triggerPrice]: *swap only* triggerPrice at which the attached take profit / stop loss order will be triggered
+        :param float [params.stopLossPrice]: *swap only* stop loss trigger price
+        :param float [params.takeProfitPrice]: *swap only* take profit trigger price
         :returns dict: an `order structure <https://github.com/ccxt/ccxt/wiki/Manual#order-structure>`
         """
         self.load_markets()

ccxt/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 self.privatePostContractPrivateSubmitLeverage(self.extend(request, params))
 
+    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>`
+        """
+        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 = 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/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,
@@ -353,12 +356,17 @@ class bl3p(Exchange, ImplicitAPI):
     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/bybit.py

@@ -3558,11 +3558,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 +3656,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')
@@ -3814,11 +3814,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
@@ -5641,11 +5641,10 @@ class bybit(Exchange, ImplicitAPI):
         self.load_markets()
         enableUnifiedMargin, enableUnifiedAccount = self.is_unified_enabled()
         isUnifiedAccount = (enableUnifiedMargin or enableUnifiedAccount)
+        market = None
         response = None
-        if symbol is None:
+        if isUnifiedAccount:
             if marginMode == 'isolated':
-                if not isUnifiedAccount:
-                    raise NotSupported(self.id + ' setMarginMode() Normal Account not support ISOLATED_MARGIN')
                 marginMode = 'ISOLATED_MARGIN'
             elif marginMode == 'cross':
                 marginMode = 'REGULAR_MARGIN'
@@ -5658,36 +5657,56 @@ class bybit(Exchange, ImplicitAPI):
             }
             response = 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)
-            type = None
-            type, params = self.get_bybit_type('setMarginMode', market, params)
-            if type == 'linear':
-                if isUnifiedAccount:
-                    raise NotSupported(self.id + ' setMarginMode() with symbol Unified Account only support inverse contract')
-                isUsdtSettled = market['settle'] == 'USDT'
-                if not isUsdtSettled:
-                    raise NotSupported(self.id + ' setMarginMode() with symbol only support USDT perpetual / inverse contract')
-            elif type != 'inverse':
-                raise NotSupported(self.id + ' setMarginMode() does not support self market type')
-            tradeMode = None
-            if marginMode == 'cross':
-                tradeMode = 0
-            elif marginMode == 'isolated':
-                tradeMode = 1
+            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 = self.privatePostV5AccountSetMarginMode(self.extend(request, params))
             else:
-                raise NotSupported(self.id + ' setMarginMode() with symbol marginMode must be either [isolated, cross]')
-            leverage = self.safe_string(params, 'leverage')
-            params = self.omit(params, ['leverage'])
-            if leverage is None:
-                raise ArgumentsRequired(self.id + ' setMarginMode() with symbol requires leverage')
-            request = {
-                'category': type,
-                'symbol': market['id'],
-                'tradeMode': tradeMode,
-                'buyLeverage': leverage,
-                'sellLeverage': leverage,
-            }
-            response = self.privatePostV5PositionSwitchIsolated(self.extend(request, params))
+                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 = self.privatePostV5PositionSwitchIsolated(self.extend(request, params))
         return response
 
     def set_leverage(self, leverage, symbol: Optional[str] = None, params={}):

ccxt/gemini.py

@@ -237,6 +237,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/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.0.101'
+__version__ = '4.0.102'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -466,8 +466,8 @@ class binance(ccxt.async_support.binance):
         for i in range(0, len(symbols)):
             symbol = symbols[i]
             market = self.market(symbol)
-            messageHash = market['lowercaseId'] + '@' + name
-            subParams.append(messageHash)
+            currentMessageHash = market['lowercaseId'] + '@' + name
+            subParams.append(currentMessageHash)
         messageHash = 'multipleTrades::' + ','.join(symbols)
         query = self.omit(params, 'type')
         url = self.urls['api']['ws'][type] + '/' + self.stream(type, messageHash)
@@ -763,17 +763,17 @@ class binance(ccxt.async_support.binance):
         hashes = []
         for i in range(0, len(symbolsAndTimeframes)):
             data = symbolsAndTimeframes[i]
-            symbol = data[0]
-            timeframe = data[1]
-            interval = self.safe_string(self.timeframes, timeframe, timeframe)
-            market = self.market(symbol)
+            symbolString = data[0]
+            timeframeString = data[1]
+            interval = self.safe_string(self.timeframes, timeframeString, timeframeString)
+            market = self.market(symbolString)
             marketId = market['lowercaseId']
             if name == 'indexPriceKline':
                 # weird behavior for index price kline we can't use the perp suffix
                 marketId = marketId.replace('_perp', '')
             topic = marketId + '@' + name + '_' + interval
             subParams.append(topic)
-            hashes.append(symbol + '#' + timeframe)
+            hashes.append(symbolString + '#' + timeframeString)
         messageHash = 'multipleOHLCV::' + ','.join(hashes)
         url = self.urls['api']['ws'][type] + '/' + self.stream(type, messageHash)
         requestId = self.request_id(url)

ccxt/pro/bybit.py

@@ -353,16 +353,16 @@ class bybit(ccxt.async_support.bybit):
         firstSymbol = None
         for i in range(0, len(symbolsAndTimeframes)):
             data = symbolsAndTimeframes[i]
-            symbol = self.safe_string(data, 0)
-            timeframe = self.safe_string(data, 1)
-            market = self.market(symbol)
-            symbol = market['symbol']
+            symbolString = self.safe_string(data, 0)
+            timeframeString = self.safe_string(data, 1)
+            market = self.market(symbolString)
+            symbolString = market['symbol']
             if i == 0:
                 firstSymbol = market['symbol']
-            timeframeId = self.safe_string(self.timeframes, timeframe, timeframe)
+            timeframeId = self.safe_string(self.timeframes, timeframeString, timeframeString)
             topic = 'kline.' + timeframeId + '.' + market['id']
             topics.append(topic)
-            hashes.append(symbol + '#' + timeframe)
+            hashes.append(symbolString + '#' + timeframeString)
         messageHash = 'multipleOHLCV::' + ','.join(hashes)
         url = self.get_url_by_market_type(firstSymbol, False, params)
         symbol, timeframe, stored = await self.watch_topics(url, messageHash, topics, params)
@@ -861,8 +861,8 @@ class bybit(ccxt.async_support.bybit):
             trades.append(parsed)
         keys = list(symbols.keys())
         for i in range(0, len(keys)):
-            messageHash = 'myTrades:' + keys[i]
-            client.resolve(trades, messageHash)
+            currentMessageHash = 'myTrades:' + keys[i]
+            client.resolve(trades, currentMessageHash)
         # non-symbol specific
         messageHash = 'myTrades'
         client.resolve(trades, messageHash)
@@ -988,22 +988,22 @@ class bybit(ccxt.async_support.bybit):
         first = self.safe_value(rawOrders, 0, {})
         category = self.safe_string(first, 'category')
         isSpot = category == 'spot'
-        parser = None
-        if isSpot:
-            parser = 'parseWsSpotOrder'
-        else:
-            parser = 'parseContractOrder'
+        if not isSpot:
             rawOrders = self.safe_value(rawOrders, 'result', rawOrders)
         symbols = {}
         for i in range(0, len(rawOrders)):
-            parsed = getattr(self, parser)(rawOrders[i])
+            parsed = None
+            if isSpot:
+                parsed = self.parse_ws_spot_order(rawOrders[i])
+            else:
+                parsed = self.parse_order(rawOrders[i])
             symbol = parsed['symbol']
             symbols[symbol] = True
             orders.append(parsed)
         symbolsArray = list(symbols.keys())
         for i in range(0, len(symbolsArray)):
-            messageHash = 'orders:' + symbolsArray[i]
-            client.resolve(orders, messageHash)
+            currentMessageHash = 'orders:' + symbolsArray[i]
+            client.resolve(orders, currentMessageHash)
         messageHash = 'orders'
         client.resolve(orders, messageHash)
 

ccxt/pro/coinbasepro.py

@@ -496,11 +496,11 @@ class coinbasepro(ccxt.async_support.coinbasepro):
         #         reason: 'filled'
         #     }
         #
-        orders = self.orders
-        if orders is None:
+        currentOrders = self.orders
+        if currentOrders is None:
             limit = self.safe_integer(self.options, 'ordersLimit', 1000)
-            orders = ArrayCacheBySymbolById(limit)
-            self.orders = orders
+            currentOrders = ArrayCacheBySymbolById(limit)
+            self.orders = currentOrders
         type = self.safe_string(message, 'type')
         marketId = self.safe_string(message, 'product_id')
         if marketId is not None:
@@ -533,9 +533,9 @@ class coinbasepro(ccxt.async_support.coinbasepro):
                         totalAmount = 0
                         trades = previousOrder['trades']
                         for i in range(0, len(trades)):
-                            trade = trades[i]
-                            totalCost = self.sum(totalCost, trade['cost'])
-                            totalAmount = self.sum(totalAmount, trade['amount'])
+                            tradeEntry = trades[i]
+                            totalCost = self.sum(totalCost, tradeEntry['cost'])
+                            totalAmount = self.sum(totalAmount, tradeEntry['amount'])
                         if totalAmount > 0:
                             previousOrder['average'] = totalCost / totalAmount
                         previousOrder['cost'] = totalCost
@@ -646,12 +646,12 @@ class coinbasepro(ccxt.async_support.coinbasepro):
             client.resolve(ticker, messageHash)
             messageHashes = self.find_message_hashes(client, 'tickers::')
             for i in range(0, len(messageHashes)):
-                messageHash = messageHashes[i]
-                parts = messageHash.split('::')
+                currentMessageHash = messageHashes[i]
+                parts = currentMessageHash.split('::')
                 symbolsString = parts[1]
                 symbols = symbolsString.split(',')
                 if self.in_array(symbol, symbols):
-                    client.resolve(ticker, messageHash)
+                    client.resolve(ticker, currentMessageHash)
         return message
 
     def parse_ticker(self, ticker, market=None):

ccxt/pro/kucoin.py

@@ -229,15 +229,15 @@ class kucoin(ccxt.async_support.kucoin):
         client.resolve(ticker, 'tickers')
         messageHashes = self.find_message_hashes(client, 'tickers::')
         for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
+            currentMessageHash = messageHashes[i]
+            parts = currentMessageHash.split('::')
             symbolsString = parts[1]
             symbols = symbolsString.split(',')
             tickers = self.filter_by_array(self.tickers, 'symbol', symbols)
             tickersSymbols = list(tickers.keys())
             numTickers = len(tickersSymbols)
             if numTickers > 0:
-                client.resolve(tickers, messageHash)
+                client.resolve(tickers, currentMessageHash)
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """

ccxt/test/test_async.py

@@ -695,7 +695,7 @@ class testMainClass(baseMainTestClass):
                 dump(self.add_padding('[INFO:PRIVATE_TESTS_DONE]', 25), exchange.id)
 
     async def start_test(self, exchange, symbol):
-        # we don't need to test aliases
+        # we do not need to test aliases
         if exchange.alias:
             return
         if self.sandbox or get_exchange_prop(exchange, 'sandbox'):

ccxt/test/test_sync.py

@@ -694,7 +694,7 @@ class testMainClass(baseMainTestClass):
                 dump(self.add_padding('[INFO:PRIVATE_TESTS_DONE]', 25), exchange.id)
 
     def start_test(self, exchange, symbol):
-        # we don't need to test aliases
+        # we do not need to test aliases
         if exchange.alias:
             return
         if self.sandbox or get_exchange_prop(exchange, 'sandbox'):