ccxt 4.2.30__py2.py3-none-any.whl → 4.2.34__py2.py3-none-any.whl

ccxt/phemex.py

@@ -7,7 +7,7 @@ from ccxt.base.exchange import Exchange
 from ccxt.abstract.phemex import ImplicitAPI
 import hashlib
 import numbers
-from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, Num, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, TransferEntry, OrderBook, OrderSide, OrderType, Num, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -1123,7 +1123,7 @@ class phemex(Exchange, ImplicitAPI):
         return orderbook
 
     def to_en(self, n, scale):
-        stringN = str(n)
+        stringN = self.number_to_string(n)
         precise = Precise(stringN)
         precise.decimals = precise.decimals - scale
         precise.reduce()
@@ -2341,7 +2341,7 @@ class phemex(Exchange, ImplicitAPI):
             return self.parse_swap_order(order, market)
         return self.parse_spot_order(order, market)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#place-order
@@ -2427,10 +2427,10 @@ class phemex(Exchange, ImplicitAPI):
                     elif cost is None:
                         raise ArgumentsRequired(self.id + ' createOrder() ' + qtyType + ' requires a price argument or a cost parameter')
                 cost = amount if (cost is None) else cost
-                costString = str(cost)
+                costString = self.number_to_string(cost)
                 request['quoteQtyEv'] = self.to_ev(costString, market)
             else:
-                amountString = str(amount)
+                amountString = self.number_to_string(amount)
                 request['baseQtyEv'] = self.to_ev(amountString, market)
         elif market['swap']:
             posSide = self.safe_string_lower(params, 'posSide')
@@ -2443,7 +2443,7 @@ class phemex(Exchange, ImplicitAPI):
             if market['settle'] == 'USDT':
                 request['orderQtyRq'] = amount
             else:
-                request['orderQty'] = int(amount)
+                request['orderQty'] = self.parse_to_int(amount)
             if stopPrice is not None:
                 triggerType = self.safe_string(params, 'triggerType', 'ByMarkPrice')
                 request['triggerType'] = triggerType
@@ -4013,7 +4013,7 @@ class phemex(Exchange, ImplicitAPI):
         url = self.implode_hostname(self.urls['api'][api]) + url
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
-    def set_leverage(self, leverage, symbol: Str = None, params={}):
+    def set_leverage(self, leverage: Int, symbol: Str = None, params={}):
         """
         set the level of leverage for a market
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#set-leverage
@@ -4044,17 +4044,17 @@ class phemex(Exchange, ImplicitAPI):
             if not isHedged and longLeverageRr is None and shortLeverageRr is None:
                 request['leverageRr'] = leverage
             else:
-                long = longLeverageRr if (longLeverageRr is not None) else leverage
-                short = shortLeverageRr if (shortLeverageRr is not None) else leverage
-                request['longLeverageRr'] = long
-                request['shortLeverageRr'] = short
+                longVar = longLeverageRr if (longLeverageRr is not None) else leverage
+                shortVar = shortLeverageRr if (shortLeverageRr is not None) else leverage
+                request['longLeverageRr'] = longVar
+                request['shortLeverageRr'] = shortVar
             response = self.privatePutGPositionsLeverage(self.extend(request, params))
         else:
             request['leverage'] = leverage
             response = self.privatePutPositionsLeverage(self.extend(request, params))
         return response
 
-    def transfer(self, code: str, amount, fromAccount, toAccount, params={}):
+    def transfer(self, code: str, amount: float, fromAccount, toAccount, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
         :param str code: unified currency code
@@ -4311,7 +4311,7 @@ class phemex(Exchange, ImplicitAPI):
         sorted = self.sort_by(result, 'timestamp')
         return self.filter_by_symbol_since_limit(sorted, symbol, since, limit)
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         make a withdrawal
         :see: https://phemex-docs.github.io/#create-withdraw-request

ccxt/poloniex.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.poloniex import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, TransferEntry, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -1212,7 +1212,7 @@ class poloniex(Exchange, ImplicitAPI):
         extension = {'status': 'open'}
         return self.parse_orders(response, market, since, limit, extension)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         create a trade order
         :see: https://docs.poloniex.com/#authenticated-endpoints-orders-create-order
@@ -1736,7 +1736,7 @@ class poloniex(Exchange, ImplicitAPI):
             'info': response,
         }
 
-    def transfer(self, code: str, amount, fromAccount, toAccount, params={}):
+    def transfer(self, code: str, amount: float, fromAccount, toAccount, params={}) -> TransferEntry:
         """
         transfer currency internally between wallets on the same account
         :see: https://docs.poloniex.com/#authenticated-endpoints-accounts-accounts-transfer
