ccxt 4.2.76__py2.py3-none-any.whl → 4.4.48__py2.py3-none-any.whl

ccxt/async_support/zonda.py

@@ -6,9 +6,10 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.zonda import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currency, DepositAddress, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
 from ccxt.base.errors import AccountSuspended
 from ccxt.base.errors import BadRequest
@@ -20,7 +21,6 @@ from ccxt.base.errors import OrderImmediatelyFillable
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import OnMaintenance
 from ccxt.base.errors import InvalidNonce
-from ccxt.base.errors import AuthenticationError
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
@@ -50,32 +50,52 @@ class zonda(Exchange, ImplicitAPI):
                 'createOrder': True,
                 'createReduceOnlyOrder': False,
                 'fetchBalance': True,
+                'fetchBorrowInterest': False,
+                'fetchBorrowRate': False,
                 'fetchBorrowRateHistories': False,
                 'fetchBorrowRateHistory': False,
+                'fetchBorrowRates': False,
+                'fetchBorrowRatesPerSymbol': False,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
                 'fetchDeposit': False,
                 'fetchDepositAddress': True,
                 'fetchDepositAddresses': True,
+                'fetchDepositAddressesByNetwork': False,
                 'fetchDeposits': None,
                 'fetchFundingHistory': False,
+                'fetchFundingInterval': False,
+                'fetchFundingIntervals': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
                 'fetchFundingRates': False,
+                'fetchGreeks': False,
                 'fetchIndexOHLCV': False,
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
+                'fetchIsolatedPositions': False,
                 'fetchLedger': True,
                 'fetchLeverage': False,
+                'fetchLeverages': False,
                 'fetchLeverageTiers': False,
+                'fetchLiquidations': 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,
                 'fetchOpenOrder': False,
                 'fetchOpenOrders': True,
+                'fetchOption': False,
+                'fetchOptionChain': False,
                 'fetchOrderBook': True,
                 'fetchOrderBooks': False,
                 'fetchPosition': False,
@@ -83,6 +103,7 @@ class zonda(Exchange, ImplicitAPI):
                 'fetchPositions': False,
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
+                'fetchSettlementHistory': False,
                 'fetchTicker': True,
                 'fetchTickers': True,
                 'fetchTime': False,
@@ -93,9 +114,13 @@ class zonda(Exchange, ImplicitAPI):
                 'fetchTransactionFees': False,
                 'fetchTransactions': None,
                 'fetchTransfer': False,
+                'fetchUnderlyingAssets': False,
+                'fetchVolatilityHistory': False,
                 'fetchWithdrawal': False,
                 'fetchWithdrawals': None,
                 'reduceMargin': False,
+                'repayCrossMargin': False,
+                'repayIsolatedMargin': False,
                 'setLeverage': False,
                 'setMargin': False,
                 'setMarginMode': False,
@@ -183,6 +208,10 @@ class zonda(Exchange, ImplicitAPI):
                         'balances/BITBAY/balance',
                         'fiat_cantor/rate/{baseId}/{quoteId}',
                         'fiat_cantor/history',
+                        'client_payments/v2/customer/crypto/{currency}/channels/deposit',
+                        'client_payments/v2/customer/crypto/{currency}/channels/withdrawal',
+                        'client_payments/v2/customer/crypto/deposit/fee',
+                        'client_payments/v2/customer/crypto/withdrawal/fee',
                     ],
                     'post': [
                         'trading/offer/{symbol}',
@@ -193,6 +222,8 @@ class zonda(Exchange, ImplicitAPI):
                         'fiat_cantor/exchange',
                         'api_payments/withdrawals/crypto',
                         'api_payments/withdrawals/fiat',
+                        'client_payments/v2/customer/crypto/deposit',
+                        'client_payments/v2/customer/crypto/withdrawal',
                     ],
                     'delete': [
                         'trading/offer/{symbol}/{id}/{side}/{price}',
@@ -311,9 +342,11 @@ class zonda(Exchange, ImplicitAPI):
             },
         })
 
