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

ccxt/async_support/wavesexchange.py

@@ -7,10 +7,11 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.wavesexchange import ImplicitAPI
 import asyncio
 import json
-from ccxt.base.types import Balances, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from typing import Any
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import AccountSuspended
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
@@ -20,8 +21,7 @@ from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import DuplicateOrderId
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import AuthenticationError
-from ccxt.base.decimal_to_precision import DECIMAL_PLACES
+from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
 
@@ -34,6 +34,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             'countries': ['CH'],  # Switzerland
             'certified': False,
             'pro': False,
+            'dex': True,
             'has': {
                 'CORS': None,
                 'spot': True,
@@ -58,6 +59,8 @@ class wavesexchange(Exchange, ImplicitAPI):
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
                 'fetchDepositAddress': True,
+                'fetchDepositAddresses': None,
+                'fetchDepositAddressesByNetwork': None,
                 'fetchDepositWithdrawFee': 'emulated',
                 'fetchDepositWithdrawFees': True,
                 'fetchFundingHistory': False,
@@ -80,8 +83,11 @@ class wavesexchange(Exchange, ImplicitAPI):
                 'fetchOrderBook': True,
                 'fetchOrders': True,
                 'fetchPosition': False,
+                'fetchPositionHistory': False,
                 'fetchPositionMode': False,
                 'fetchPositions': False,
+                'fetchPositionsForSymbol': False,
+                'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
                 'fetchPremiumIndexOHLCV': False,
                 'fetchTicker': True,
@@ -90,6 +96,7 @@ class wavesexchange(Exchange, ImplicitAPI):
                 'fetchTransfer': False,
                 'fetchTransfers': False,
                 'reduceMargin': False,
+                'sandbox': True,
                 'setLeverage': False,
                 'setMarginMode': False,
                 'setPositionMode': False,
@@ -131,7 +138,13 @@ class wavesexchange(Exchange, ImplicitAPI):
                     'forward': 'https://wx.network/api/v1/forward/matcher',
                     'market': 'https://wx.network/api/v1/forward/marketdata/api/v1',
                 },
-                'doc': 'https://docs.wx.network',
+                'doc': [
+                    'https://docs.wx.network',
+                    'https://docs.waves.tech',
+                    'https://api.wavesplatform.com/v0/docs/',
+                    'https://nodes.wavesnodes.com/api-docs/index.html',
+                    'https://matcher.waves.exchange/api-docs/index.html',
+                ],
                 'www': 'https://wx.network',
             },
             'api': {
@@ -325,9 +338,9 @@ class wavesexchange(Exchange, ImplicitAPI):
                 },
             },
             'currencies': {
-                'WX': self.safe_currency_structure({'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': None, 'code': 'WX', 'precision': self.parse_to_int('8')}),
+                'WX': self.safe_currency_structure({'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': None, 'code': 'WX', 'precision': self.parse_number('1e-8')}),
             },