@@ -1785,7 +1785,7 @@ class poloniex(Exchange, ImplicitAPI):
             'status': None,
         }
 
-    def withdraw(self, code: str, amount, address, tag=None, params={}):
+    def withdraw(self, code: str, amount: float, address, tag=None, params={}):
         """
         make a withdrawal
         :see: https://docs.poloniex.com/#authenticated-endpoints-wallets-withdraw-currency

ccxt/poloniexfutures.py

@@ -45,6 +45,9 @@ class poloniexfutures(Exchange, ImplicitAPI):
                 'fetchBalance': True,
                 'fetchClosedOrders': True,
                 'fetchCurrencies': False,
+                'fetchDepositAddress': False,
+                'fetchDepositAddresses': False,
+                'fetchDepositAddressesByNetwork': False,
                 'fetchFundingRate': True,
                 'fetchFundingRateHistory': False,
                 'fetchL3OrderBook': True,
@@ -777,7 +780,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
         #
         return self.parse_balance(response)
 
-    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}):
+    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}):
         """
         Create an order on the exchange
         :see: https://futures-docs.poloniex.com/#place-an-order

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.30'
+__version__ = '4.2.34'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/alpaca.py

@@ -591,11 +591,14 @@ class alpaca(ccxt.async_support.alpaca):
             T = self.safe_string(data, 'T')
             msg = self.safe_value(data, 'msg', {})
             if T == 'subscription':
-                return self.handle_subscription(client, data)
+                self.handle_subscription(client, data)
+                return
             if T == 'success' and msg == 'connected':
-                return self.handle_connected(client, data)
+                self.handle_connected(client, data)
+                return
             if T == 'success' and msg == 'authenticated':
-                return self.handle_authenticate(client, data)
+                self.handle_authenticate(client, data)
+                return
             methods = {
                 'error': self.handle_error_message,
                 'b': self.handle_ohlcv,
@@ -620,7 +623,8 @@ class alpaca(ccxt.async_support.alpaca):
 
     def handle_message(self, client: Client, message):
         if isinstance(message, list):
-            return self.handle_crypto_message(client, message)
+            self.handle_crypto_message(client, message)
+            return
         self.handle_trading_message(client, message)
 
     def handle_authenticate(self, client: Client, message):

ccxt/pro/ascendex.py

@@ -843,7 +843,6 @@ class ascendex(ccxt.async_support.ascendex):
             self.handle_order(client, message)
             if subject == 'order':
                 self.handle_balance(client, message)
-        return message
 
     def handle_subscription_status(self, client: Client, message):
         #
@@ -879,7 +878,7 @@ class ascendex(ccxt.async_support.ascendex):
     def handle_ping(self, client: Client, message):
         self.spawn(self.pong, client, message)
 
-    def authenticate(self, url, params={}):
+    async def authenticate(self, url, params={}):
         self.check_required_credentials()
         messageHash = 'authenticated'
         client = self.client(url)

ccxt/pro/binance.py

@@ -491,7 +491,7 @@ class binance(ccxt.async_support.binance):
         """
         return await self.watch_trades_for_symbols([symbol], since, limit, params)
 
-    def parse_trade(self, trade, market=None) -> Trade:
+    def parse_ws_trade(self, trade, market=None) -> Trade:
         #
         # public watchTrades
         #
@@ -599,7 +599,7 @@ class binance(ccxt.async_support.binance):
         executionType = self.safe_string(trade, 'x')
         isTradeExecution = (executionType == 'TRADE')
         if not isTradeExecution:
-            return super(binance, self).parse_trade(trade, market)
+            return self.parse_trade(trade, market)
         id = self.safe_string_2(trade, 't', 'a')
         timestamp = self.safe_integer(trade, 'T')
         price = self.safe_string_2(trade, 'L', 'p')
@@ -657,7 +657,7 @@ class binance(ccxt.async_support.binance):
         lowerCaseId = self.safe_string_lower(message, 's')
         event = self.safe_string(message, 'e')
         messageHash = lowerCaseId + '@' + event
-        trade = self.parse_trade(message, market)
+        trade = self.parse_ws_trade(message, market)
         tradesArray = self.safe_value(self.trades, symbol)
         if tradesArray is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
@@ -1146,11 +1146,12 @@ class binance(ccxt.async_support.binance):
             for j in range(0, len(subscriptionKeys)):
                 subscribeType = subscriptionKeys[j]
                 if subscribeType == type:
-                    return self.delay(listenKeyRefreshRate, self.keep_alive_listen_key, params)
+                    self.delay(listenKeyRefreshRate, self.keep_alive_listen_key, params)
+                    return
 
     def set_balance_cache(self, client: Client, type):
         if type in client.subscriptions:
-            return None
+            return
         options = self.safe_value(self.options, 'watchBalance')
         fetchBalanceSnapshot = self.safe_bool(options, 'fetchBalanceSnapshot', False)
         if fetchBalanceSnapshot:
@@ -1245,7 +1246,7 @@ class binance(ccxt.async_support.binance):
         #
         messageHash = self.safe_string(message, 'id')
         result = self.safe_value(message, 'result', {})
-        parsedBalances = self.parse_balance(result, 'spot')
+        parsedBalances = self.parse_balance(result)
         client.resolve(parsedBalances, messageHash)
 
     async def watch_balance(self, params={}) -> Balances:
@@ -2501,12 +2502,14 @@ class binance(ccxt.async_support.binance):
         status = self.safe_string(message, 'status')
         error = self.safe_value(message, 'error')
         if (error is not None) or (status is not None and status != '200'):
-            return self.handle_ws_error(client, message)
+            self.handle_ws_error(client, message)
+            return
         id = self.safe_string(message, 'id')
         subscriptions = self.safe_value(client.subscriptions, id)
         method = self.safe_value(subscriptions, 'method')
         if method is not None:
-            return method(client, message)
+            method(client, message)
+            return
         # handle other APIs
         methods = {
             'depthUpdate': self.handle_order_book,
@@ -2534,7 +2537,8 @@ class binance(ccxt.async_support.binance):
         if method is None:
             requestId = self.safe_string(message, 'id')
             if requestId is not None:
-                return self.handle_subscription_status(client, message)
+                self.handle_subscription_status(client, message)
+                return
             # special case for the real-time bookTicker, since it comes without an event identifier
             #
             #     {
@@ -2550,4 +2554,4 @@ class binance(ccxt.async_support.binance):
                 self.handle_ticker(client, message)
                 self.handle_tickers(client, message)
         else:
-            return method(client, message)
+            method(client, message)

ccxt/pro/bingx.py

@@ -675,7 +675,7 @@ class bingx(ccxt.async_support.bingx):
 
     def set_balance_cache(self, client: Client, type, subscriptionHash, params):
         if subscriptionHash in client.subscriptions:
-            return None
+            return
         fetchBalanceSnapshot = self.handle_option_and_params(params, 'watchBalance', 'fetchBalanceSnapshot', True)
         if fetchBalanceSnapshot:
             messageHash = type + ':fetchBalanceSnapshot'

ccxt/pro/bitfinex.py

@@ -129,7 +129,6 @@ class bitfinex(ccxt.async_support.bitfinex):
             trade = self.parse_trade(message, market)
             stored.append(trade)
         client.resolve(stored, messageHash)
-        return message
 
     def parse_trade(self, trade, market=None) -> Trade:
         #
@@ -308,35 +307,39 @@ class bitfinex(ccxt.async_support.bitfinex):
                     delta = deltas[i]
                     id = self.safe_string(delta, 0)
                     price = self.safe_float(delta, 1)
-                    size = -delta[2] if (delta[2] < 0) else delta[2]
-                    side = 'asks' if (delta[2] < 0) else 'bids'
+                    delta2Value = delta[2]
+                    size = -delta2Value if (delta2Value < 0) else delta2Value
+                    side = 'asks' if (delta2Value < 0) else 'bids'
                     bookside = orderbook[side]
                     bookside.store(price, size, id)
             else:
                 deltas = message[1]
                 for i in range(0, len(deltas)):
                     delta = deltas[i]
-                    size = -delta[2] if (delta[2] < 0) else delta[2]
-                    side = 'asks' if (delta[2] < 0) else 'bids'
-                    bookside = orderbook[side]
-                    bookside.store(delta[0], size, delta[1])
+                    delta2 = delta[2]
+                    size = -delta2 if (delta2 < 0) else delta2
+                    side = 'asks' if (delta2 < 0) else 'bids'
+                    countedBookSide = orderbook[side]
+                    countedBookSide.store(delta[0], size, delta[1])
             client.resolve(orderbook, messageHash)
         else:
             orderbook = self.orderbooks[symbol]
             if isRaw:
                 id = self.safe_string(message, 1)
                 price = self.safe_string(message, 2)
-                size = -message[3] if (message[3] < 0) else message[3]
-                side = 'asks' if (message[3] < 0) else 'bids'
+                message3 = message[3]
+                size = -message3 if (message3 < 0) else message3
+                side = 'asks' if (message3 < 0) else 'bids'
                 bookside = orderbook[side]
                 # price = 0 means that you have to remove the order from your book
                 amount = size if Precise.string_gt(price, '0') else '0'
                 bookside.store(self.parse_number(price), self.parse_number(amount), id)
             else:
-                size = -message[3] if (message[3] < 0) else message[3]
-                side = 'asks' if (message[3] < 0) else 'bids'
-                bookside = orderbook[side]
-                bookside.store(message[1], size, message[2])
+                message3Value = message[3]
+                size = -message3Value if (message3Value < 0) else message3Value
+                side = 'asks' if (message3Value < 0) else 'bids'
+                countedBookSide = orderbook[side]
+                countedBookSide.store(message[1], size, message[2])
             client.resolve(orderbook, messageHash)
 
     def handle_heartbeat(self, client: Client, message):
@@ -579,7 +582,7 @@ class bitfinex(ccxt.async_support.bitfinex):
             #     ]
             #
             if message[1] == 'hb':
-                return message  # skip heartbeats within subscription channels for now
+                return  # skip heartbeats within subscription channels for now
             subscription = self.safe_value(client.subscriptions, channelId, {})
             channel = self.safe_string(subscription, 'channel')
             name = self.safe_string(message, 1)
@@ -593,10 +596,8 @@ class bitfinex(ccxt.async_support.bitfinex):
                 'oc': self.handle_orders,
             }
             method = self.safe_value_2(methods, channel, name)
-            if method is None:
-                return message
-            else:
-                return method(client, message, subscription)
+            if method is not None:
+                method(client, message, subscription)
         else:
             # todo add bitfinex handleErrorMessage
             #
@@ -616,7 +617,5 @@ class bitfinex(ccxt.async_support.bitfinex):
                     'auth': self.handle_authentication_message,
                 }
                 method = self.safe_value(methods, event)
-                if method is None:
-                    return message
-                else:
-                    return method(client, message)
+                if method is not None:
+                    method(client, message)

ccxt/pro/bitfinex2.py

@@ -324,7 +324,6 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             parsed = self.parse_ws_trade(trade, market)
             stored.append(parsed)
         client.resolve(stored, messageHash)
-        return message
 
     def parse_ws_trade(self, trade, market=None):
         #
@@ -563,8 +562,9 @@ class bitfinex2(ccxt.async_support.bitfinex2):
                 deltas = message[1]
                 for i in range(0, len(deltas)):
                     delta = deltas[i]
-                    size = -delta[2] if (delta[2] < 0) else delta[2]
-                    side = 'asks' if (delta[2] < 0) else 'bids'
+                    delta2 = delta[2]
+                    size = -delta2 if (delta2 < 0) else delta2
+                    side = 'asks' if (delta2 < 0) else 'bids'
                     bookside = orderbook[side]
                     idString = self.safe_string(delta, 0)
                     price = self.safe_float(delta, 1)
@@ -587,8 +587,9 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             orderbookItem = self.orderbooks[symbol]
             if isRaw:
                 price = self.safe_string(deltas, 1)
-                size = -deltas[2] if (deltas[2] < 0) else deltas[2]
-                side = 'asks' if (deltas[2] < 0) else 'bids'
+                deltas2 = deltas[2]
+                size = -deltas2 if (deltas2 < 0) else deltas2
+                side = 'asks' if (deltas2 < 0) else 'bids'
                 bookside = orderbookItem[side]
                 # price = 0 means that you have to remove the order from your book
                 amount = size if Precise.string_gt(price, '0') else '0'
@@ -631,7 +632,8 @@ class bitfinex2(ccxt.async_support.bitfinex2):
                 stringArray.append(self.number_to_string(bids[i][1]))
             if ask is not None:
                 stringArray.append(self.number_to_string(asks[i][idToCheck]))
-                stringArray.append(self.number_to_string(-asks[i][1]))
+                aski1 = asks[i][1]
+                stringArray.append(self.number_to_string(-aski1))
         payload = ':'.join(stringArray)
         localChecksum = self.crc32(payload, True)
         responseChecksum = self.safe_integer(message, 2)
@@ -1036,7 +1038,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
         #
         if isinstance(message, list):
             if message[1] == 'hb':
-                return message  # skip heartbeats within subscription channels for now
+                return  # skip heartbeats within subscription channels for now
             subscription = self.safe_value(client.subscriptions, channelId, {})
             channel = self.safe_string(subscription, 'channel')
             name = self.safe_string(message, 1)
@@ -1061,10 +1063,8 @@ class bitfinex2(ccxt.async_support.bitfinex2):
                 method = self.safe_value(privateMethods, name)
             else:
                 method = self.safe_value_2(publicMethods, name, channel)
-            if method is None:
-                return message
-            else:
-                return method(client, message, subscription)
+            if method is not None:
+                method(client, message, subscription)
         else:
             event = self.safe_string(message, 'event')
             if event is not None:
@@ -1074,7 +1074,5 @@ class bitfinex2(ccxt.async_support.bitfinex2):
                     'auth': self.handle_authentication_message,
                 }
                 method = self.safe_value(methods, event)
-                if method is None:
-                    return message
-                else:
-                    return method(client, message)
+                if method is not None:
+                    method(client, message)

ccxt/pro/bitget.py

@@ -100,7 +100,9 @@ class bitget(ccxt.async_support.bitget):
             instType, params = self.handleProductTypeAndParams(market, params)
         else:
             instType = 'SPOT'
-        instType, params = self.handle_option_and_params(params, 'getInstType', 'instType', instType)
+        instypeAux = None
+        instypeAux, params = self.handle_option_and_params(params, 'getInstType', 'instType', instType)
+        instType = instypeAux
         return [instType, params]
 
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:

ccxt/pro/bitmart.py

@@ -766,7 +766,6 @@ class bitmart(ccxt.async_support.bitmart):
         if isSpot:
             messageHash += ':' + self.safe_string(data[0], 'symbol')
         client.resolve(stored, messageHash)
-        return message
 
     def parse_ws_trade(self, trade, market: Market = None):
         # spot
@@ -864,7 +863,6 @@ class bitmart(ccxt.async_support.bitmart):
             self.tickers[symbol] = ticker
             client.resolve(ticker, 'tickers::swap')
             self.resolve_message_hashes_for_symbol(client, symbol, ticker, 'tickers::')
-        return message
 
     def resolve_message_hashes_for_symbol(self, client, symbol, result, prexif):
         prefixSeparator = '::'
@@ -1357,10 +1355,8 @@ class bitmart(ccxt.async_support.bitmart):
                     'subscribe': self.handle_subscription_status,
                 }
                 method = self.safe_value(methods, event)
-                if method is None:
-                    return message
-                else:
-                    return method(client, message)
+                if method is not None:
+                    method(client, message)
         else:
             methods = {
                 'depth': self.handle_order_book,
@@ -1377,4 +1373,4 @@ class bitmart(ccxt.async_support.bitmart):
                 key = keys[i]
                 if channel.find(key) >= 0:
                     method = self.safe_value(methods, key)
-                    return method(client, message)
+                    method(client, message)

ccxt/pro/bitmex.py

@@ -1462,7 +1462,7 @@ class bitmex(ccxt.async_support.bitmex):
         #
         #     {"error": "Rate limit exceeded, retry in 29 seconds."}
         #
-        error = self.safe_value(message, 'error')
+        error = self.safe_string(message, 'error')
         if error is not None:
             request = self.safe_value(message, 'request', {})
             args = self.safe_value(request, 'args', [])
@@ -1473,7 +1473,7 @@ class bitmex(ccxt.async_support.bitmex):
                 broadKey = self.find_broadly_matched_key(broad, error)
                 exception = None
                 if broadKey is None:
-                    exception = ExchangeError(error)
+                    exception = ExchangeError(error)  # c# requirement for now
                 else:
                     exception = broad[broadKey](error)
                 client.reject(exception, messageHash)
@@ -1537,8 +1537,6 @@ class bitmex(ccxt.async_support.bitmex):
                 request = self.safe_value(message, 'request', {})
                 op = self.safe_value(request, 'op')
                 if op == 'authKeyExpires':
-                    return self.handle_authentication_message(client, message)
-                else:
-                    return message
+                    self.handle_authentication_message(client, message)
             else:
-                return method(client, message)
+                method(client, message)

ccxt/pro/bitopro.py

@@ -440,7 +440,5 @@ class bitopro(ccxt.async_support.bitopro):
         }
         event = self.safe_string(message, 'event')
         method = self.safe_value(methods, event)
-        if method is None:
-            return message
-        else:
-            return method(client, message)
+        if method is not None:
+            method(client, message)

ccxt/pro/bitrue.py

@@ -408,7 +408,7 @@ class bitrue(ccxt.async_support.bitrue):
             except Exception as error:
                 self.options['listenKey'] = None
                 self.options['listenKeyUrl'] = None
-                return
+                return None
             #
             #     {
             #         "msg": "succ",

ccxt/pro/bitstamp.py

@@ -482,9 +482,9 @@ class bitstamp(ccxt.async_support.bitstamp):
         #
         event = self.safe_string(message, 'event')
         if event == 'bts:subscription_succeeded':
-            return self.handle_subscription_status(client, message)
+            self.handle_subscription_status(client, message)
         else:
-            return self.handle_subject(client, message)
+            self.handle_subject(client, message)
 
     async def authenticate(self, params={}):
         self.check_required_credentials()
@@ -506,7 +506,6 @@ class bitstamp(ccxt.async_support.bitstamp):
                 self.options['expiresIn'] = self.sum(time, validity)
                 self.options['userId'] = userId
                 self.options['wsSessionToken'] = sessionToken
-                return response
 
     async def subscribe_private(self, subscription, messageHash, params={}):
         url = self.urls['api']['ws']

ccxt/pro/bitvavo.py

@@ -400,7 +400,7 @@ class bitvavo(ccxt.async_support.bitvavo):
         #
         response = self.safe_value(message, 'response')
         if response is None:
-            return message
+            return
         marketId = self.safe_string(response, 'market')
         symbol = self.safe_symbol(marketId, None, '-')
         name = 'book'
@@ -502,7 +502,7 @@ class bitvavo(ccxt.async_support.bitvavo):
             limit = trades.getLimit(symbol, limit)
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
-    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount, price=None, params={}) -> Order:
+    async def create_order_ws(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: float = None, params={}) -> Order:
         """
         create a trade order
         :see: https://docs.bitvavo.com/#tag/Orders/paths/~1order/post
@@ -1122,7 +1122,7 @@ class bitvavo(ccxt.async_support.bitvavo):
                 method(client, message, subscription)
         return message
 
-    def authenticate(self, params={}):
+    async def authenticate(self, params={}):
         url = self.urls['api']['ws']
         client = self.client(url)
         messageHash = 'authenticated'
@@ -1259,7 +1259,12 @@ class bitvavo(ccxt.async_support.bitvavo):
             'getCandles': self.handle_fetch_ohlcv,
             'getMarkets': self.handle_markets,
         }
-        event = self.safe_string_2(message, 'event', 'action')
+        event = self.safe_string(message, 'event')
         method = self.safe_value(methods, event)
-        if method is not None:
+        if method is None:
+            action = self.safe_string(message, 'action')
+            method = self.safe_value(methods, action)
+            if method is not None:
+                method(client, message)
+        else:
             method(client, message)