-    async def fetch_markets(self, params={}):
+    async def fetch_markets(self, params={}) -> List[Market]:
         """
-        :see: https://docs.zondacrypto.exchange/reference/ticker-1
+
+        https://docs.zondacrypto.exchange/reference/ticker-1
+
         retrieves data on all markets for zonda
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
@@ -410,7 +443,9 @@ class zonda(Exchange, ImplicitAPI):
 
     async def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
-        :see: https://docs.zondacrypto.exchange/reference/active-orders
+
+        https://docs.zondacrypto.exchange/reference/active-orders
+
         fetch all unfilled currently open orders
         :param str symbol: not used by zonda fetchOpenOrders
         :param int [since]: the earliest time in ms to fetch open orders for
@@ -419,12 +454,12 @@ class zonda(Exchange, ImplicitAPI):
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        request = {}
+        request: dict = {}
         response = await self.v1_01PrivateGetTradingOffer(self.extend(request, params))
-        items = self.safe_value(response, 'items', [])
+        items = self.safe_list(response, 'items', [])
         return self.parse_orders(items, None, since, limit, {'status': 'open'})
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         #     {
         #         "market": "ETH-EUR",
@@ -443,6 +478,13 @@ class zonda(Exchange, ImplicitAPI):
         #         "secondBalanceId": "ab43023b-4079-414c-b340-056e3430a3af"
         #     }
         #
+        # cancelOrder
+        #
+        #    {
+        #        status: "Ok",
+        #        errors: []
+        #    }
+        #
         marketId = self.safe_string(order, 'market')
         symbol = self.safe_symbol(marketId, market, '-')
         timestamp = self.safe_integer(order, 'time')
@@ -463,7 +505,6 @@ class zonda(Exchange, ImplicitAPI):
             'postOnly': postOnly,
             'side': self.safe_string_lower(order, 'offerType'),
             'price': self.safe_string(order, 'rate'),
-            'stopPrice': None,
             'triggerPrice': None,
             'amount': amount,
             'cost': None,
@@ -476,7 +517,9 @@ class zonda(Exchange, ImplicitAPI):
 
     async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
-        :see: https://docs.zondacrypto.exchange/reference/transactions-history
+
+        https://docs.zondacrypto.exchange/reference/transactions-history
+
         fetch all trades made by the user
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch trades for
@@ -485,12 +528,12 @@ class zonda(Exchange, ImplicitAPI):
         :returns Trade[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
         """
         await self.load_markets()
-        request = {}
+        request: dict = {}
         if symbol:
             markets = [self.market_id(symbol)]
             symbol = self.symbol(symbol)
             request['markets'] = markets
-        query = {'query': self.json(self.extend(request, params))}
+        query: dict = {'query': self.json(self.extend(request, params))}
         response = await self.v1_01PrivateGetTradingHistoryTransactions(query)
         #
         #     {
@@ -522,7 +565,7 @@ class zonda(Exchange, ImplicitAPI):
         balances = self.safe_value(response, 'balances')
         if balances is None:
             raise ExchangeError(self.id + ' empty balance response ' + self.json(response))
-        result = {'info': response}
+        result: dict = {'info': response}
         for i in range(0, len(balances)):
             balance = balances[i]
             currencyId = self.safe_string(balance, 'currency')
@@ -535,7 +578,9 @@ class zonda(Exchange, ImplicitAPI):
 
     async def fetch_balance(self, params={}) -> Balances:
         """
-        :see: https://docs.zondacrypto.exchange/reference/list-of-wallets
+
+        https://docs.zondacrypto.exchange/reference/list-of-wallets
+
         query for balance and get the amount of funds available for trading or funds locked in orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
@@ -546,7 +591,9 @@ class zonda(Exchange, ImplicitAPI):
 
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
-        :see: https://docs.zondacrypto.exchange/reference/orderbook-2
+
+        https://docs.zondacrypto.exchange/reference/orderbook-2
+
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
@@ -555,7 +602,7 @@ class zonda(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = await self.v1_01PublicGetTradingOrderbookSymbol(self.extend(request, params))
@@ -588,7 +635,7 @@ class zonda(Exchange, ImplicitAPI):
             'nonce': self.safe_integer(response, 'seqNo'),
         }
 
-    def parse_ticker(self, ticker, market: Market = None) -> Ticker:
+    def parse_ticker(self, ticker: dict, market: Market = None) -> Ticker:
         #
         # version 1
         #
@@ -657,7 +704,9 @@ class zonda(Exchange, ImplicitAPI):
     async def fetch_ticker(self, symbol: str, params={}):
         """
         v1_01PublicGetTradingTickerSymbol retrieves timestamp, datetime, bid, ask, close, last, previousClose, v1_01PublicGetTradingStatsSymbol retrieves high, low, volume and opening price of an asset