-            'precisionMode': DECIMAL_PLACES,
+            'precisionMode': TICK_SIZE,
             'options': {
                 'allowedCandles': 1440,
                 'accessToken': None,
@@ -338,7 +351,7 @@ class wavesexchange(Exchange, ImplicitAPI):
                 'wavesAddress': None,
                 'withdrawFeeUSDN': 7420,
                 'withdrawFeeWAVES': 100000,
-                'wavesPrecision': 8,
+                'wavesPrecision': 1e-8,
                 'messagePrefix': 'W',  # W for production, T for testnet
                 'networks': {
                     'ERC20': 'ETH',
@@ -386,8 +399,8 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def get_fees_for_asset(self, symbol: str, side, amount, price, params={}):
         await self.load_markets()
         market = self.market(symbol)
-        amount = self.custom_amount_to_precision(symbol, amount)
-        price = self.custom_price_to_precision(symbol, price)
+        amount = self.to_real_symbol_amount(symbol, amount)
+        price = self.to_real_symbol_price(symbol, price)
         request = self.extend({
             'baseId': market['baseId'],
             'quoteId': market['quoteId'],
@@ -418,7 +431,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         matcherFee = self.safe_string(mode, 'matcherFee')
         feeAssetId = self.safe_string(mode, 'feeAssetId')
         feeAsset = self.safe_currency_code(feeAssetId)
-        adjustedMatcherFee = self.currency_from_precision(feeAsset, matcherFee)
+        adjustedMatcherFee = self.from_real_currency_amount(feeAsset, matcherFee)
         amountAsString = self.number_to_string(amount)
         priceAsString = self.number_to_string(price)
         feeCost = self.fee_to_precision(symbol, self.parse_number(adjustedMatcherFee))
@@ -495,7 +508,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             self.options['quotes'] = quotes
             return quotes
 
-    async def fetch_markets(self, params={}):
+    async def fetch_markets(self, params={}) -> List[Market]:
         """
         retrieves data on all markets for wavesexchange
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -566,8 +579,8 @@ class wavesexchange(Exchange, ImplicitAPI):
                 'strike': None,
                 'optionType': None,
                 'precision': {
-                    'amount': self.safe_integer(entry, 'amountAssetDecimals'),
-                    'price': self.safe_integer(entry, 'priceAssetDecimals'),
+                    'amount': self.parse_number(self.parse_precision(self.safe_string(entry, 'amountAssetDecimals'))),
+                    'price': self.parse_number(self.parse_precision(self.safe_string(entry, 'priceAssetDecimals'))),
                 },
                 'limits': {
                     'leverage': {
@@ -595,6 +608,9 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+
+        https://matcher.waves.exchange/api-docs/index.html#/markets/getOrderBook
+
         :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
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -621,12 +637,11 @@ class wavesexchange(Exchange, ImplicitAPI):
 
     def parse_order_book_side(self, bookSide, market=None, limit: Int = None):
         precision = market['precision']
-        wavesPrecision = self.safe_string(self.options, 'wavesPrecision', '8')
-        amountPrecision = '1e' + self.number_to_string(precision['amount'])
-        amountPrecisionString = self.number_to_string(precision['amount'])
-        pricePrecisionString = self.number_to_string(precision['price'])
-        difference = Precise.string_sub(amountPrecisionString, pricePrecisionString)
-        pricePrecision = '1e' + Precise.string_sub(wavesPrecision, difference)
+        wavesPrecision = self.safe_string(self.options, 'wavesPrecision', '1e-8')
+        amountPrecisionString = self.safe_string(precision, 'amount')
+        pricePrecisionString = self.safe_string(precision, 'price')
+        difference = Precise.string_div(amountPrecisionString, pricePrecisionString)
+        pricePrecision = Precise.string_div(wavesPrecision, difference)
         result = []
         for i in range(0, len(bookSide)):
             entry = bookSide[i]
@@ -635,9 +650,9 @@ class wavesexchange(Exchange, ImplicitAPI):
             price = None
             amount = None
             if (pricePrecision is not None) and (entryPrice is not None):
-                price = Precise.string_div(entryPrice, pricePrecision)
-            if (amountPrecision is not None) and (entryAmount is not None):
-                amount = Precise.string_div(entryAmount, amountPrecision)
+                price = Precise.string_mul(entryPrice, pricePrecision)
+            if (amountPrecisionString is not None) and (entryAmount is not None):
+                amount = Precise.string_mul(entryAmount, amountPrecisionString)
             if (limit is not None) and (i > limit):
                 break
             result.append([
@@ -716,6 +731,9 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def sign_in(self, params={}):
         """
         sign in, must be called prior to using other authenticated methods
+
+        https://docs.wx.network/en/api/auth/oauth2-token
+
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns: response from exchange
         """
@@ -732,7 +750,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             payload = prefix + messageHex
             hexKey = self.binary_to_base16(self.base58_to_binary(self.secret))
             signature = self.axolotl(payload, hexKey, 'ed25519')
-            request = {
+            request: dict = {
                 'grant_type': 'password',
                 'scope': 'general',
                 'username': self.apiKey,
@@ -749,7 +767,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             return self.options['accessToken']
         return None
 
-    def parse_ticker(self, ticker, market: Market = None) -> Ticker:
+    def parse_ticker(self, ticker: dict, market: Market = None) -> Ticker:
         #
         #       {
         #           "symbol": "WAVES/BTC",
@@ -826,13 +844,16 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+
+        https://api.wavesplatform.com/v0/docs/#/pairs/getPairsListAll
+
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pairs': market['id'],
         }
         response = await self.publicGetPairs(self.extend(request, params))
@@ -861,13 +882,13 @@ class wavesexchange(Exchange, ImplicitAPI):
         #
         data = self.safe_value(response, 'data', [])
         ticker = self.safe_value(data, 0, {})
-        dataTicker = self.safe_value(ticker, 'data', {})
+        dataTicker = self.safe_dict(ticker, 'data', {})
         return self.parse_ticker(dataTicker, market)
 
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+        :param str[] [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
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
@@ -906,6 +927,9 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+
+        https://api.wavesplatform.com/v0/docs/#/candles/getCandles
+
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch
@@ -915,7 +939,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'baseId': market['baseId'],
             'quoteId': market['quoteId'],
             'interval': self.safe_string(self.timeframes, timeframe, timeframe),
@@ -1015,7 +1039,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             self.safe_number(data, 'volume', 0),
         ]
 
-    async def fetch_deposit_address(self, code: str, params={}):
+    async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         fetch the deposit address for a currency associated with self account
         :param str code: unified currency code
@@ -1060,8 +1084,8 @@ class wavesexchange(Exchange, ImplicitAPI):
         #       ]
         #     }
         #
-        currencies = {}
-        networksByCurrency = {}
+        currencies: dict = {}
+        networksByCurrency: dict = {}
         items = self.safe_value(supportedCurrencies, 'items', [])
         for i in range(0, len(items)):
             entry = items[i]
@@ -1078,7 +1102,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             raise ExchangeError(self.id + ' fetchDepositAddress() ' + code + ' not supported. Currency code must be one of ' + ', '.join(codes))
         response = None
         if network is None:
-            request = {
+            request: dict = {
                 'currency': code,
             }
             response = await self.privateGetDepositAddressesCurrency(self.extend(request, params))
@@ -1088,21 +1112,20 @@ class wavesexchange(Exchange, ImplicitAPI):
                 supportedNetworkKeys = list(supportedNetworks.keys())
                 raise ExchangeError(self.id + ' ' + network + ' network ' + code + ' deposit address not supported. Network must be one of ' + ', '.join(supportedNetworkKeys))
             if network == 'WAVES':
-                request = {
+                request: dict = {
                     'publicKey': self.apiKey,
                 }
                 responseInner = await self.nodeGetAddressesPublicKeyPublicKey(self.extend(request, request))
                 addressInner = self.safe_string(response, 'address')
                 return {
-                    'address': addressInner,
-                    'code': code,  # kept here for backward-compatibility, but will be removed soon
+                    'info': responseInner,
                     'currency': code,
                     'network': network,
+                    'address': addressInner,
                     'tag': None,
-                    'info': responseInner,
                 }
             else:
-                request = {
+                request: dict = {
                     'currency': code,
                     'platform': network,
                 }
@@ -1137,12 +1160,11 @@ class wavesexchange(Exchange, ImplicitAPI):
         addresses = self.safe_value(response, 'deposit_addresses')
         address = self.safe_string(addresses, 0)
         return {
-            'address': address,
-            'code': code,  # kept here for backward-compatibility, but will be removed soon
+            'info': response,
             'currency': code,
-            'tag': None,
             'network': unifiedNetwork,
-            'info': response,
+            'address': address,
+            'tag': None,
         }
 
     async def get_matcher_public_key(self):
@@ -1167,50 +1189,35 @@ class wavesexchange(Exchange, ImplicitAPI):
             return ''
         return currencyId
 
-    def custom_price_to_precision(self, symbol, price):
+    def to_real_currency_amount(self, code: str, amount: float, networkCode=None):
+        currency = self.currency(code)
+        stringValue = Precise.string_div(self.number_to_string(amount), self.safe_string(currency, 'precision'))
+        return int(stringValue)
+
+    def from_real_currency_amount(self, code: str, amountString: str):
+        if not (code in self.currencies):
+            return amountString
+        currency = self.currency(code)
+        precisionAmount = self.safe_string(currency, 'precision')
+        return Precise.string_mul(amountString, precisionAmount)
+
+    def to_real_symbol_price(self, symbol: str, price: float):
+        market = self.market(symbol)
+        stringValue = Precise.string_div(self.number_to_string(price), self.safe_string(market['precision'], 'price'))
+        return int(stringValue)
+
+    def from_real_symbol_price(self, symbol: str, priceString: str):
         market = self.markets[symbol]
-        wavesPrecision = self.safe_string(self.options, 'wavesPrecision', '8')
-        amount = self.number_to_string(market['precision']['amount'])
-        precisionPrice = self.number_to_string(market['precision']['price'])
-        difference = Precise.string_sub(amount, precisionPrice)
-        precision = Precise.string_sub(wavesPrecision, difference)
-        pricePrecision = self.to_precision(price, str(precision))
-        return self.parse_to_int(float(pricePrecision))
-
-    def custom_amount_to_precision(self, symbol, amount):
-        amountPrecision = self.number_to_string(self.to_precision(amount, self.number_to_string(self.markets[symbol]['precision']['amount'])))
-        return self.parse_to_int(float(amountPrecision))
-
-    def currency_to_precision(self, code, amount, networkCode=None):
-        amountPrecision = self.number_to_string(self.to_precision(amount, self.currencies[code]['precision']))
-        return self.parse_to_int(float(amountPrecision))
-
-    def from_precision(self, amount, scale):
-        if amount is None:
-            return None
-        precise = Precise(amount)
-        precise.decimals = self.sum(precise.decimals, scale)
-        precise.reduce()
-        return str(precise)
-
-    def to_precision(self, amount, scale):
-        amountString = self.number_to_string(amount)
-        precise = Precise(amountString)
-        # precise.decimals should be integer
-        precise.decimals = self.parse_to_int(Precise.string_sub(self.number_to_string(precise.decimals), self.number_to_string(scale)))
-        precise.reduce()
-        stringValue = str(precise)
-        return stringValue
-
-    def currency_from_precision(self, currency, amount):
-        scale = self.currencies[currency]['precision']
-        return self.from_precision(amount, scale)
-
-    def price_from_precision(self, symbol, price):
+        return Precise.string_mul(priceString, self.safe_string(market['precision'], 'price'))
+
+    def to_real_symbol_amount(self, symbol: str, amount: float):
+        market = self.market(symbol)
+        stringValue = Precise.string_div(self.number_to_string(amount), self.safe_string(market['precision'], 'amount'))
+        return int(stringValue)
+
+    def from_real_symbol_amount(self, symbol: str, amountString: str):
         market = self.markets[symbol]
-        wavesPrecision = self.safe_integer(self.options, 'wavesPrecision', 8)
-        scale = self.sum(wavesPrecision, market['precision']['price']) - market['precision']['amount']
-        return self.from_precision(price, scale)
+        return Precise.string_mul(amountString, market['precision']['amount'])
 
     def safe_get_dynamic(self, settings):
         orderFee = self.safe_value(settings, 'orderFee')
@@ -1228,13 +1235,16 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """
         create a trade order
+
+        https://matcher.waves.exchange/api-docs/index.html#/serialize/serializeOrder
+
         :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 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
-        :param float [params.stopPrice]: The price at which a stop order is triggered at
+        :param float [params.triggerPrice]: The price at which a stop order is triggered at
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.check_required_dependencies()
@@ -1245,12 +1255,13 @@ class wavesexchange(Exchange, ImplicitAPI):
         amountAsset = self.get_asset_id(market['baseId'])
         priceAsset = self.get_asset_id(market['quoteId'])
         isMarketOrder = (type == 'market')
-        stopPrice = self.safe_float_2(params, 'triggerPrice', 'stopPrice')
-        isStopOrder = (stopPrice is not None)
+        triggerPrice = self.safe_float_2(params, 'triggerPrice', 'stopPrice')
+        isStopOrder = (triggerPrice is not None)
         if (isMarketOrder) and (price is None):
             raise InvalidOrder(self.id + ' createOrder() requires a price argument for ' + type + ' orders to determine the max price for buy and the min price for sell')
         timestamp = self.milliseconds()
-        defaultExpiryDelta = self.safe_integer(self.options, 'createOrderDefaultExpiry', 2419200000)
+        defaultExpiryDelta = None
+        defaultExpiryDelta, params = self.handle_option_and_params(params, 'createOrder', 'defaultExpiry', self.safe_integer(self.options, 'createOrderDefaultExpiry', 2419200000))
         expiration = self.sum(timestamp, defaultExpiryDelta)
         matcherFees = await self.get_fees_for_asset(symbol, side, amount, price)
         # {
@@ -1284,33 +1295,33 @@ class wavesexchange(Exchange, ImplicitAPI):
                 raise InvalidOrder(self.id + ' asset fee must be ' + baseFeeAsset + ' or ' + discountFeeAsset)
             matcherFeeAsset = self.safe_currency_code(matcherFeeAssetId)
             rawMatcherFee = baseMatcherFee if (matcherFeeAssetId == baseFeeAssetId) else discountMatcherFee
-            floatMatcherFee = float(self.currency_from_precision(matcherFeeAsset, rawMatcherFee))
+            floatMatcherFee = float(self.from_real_currency_amount(matcherFeeAsset, rawMatcherFee))
             if (matcherFeeAsset in balances) and (balances[matcherFeeAsset]['free'] >= floatMatcherFee):
                 matcherFee = int(rawMatcherFee)
             else:
                 raise InsufficientFunds(self.id + ' not enough funds of the selected asset fee')
+        floatBaseMatcherFee = self.from_real_currency_amount(baseFeeAsset, baseMatcherFee)
+        floatDiscountMatcherFee = self.from_real_currency_amount(discountFeeAsset, discountMatcherFee)
         if matcherFeeAssetId is None:
             # try to the pay the fee using the base first then discount asset
-            floatBaseMatcherFee = float(self.currency_from_precision(baseFeeAsset, baseMatcherFee))
-            if (baseFeeAsset in balances) and (balances[baseFeeAsset]['free'] >= floatBaseMatcherFee):
+            if (baseFeeAsset in balances) and (balances[baseFeeAsset]['free'] >= float(floatBaseMatcherFee)):
                 matcherFeeAssetId = baseFeeAssetId
                 matcherFee = int(baseMatcherFee)
             else:
-                floatDiscountMatcherFee = float(self.currency_from_precision(discountFeeAsset, discountMatcherFee))
-                if (discountFeeAsset in balances) and (balances[discountFeeAsset]['free'] >= floatDiscountMatcherFee):
+                if (discountFeeAsset in balances) and (balances[discountFeeAsset]['free'] >= float(floatDiscountMatcherFee)):
                     matcherFeeAssetId = discountFeeAssetId
                     matcherFee = int(discountMatcherFee)
         if matcherFeeAssetId is None:
-            raise InsufficientFunds(self.id + ' not enough funds on none of the eligible asset fees')
-        amount = self.custom_amount_to_precision(symbol, amount)
-        price = self.custom_price_to_precision(symbol, price)
-        assetPair = {
+            raise InsufficientFunds(self.id + ' not enough funds on none of the eligible asset fees: ' + baseFeeAsset + ' ' + floatBaseMatcherFee + ' or ' + discountFeeAsset + ' ' + floatDiscountMatcherFee)
+        amount = self.to_real_symbol_amount(symbol, amount)
+        price = self.to_real_symbol_price(symbol, price)
+        assetPair: dict = {
             'amountAsset': amountAsset,
             'priceAsset': priceAsset,
         }
         sandboxMode = self.safe_bool(self.options, 'sandboxMode', False)
         chainId = 84 if (sandboxMode) else 87
-        body = {
+        body: dict = {
             'senderPublicKey': self.apiKey,
             'matcherPublicKey': matcherPublicKey,
             'assetPair': assetPair,
@@ -1336,12 +1347,12 @@ class wavesexchange(Exchange, ImplicitAPI):
             #     },
             # }
             #
-            attachment = {
+            attachment: dict = {
                 'v': 1,
                 'c': {
                     't': 'sp',
                     'v': {
-                        'p': self.custom_price_to_precision(symbol, stopPrice),
+                        'p': self.to_real_symbol_price(symbol, triggerPrice),
                     },
                 },
             }
@@ -1385,17 +1396,20 @@ class wavesexchange(Exchange, ImplicitAPI):
         #     }
         #
         if isMarketOrder:
-            response = await self.matcherPostMatcherOrderbookMarket(body)
-            value = self.safe_value(response, 'message')
+            response = await self.matcherPostMatcherOrderbookMarket(self.extend(body, params))
+            value = self.safe_dict(response, 'message')
             return self.parse_order(value, market)
         else:
-            response = await self.matcherPostMatcherOrderbook(body)
-            value = self.safe_value(response, 'message')
+            response = await self.matcherPostMatcherOrderbook(self.extend(body, params))
+            value = self.safe_dict(response, 'message')
             return self.parse_order(value, market)
 
     async def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
         cancels an open order
+
+        https://matcher.waves.exchange/api-docs/index.html#/cancel/cancelOrdersByIdsWithKeyOrSignature
+
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1418,7 +1432,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         firstMessage = self.safe_value(message, 0)
         firstOrder = self.safe_value(firstMessage, 0)
         returnedId = self.safe_string(firstOrder, 'orderId')
-        return {
+        return self.safe_order({
             'info': response,
             'id': returnedId,
             'clientOrderId': None,
@@ -1437,11 +1451,15 @@ class wavesexchange(Exchange, ImplicitAPI):
             'status': None,
             'fee': None,
             'trades': None,
-        }
+        })
 
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
         fetches information on an order made by the user
+
+        https://matcher.waves.exchange/api-docs/index.html#/status/getOrderStatusByPKAndIdWithSig
+
+        :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
@@ -1460,7 +1478,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         binary = self.binary_concat_array(byteArray)
         hexSecret = self.binary_to_base16(self.base58_to_binary(self.secret))
         signature = self.axolotl(self.binary_to_base16(binary), hexSecret, 'ed25519')
-        request = {
+        request: dict = {
             'Timestamp': str(timestamp),
             'Signature': signature,
             'publicKey': self.apiKey,
@@ -1492,7 +1510,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         binary = self.binary_concat_array(byteArray)
         hexSecret = self.binary_to_base16(self.base58_to_binary(self.secret))
         signature = self.axolotl(self.binary_to_base16(binary), hexSecret, 'ed25519')
-        request = {
+        request: dict = {
             'Accept': 'application/json',
             'Timestamp': str(timestamp),
             'Signature': signature,
@@ -1533,7 +1551,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         if symbol is not None:
             market = self.market(symbol)
         address = await self.get_waves_address()
-        request = {
+        request: dict = {
             'address': address,
             'activeOnly': True,
         }
@@ -1555,7 +1573,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         if symbol is not None:
             market = self.market(symbol)
         address = await self.get_waves_address()
-        request = {
+        request: dict = {
             'address': address,
             'closedOnly': True,
         }
@@ -1582,8 +1600,8 @@ class wavesexchange(Exchange, ImplicitAPI):
         # ]
         return self.parse_orders(response, market, since, limit)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             'Cancelled': 'canceled',
             'Accepted': 'open',
             'Filled': 'closed',
@@ -1597,7 +1615,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         quoteId = self.safe_string(assetPair, 'priceAsset', 'WAVES')
         return self.safe_currency_code(baseId) + '/' + self.safe_currency_code(quoteId)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # createOrder
         #
@@ -1667,23 +1685,23 @@ class wavesexchange(Exchange, ImplicitAPI):
         elif market is not None:
             symbol = market['symbol']
         amountCurrency = self.safe_currency_code(self.safe_string(assetPair, 'amountAsset', 'WAVES'))
-        price = self.price_from_precision(symbol, priceString)
-        amount = self.currency_from_precision(amountCurrency, amountString)
-        filled = self.currency_from_precision(amountCurrency, filledString)
-        average = self.price_from_precision(symbol, self.safe_string(order, 'avgWeighedPrice'))
+        price = self.from_real_symbol_price(symbol, priceString)
+        amount = self.from_real_currency_amount(amountCurrency, amountString)
+        filled = self.from_real_currency_amount(amountCurrency, filledString)
+        average = self.from_real_symbol_price(symbol, self.safe_string(order, 'avgWeighedPrice'))
         status = self.parse_order_status(self.safe_string(order, 'status'))
         fee = None
         if 'type' in order:
-            currency = self.safe_currency_code(self.safe_string(order, 'feeAsset'))
+            code = self.safe_currency_code(self.safe_string(order, 'feeAsset'))
             fee = {
-                'currency': currency,
-                'fee': self.parse_number(self.currency_from_precision(currency, self.safe_string(order, 'filledFee'))),
+                'currency': code,
+                'fee': self.parse_number(self.from_real_currency_amount(code, self.safe_string(order, 'filledFee'))),
             }
         else:
-            currency = self.safe_currency_code(self.safe_string(order, 'matcherFeeAssetId', 'WAVES'))
+            code = self.safe_currency_code(self.safe_string(order, 'matcherFeeAssetId', 'WAVES'))
             fee = {
-                'currency': currency,
-                'fee': self.parse_number(self.currency_from_precision(currency, self.safe_string(order, 'matcherFee'))),
+                'currency': code,
+                'fee': self.parse_number(self.from_real_currency_amount(code, self.safe_string(order, 'matcherFee'))),
             }
         triggerPrice = None
         attachment = self.safe_string(order, 'attachment')
@@ -1708,7 +1726,6 @@ class wavesexchange(Exchange, ImplicitAPI):
             'postOnly': None,
             'side': side,
             'price': price,
-            'stopPrice': triggerPrice,
             'triggerPrice': triggerPrice,
             'amount': amount,
             'cost': None,
@@ -1723,7 +1740,7 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def get_waves_address(self):
         cachedAddreess = self.safe_string(self.options, 'wavesAddress')
         if cachedAddreess is None:
-            request = {
+            request: dict = {
                 'publicKey': self.apiKey,
             }
             response = await self.nodeGetAddressesPublicKeyPublicKey(request)
@@ -1748,7 +1765,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         self.check_required_keys()
         await self.load_markets()
         wavesAddress = await self.get_waves_address()
-        request = {
+        request: dict = {
             'address': wavesAddress,
         }
         totalBalance = await self.nodeGetAssetsBalanceAddress(request)
@@ -1787,7 +1804,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         #   ]
         # }
         balances = self.safe_value(totalBalance, 'balances', [])
-        result = {}
+        result: dict = {}
         timestamp = None
         assetIds = []
         nonStandardBalances = []
@@ -1798,19 +1815,17 @@ class wavesexchange(Exchange, ImplicitAPI):
             issueTransaction = self.safe_value(entry, 'issueTransaction')
             currencyId = self.safe_string(entry, 'assetId')
             balance = self.safe_string(entry, 'balance')
-            if issueTransaction is None:
-                assetIds.append(currencyId)
-                nonStandardBalances.append(balance)
-                continue
-            decimals = self.safe_integer(issueTransaction, 'decimals')
-            code = None
-            if currencyId in self.currencies_by_id:
+            currencyExists = (currencyId in self.currencies_by_id)
+            if currencyExists:
                 code = self.safe_currency_code(currencyId)
                 result[code] = self.account()
-                result[code]['total'] = self.from_precision(balance, decimals)
+                result[code]['total'] = self.from_real_currency_amount(code, balance)
+            elif issueTransaction is None:
+                assetIds.append(currencyId)
+                nonStandardBalances.append(balance)
         nonStandardAssets = len(assetIds)
         if nonStandardAssets:
-            requestInner = {
+            requestInner: dict = {
                 'ids': assetIds,
             }
             response = await self.publicGetAssets(requestInner)
@@ -1819,11 +1834,11 @@ class wavesexchange(Exchange, ImplicitAPI):
                 entry = data[i]
                 balance = nonStandardBalances[i]
                 inner = self.safe_value(entry, 'data')
-                decimals = self.safe_integer(inner, 'precision')
+                precision = self.parse_precision(self.safe_string(inner, 'precision'))
                 ticker = self.safe_string(inner, 'ticker')
                 code = self.safe_currency_code(ticker)
                 result[code] = self.account()
-                result[code]['total'] = self.from_precision(balance, decimals)
+                result[code]['total'] = Precise.string_mul(balance, precision)
         currentTimestamp = self.milliseconds()
         byteArray = [
             self.base58_to_binary(self.apiKey),
@@ -1832,7 +1847,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         binary = self.binary_concat_array(byteArray)
         hexSecret = self.binary_to_base16(self.base58_to_binary(self.secret))
         signature = self.axolotl(self.binary_to_base16(binary), hexSecret, 'ed25519')
-        matcherRequest = {
+        matcherRequest: dict = {
             'publicKey': self.apiKey,
             'signature': signature,
             'timestamp': str(currentTimestamp),
@@ -1846,11 +1861,8 @@ class wavesexchange(Exchange, ImplicitAPI):
             if not (code in result):
                 result[code] = self.account()
             amount = self.safe_string(reservedBalance, currencyId)
-            if code in self.currencies:
-                result[code]['used'] = self.currency_from_precision(code, amount)
-            else:
-                result[code]['used'] = amount
-        wavesRequest = {
+            result[code]['used'] = self.from_real_currency_amount(code, amount)
+        wavesRequest: dict = {
             'address': wavesAddress,
         }
         wavesTotal = await self.nodeGetAddressesBalanceAddress(wavesRequest)
@@ -1859,20 +1871,27 @@ class wavesexchange(Exchange, ImplicitAPI):
         #   "confirmations": 0,
         #   "balance": 909085978
         # }
-        result['WAVES'] = self.safe_value(result, 'WAVES', {})
-        result['WAVES']['total'] = self.currency_from_precision('WAVES', self.safe_string(wavesTotal, 'balance'))
-        codes = list(result.keys())
-        for i in range(0, len(codes)):
-            code = codes[i]
-            if self.safe_value(result[code], 'used') is None:
-                result[code]['used'] = '0'
+        result['WAVES'] = self.safe_value(result, 'WAVES', self.account())
+        result['WAVES']['total'] = self.from_real_currency_amount('WAVES', self.safe_string(wavesTotal, 'balance'))
+        result = self.set_undefined_balances_to_zero(result)
         result['timestamp'] = timestamp
         result['datetime'] = self.iso8601(timestamp)
         return self.safe_balance(result)
 
+    def set_undefined_balances_to_zero(self, balances, key='used'):
+        codes = list(balances.keys())
+        for i in range(0, len(codes)):
+            code = codes[i]
+            if self.safe_value(balances[code], 'used') is None:
+                balances[code][key] = '0'
+        return balances
+
     async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all trades made by the user
+
+        https://api.wavesplatform.com/v0/docs/#/transactions/searchTxsExchange
+
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trades structures to retrieve
@@ -1881,7 +1900,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         address = await self.get_waves_address()
-        request = {
+        request: dict = {
             'sender': address,
         }
         market = None
@@ -1962,6 +1981,9 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
+
+        https://api.wavesplatform.com/v0/docs/#/transactions/searchTxsExchange
+
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -1970,7 +1992,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'amountAsset': market['baseId'],
             'priceAsset': market['quoteId'],
         }
@@ -2048,7 +2070,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         #
         return self.parse_trades(data, market, since, limit)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # {__type: "transaction",
         #   "data":
@@ -2138,7 +2160,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         }, market)
 
     def parse_deposit_withdraw_fees(self, response, codes: Strings = None, currencyIdKey=None) -> Any:
-        depositWithdrawFees = {}
+        depositWithdrawFees: dict = {}
         codes = self.market_codes(codes)
         for i in range(0, len(response)):
             entry = response[i]
@@ -2203,8 +2225,10 @@ class wavesexchange(Exchange, ImplicitAPI):
     async def fetch_deposit_withdraw_fees(self, codes: Strings = None, params={}):
         """
         fetch deposit and withdraw fees
-        :see: https://docs.wx.network/en/api/gateways/deposit/currencies
-        :see: https://docs.wx.network/en/api/gateways/withdraw/currencies
+
+        https://docs.wx.network/en/api/gateways/deposit/currencies
+        https://docs.wx.network/en/api/gateways/withdraw/currencies
+
         :param str[]|None codes: list of unified currency codes
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a list of `fee structures <https://docs.ccxt.com/#/?id=fee-structure>`
@@ -2276,7 +2300,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             data = self.array_concat(data, items)
         return self.parse_deposit_withdraw_fees(data, codes, 'id')
 
-    def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
+    def handle_errors(self, code: int, reason: str, url: str, method: str, headers: dict, body: str, response, requestHeaders, requestBody):
         errorCode = self.safe_string(response, 'error')
         success = self.safe_bool(response, 'success', True)
         Exception = self.safe_value(self.exceptions, errorCode)
@@ -2290,7 +2314,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             raise ExchangeError(self.id + ' ' + body)
         return None
 
-    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:
         """
         make a withdrawal
         :param str code: unified currency code
@@ -2304,7 +2328,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         # currently only works for BTC and WAVES
         if code != 'WAVES':
             supportedCurrencies = await self.privateGetWithdrawCurrencies()
-            currencies = {}
+            currencies: dict = {}
             items = self.safe_value(supportedCurrencies, 'items', [])
             for i in range(0, len(items)):
                 entry = items[i]
@@ -2315,7 +2339,7 @@ class wavesexchange(Exchange, ImplicitAPI):
                 raise ExchangeError(self.id + ' withdraw() ' + code + ' not supported. Currency code must be one of ' + str(codes))
         await self.load_markets()
         hexChars = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
-        set = {}
+        set: dict = {}
         for i in range(0, len(hexChars)):
             key = hexChars[i]
             set[key] = True
@@ -2333,7 +2357,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         if code == 'WAVES' and not isErc20:
             proxyAddress = address
         else:
-            withdrawAddressRequest = {
+            withdrawAddressRequest: dict = {
                 'address': address,
                 'currency': code,
             }
@@ -2370,7 +2394,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         feeAssetId = 'WAVES'
         type = 4  # transfer
         version = 2
-        amountInteger = self.currency_to_precision(code, amount)
+        amountInteger = self.to_real_currency_amount(code, amount)
         currency = self.currency(code)
         timestamp = self.milliseconds()
         byteArray = [
@@ -2388,7 +2412,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         binary = self.binary_concat_array(byteArray)
         hexSecret = self.binary_to_base16(self.base58_to_binary(self.secret))
         signature = self.axolotl(self.binary_to_base16(binary), hexSecret, 'ed25519')
-        request = {
+        request: dict = {
             'senderPublicKey': self.apiKey,
             'amount': amountInteger,
             'fee': fee,
@@ -2417,7 +2441,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         #
         return self.parse_transaction(result, currency)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         # withdraw
         #
@@ -2430,18 +2454,45 @@ class wavesexchange(Exchange, ImplicitAPI):
         #         "amount": 0
         #     }
         #
+        # withdraw new:
+        #     {
+        #         type: "4",
+        #         id: "2xnWTqG9ar7jEDrLxfbVyyspPZ6XZNrrw9ai9sQ81Eya",
+        #         fee: "100000",
+        #         feeAssetId: null,
+        #         timestamp: "1715786263807",
+        #         version: "2",
+        #         sender: "3P81LLX1kk2CSJC9L8C2enxdHB7XvnSGAEE",
+        #         senderPublicKey: "DdmzmXf9mty1FBE8AdVGnrncVLEAzP4gR4nWoTFAJoXz",
+        #         proofs: ["RyoKwdSYv3EqotJCYftfFM9JE2j1ZpDRxKwYfiRhLAFeyNp6VfJUXNDS884XfeCeHeNypNmTCZt5NYR1ekyjCX3",],
+        #         recipient: "3P9tXxu38a8tgewNEKFzourVxeqHd11ppOc",
+        #         assetId: null,
+        #         feeAsset: null,
+        #         amount: "2000000",
+        #         attachment: "",
+        #     }
+        #
         currency = self.safe_currency(None, currency)
+        code = currency['code']
+        typeRaw = self.safe_string(transaction, 'type')
+        type = 'withdraw' if (typeRaw == '4') else 'deposit'
+        amount = self.parse_number(self.from_real_currency_amount(code, self.safe_string(transaction, 'amount')))
+        feeString = self.safe_string(transaction, 'fee')
+        feeAssetId = self.safe_string(transaction, 'feeAssetId', 'WAVES')
+        feeCode = self.safe_currency_code(feeAssetId)
+        feeAmount = self.parse_number(self.from_real_currency_amount(feeCode, feeString))
+        timestamp = self.safe_integer(transaction, 'timestamp')
         return {
-            'id': None,
+            'id': self.safe_string(transaction, 'id'),
             'txid': None,
-            'timestamp': None,
-            'datetime': None,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
             'network': None,
-            'addressFrom': None,
+            'addressFrom': self.safe_string(transaction, 'sender'),
             'address': None,
-            'addressTo': None,
-            'amount': None,
-            'type': None,
+            'addressTo': self.safe_string(transaction, 'recipient'),
+            'amount': amount,
+            'type': type,
             'currency': currency['code'],
             'status': None,
             'updated': None,
@@ -2450,6 +2501,9 @@ class wavesexchange(Exchange, ImplicitAPI):
             'tagTo': None,
             'comment': None,
             'internal': None,
-            'fee': None,
+            'fee': {
+                'currency': feeCode,
+                'cost': feeAmount,
+            },
             'info': transaction,
         }