-        :see: https://docs.zondacrypto.exchange/reference/market-statistics
+
+        https://docs.zondacrypto.exchange/reference/market-statistics
+
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.method]: v1_01PublicGetTradingTickerSymbol(default) or v1_01PublicGetTradingStatsSymbol
@@ -665,7 +714,7 @@ class zonda(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         method = 'v1_01PublicGetTradingTickerSymbol'
@@ -723,9 +772,11 @@ class zonda(Exchange, ImplicitAPI):
 
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
-         * @ignore
+ @ignore
         v1_01PublicGetTradingTicker retrieves timestamp, datetime, bid, ask, close, last, previousClose for each market, v1_01PublicGetTradingStats retrieves high, low, volume and opening price of each market
-        :see: https://docs.zondacrypto.exchange/reference/market-statistics
+
+        https://docs.zondacrypto.exchange/reference/market-statistics
+
         :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.method]: v1_01PublicGetTradingTicker(default) or v1_01PublicGetTradingStats
@@ -788,24 +839,26 @@ class zonda(Exchange, ImplicitAPI):
             #
         else:
             raise BadRequest(self.id + ' fetchTickers params["method"] must be "v1_01PublicGetTradingTicker" or "v1_01PublicGetTradingStats"')
-        items = self.safe_value(response, 'items')
+        items = self.safe_dict(response, 'items')
         return self.parse_tickers(items, symbols)
 
-    async def fetch_ledger(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
+    async def fetch_ledger(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[LedgerEntry]:
         """
-        :see: https://docs.zondacrypto.exchange/reference/operations-history
-        fetch the history of changes, actions done by the user or operations that altered balance of the user
-        :param str code: unified currency code, default is None
+        fetch the history of changes, actions done by the user or operations that altered the balance of the user
+
+        https://docs.zondacrypto.exchange/reference/operations-history
+
+        :param str [code]: unified currency code, default is None
         :param int [since]: timestamp in ms of the earliest ledger entry, default is None
-        :param int [limit]: max number of ledger entrys to return, default is None
+        :param int [limit]: max number of ledger entries to return, default is None
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: a `ledger structure <https://docs.ccxt.com/#/?id=ledger-structure>`
+        :returns dict: a `ledger structure <https://docs.ccxt.com/#/?id=ledger>`
         """
         balanceCurrencies = []
         if code is not None:
             currency = self.currency(code)
             balanceCurrencies.append(currency['id'])
-        request = {
+        request: dict = {
             'balanceCurrencies': balanceCurrencies,
         }
         if since is not None:
@@ -817,7 +870,7 @@ class zonda(Exchange, ImplicitAPI):
         items = response['items']
         return self.parse_ledger(items, None, since, limit)
 
-    def parse_ledger_entry(self, item, currency: Currency = None):
+    def parse_ledger_entry(self, item: dict, currency: Currency = None) -> LedgerEntry:
         #
         #    FUNDS_MIGRATION
         #    {
@@ -1088,6 +1141,7 @@ class zonda(Exchange, ImplicitAPI):
         timestamp = self.safe_integer(item, 'time')
         balance = self.safe_value(item, 'balance', {})
         currencyId = self.safe_string(balance, 'currency')
+        currency = self.safe_currency(currencyId, currency)
         change = self.safe_value(item, 'change', {})
         amount = self.safe_string(change, 'total')
         direction = 'in'
@@ -1098,7 +1152,7 @@ class zonda(Exchange, ImplicitAPI):
         # that can be used to enrich the transfers with txid, address etc(you need to use info.detailId parameter)
         fundsBefore = self.safe_value(item, 'fundsBefore', {})
         fundsAfter = self.safe_value(item, 'fundsAfter', {})
-        return {
+        return self.safe_ledger_entry({
             'info': item,
             'id': self.safe_string(item, 'historyId'),
             'direction': direction,
@@ -1114,10 +1168,10 @@ class zonda(Exchange, ImplicitAPI):
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'fee': None,
-        }
+        }, currency)
 
     def parse_ledger_entry_type(self, type):
-        types = {
+        types: dict = {
             'ADD_FUNDS': 'transaction',
             'BITCOIN_GOLD_FORK': 'transaction',
             'CREATE_BALANCE': 'transaction',
@@ -1161,7 +1215,9 @@ class zonda(Exchange, ImplicitAPI):
 
     async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
-        :see: https://docs.zondacrypto.exchange/reference/candles-chart
+
+        https://docs.zondacrypto.exchange/reference/candles-chart
+
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
@@ -1173,7 +1229,7 @@ class zonda(Exchange, ImplicitAPI):
         await self.load_markets()
         market = self.market(symbol)
         tradingSymbol = market['baseId'] + '-' + market['quoteId']
-        request = {
+        request: dict = {
             'symbol': tradingSymbol,
             'resolution': self.safe_string(self.timeframes, timeframe, timeframe),
             # 'from': 1574709092000,  # unix timestamp in milliseconds, required
@@ -1181,6 +1237,8 @@ class zonda(Exchange, ImplicitAPI):
         }
         if limit is None:
             limit = 100
+        else:
+            limit = min(limit, 11000)  # supports up to 11k candles diapason
         duration = self.parse_timeframe(timeframe)
         timerange = limit * duration * 1000
         if since is None:
@@ -1200,10 +1258,10 @@ class zonda(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        items = self.safe_value(response, 'items', [])
+        items = self.safe_list(response, 'items', [])
         return self.parse_ohlcvs(items, market, timeframe, since, limit)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # createOrder trades
         #
@@ -1279,7 +1337,9 @@ class zonda(Exchange, ImplicitAPI):
 
     async def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
-        :see: https://docs.zondacrypto.exchange/reference/last-transactions
+
+        https://docs.zondacrypto.exchange/reference/last-transactions
+
         get the list of most recent trades for a particular symbol
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
@@ -1290,7 +1350,7 @@ class zonda(Exchange, ImplicitAPI):
         await self.load_markets()
         market = self.market(symbol)
         tradingSymbol = market['baseId'] + '-' + market['quoteId']
-        request = {
+        request: dict = {
             'symbol': tradingSymbol,
         }
         if since is not None:
@@ -1298,7 +1358,7 @@ class zonda(Exchange, ImplicitAPI):
         if limit is not None:
             request['limit'] = limit  # default - 10, max - 300
         response = await self.v1_01PublicGetTradingTransactionsSymbol(self.extend(request, params))
-        items = self.safe_value(response, 'items')
+        items = self.safe_list(response, 'items')
         return self.parse_trades(items, market, since, limit)
 
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
@@ -1308,7 +1368,7 @@ class zonda(Exchange, ImplicitAPI):
         :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 float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
@@ -1316,7 +1376,7 @@ class zonda(Exchange, ImplicitAPI):
         market = self.market(symbol)
         tradingSymbol = market['baseId'] + '-' + market['quoteId']
         amount = float(self.amount_to_precision(symbol, amount))
-        request = {
+        request: dict = {
             'symbol': tradingSymbol,
             'offerType': side.upper(),
             'amount': amount,
@@ -1339,7 +1399,7 @@ class zonda(Exchange, ImplicitAPI):
         response = None
         if isStopOrder:
             if not isStopLossPrice:
-                raise ExchangeError(self.id + ' createOrder() zonda requires `triggerPrice` or `stopPrice` parameter for stop-limit or stop-market orders')
+                raise ExchangeError(self.id + ' createOrder() zonda requires `triggerPrice` parameter for stop-limit or stop-market orders')
             request['stopRate'] = self.price_to_precision(symbol, stopLossPrice)
             response = await self.v1_01PrivatePostTradingStopOfferSymbol(self.extend(request, params))
         else:
@@ -1425,7 +1485,9 @@ class zonda(Exchange, ImplicitAPI):
 
     async def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
-        :see: https://docs.zondacrypto.exchange/reference/cancel-order
+
+        https://docs.zondacrypto.exchange/reference/cancel-order
+
         cancels an open order
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
@@ -1441,25 +1503,26 @@ class zonda(Exchange, ImplicitAPI):
         await self.load_markets()
         market = self.market(symbol)
         tradingSymbol = market['baseId'] + '-' + market['quoteId']
-        request = {
+        request: dict = {
             'symbol': tradingSymbol,
             'id': id,
             'side': side,
             'price': price,
         }
+        response = await self.v1_01PrivateDeleteTradingOfferSymbolIdSidePrice(self.extend(request, params))
         # {status: "Fail", errors: ["NOT_RECOGNIZED_OFFER_TYPE"]}  -- if required params are missing
         # {status: "Ok", errors: []}
-        return await self.v1_01PrivateDeleteTradingOfferSymbolIdSidePrice(self.extend(request, params))
+        return self.parse_order(response)
 
-    def is_fiat(self, currency):
-        fiatCurrencies = {
+    def is_fiat(self, currency: str) -> bool:
+        fiatCurrencies: dict = {
             'USD': True,
             'EUR': True,
             'PLN': True,
         }
         return self.safe_bool(fiatCurrencies, currency, False)
 
-    def parse_deposit_address(self, depositAddress, currency: Currency = None):
+    def parse_deposit_address(self, depositAddress, currency: Currency = None) -> DepositAddress:
         #
         #     {
         #         "address": "33u5YAEhQbYfjHHPsfMfCoSdEjfwYjVcBE",
@@ -1473,16 +1536,18 @@ class zonda(Exchange, ImplicitAPI):
         address = self.safe_string(depositAddress, 'address')
         self.check_address(address)
         return {
+            'info': depositAddress,
             'currency': self.safe_currency_code(currencyId, currency),
+            'network': None,
             'address': address,
             'tag': self.safe_string(depositAddress, 'tag'),
-            'network': None,
-            'info': depositAddress,
         }
 
-    async def fetch_deposit_address(self, code: str, params={}):
+    async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
-        :see: https://docs.zondacrypto.exchange/reference/deposit-addresses-for-crypto
+
+        https://docs.zondacrypto.exchange/reference/deposit-addresses-for-crypto
+
         fetch the deposit address for a currency associated with self account
         :param str code: unified currency code
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1491,7 +1556,7 @@ class zonda(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'],
         }
         response = await self.v1_01PrivateGetApiPaymentsDepositsCryptoAddresses(self.extend(request, params))
@@ -1509,12 +1574,14 @@ class zonda(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data')
-        first = self.safe_value(data, 0)
+        first = self.safe_dict(data, 0)
         return self.parse_deposit_address(first, currency)
 
-    async def fetch_deposit_addresses(self, codes: List[str] = None, params={}):
+    async def fetch_deposit_addresses(self, codes: Strings = None, params={}) -> List[DepositAddress]:
         """
-        :see: https://docs.zondacrypto.exchange/reference/deposit-addresses-for-crypto
+
+        https://docs.zondacrypto.exchange/reference/deposit-addresses-for-crypto
+
         fetch deposit addresses for multiple currencies and chain types
         :param str[]|None codes: zonda does not support filtering filtering by multiple codes and will ignore self parameter.
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1535,12 +1602,14 @@ class zonda(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_list(response, 'data')
         return self.parse_deposit_addresses(data, codes)
 
     async def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
         """
-        :see: https://docs.zondacrypto.exchange/reference/internal-transfer
+
+        https://docs.zondacrypto.exchange/reference/internal-transfer
+
         transfer currency internally between wallets on the same account
         :param str code: unified currency code
         :param float amount: amount to transfer
@@ -1551,7 +1620,7 @@ class zonda(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'source': fromAccount,
             'destination': toAccount,
             'currency': code,
@@ -1593,7 +1662,7 @@ class zonda(Exchange, ImplicitAPI):
             transfer['amount'] = amount
         return transfer
 
-    def parse_transfer(self, transfer, currency: Currency = None):
+    def parse_transfer(self, transfer: dict, currency: Currency = None) -> TransferEntry:
         #
         #     {
         #         "status": "Ok",
@@ -1640,16 +1709,18 @@ class zonda(Exchange, ImplicitAPI):
             'status': self.parse_transfer_status(status),
         }
 
-    def parse_transfer_status(self, status):
-        statuses = {
+    def parse_transfer_status(self, status: Str) -> Str:
+        statuses: dict = {
             'Ok': 'ok',
             'Fail': 'failed',
         }
         return self.safe_string(statuses, status, status)
 
-    async def withdraw(self, code: str, amount: float, address, tag=None, params={}):
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
-        :see: https://docs.zondacrypto.exchange/reference/crypto-withdrawal-1
+
+        https://docs.zondacrypto.exchange/reference/crypto-withdrawal-1
+
         make a withdrawal
         :param str code: unified currency code
         :param float amount: the amount to withdraw
@@ -1663,7 +1734,7 @@ class zonda(Exchange, ImplicitAPI):
         await self.load_markets()
         response = None
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'currency': currency['id'],
             'amount': amount,
             'address': address,
@@ -1684,10 +1755,10 @@ class zonda(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_dict(response, 'data')
         return self.parse_transaction(data, currency)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         # withdraw
         #
@@ -1764,7 +1835,7 @@ class zonda(Exchange, ImplicitAPI):
             }
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
-    def handle_errors(self, httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody):
+    def handle_errors(self, httpCode: int, reason: str, url: str, method: str, headers: dict, body: str, response, requestHeaders, requestBody):
         if response is None:
             return None  # fallback to default error handler
         if 'code' in response: