ccxt 4.3.77__py2.py3-none-any.whl → 4.3.79__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.77'
+__version__ = '4.3.79'
 
 # ----------------------------------------------------------------------------
 

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.77'
+__version__ = '4.3.79'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.77'
+__version__ = '4.3.79'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/binance.py

@@ -3473,7 +3473,7 @@ class binance(Exchange, ImplicitAPI):
         #
         # futures(fapi)
         #
-        #     fapiPrivateV2GetAccount
+        #     fapiPrivateV3GetAccount
         #
         #     {
         #         "feeTier":0,
@@ -8378,6 +8378,7 @@ class binance(Exchange, ImplicitAPI):
         :see: https://developers.binance.com/docs/wallet/asset/trade-fee
         :see: https://developers.binance.com/docs/derivatives/usds-margined-futures/account/rest-api/Account-Information-V2
         :see: https://developers.binance.com/docs/derivatives/coin-margined-futures/account/Account-Information
+        :see: https://developers.binance.com/docs/derivatives/usds-margined-futures/account/rest-api/Account-Config
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.subType]: "linear" or "inverse"
         :returns dict: a dictionary of `fee structures <https://docs.ccxt.com/#/?id=fee-structure>` indexed by market symbols
@@ -8394,7 +8395,7 @@ class binance(Exchange, ImplicitAPI):
         if isSpotOrMargin:
             response = await self.sapiGetAssetTradeFee(params)
         elif isLinear:
-            response = await self.fapiPrivateV2GetAccount(params)
+            response = await self.fapiPrivateGetAccountConfig(params)
         elif isInverse:
             response = await self.dapiPrivateGetAccount(params)
         #
@@ -9576,6 +9577,7 @@ class binance(Exchange, ImplicitAPI):
         :see: https://developers.binance.com/docs/derivatives/coin-margined-futures/account/Account-Information
         :see: https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/Position-Information-V2
         :see: https://developers.binance.com/docs/derivatives/coin-margined-futures/trade/Position-Information
+        :see: https://developers.binance.com/docs/derivatives/usds-margined-futures/account/rest-api/Account-Information-V3
         :param str[] [symbols]: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param boolean [params.portfolioMargin]: set to True if you would like to fetch positions in a portfolio margin account
@@ -9694,6 +9696,7 @@ class binance(Exchange, ImplicitAPI):
         :see: https://developers.binance.com/docs/derivatives/coin-margined-futures/trade/Position-Information
         :see: https://developers.binance.com/docs/derivatives/portfolio-margin/account/Query-UM-Position-Information
         :see: https://developers.binance.com/docs/derivatives/portfolio-margin/account/Query-CM-Position-Information
+        :see: https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/Position-Information-V3
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param boolean [params.portfolioMargin]: set to True if you would like to fetch positions for a portfolio margin account
@@ -10049,6 +10052,7 @@ class binance(Exchange, ImplicitAPI):
         :see: https://developers.binance.com/docs/derivatives/coin-margined-futures/account/Account-Information
         :see: https://developers.binance.com/docs/derivatives/portfolio-margin/account/Get-UM-Account-Detail
         :see: https://developers.binance.com/docs/derivatives/portfolio-margin/account/Get-CM-Account-Detail
+        :see: https://developers.binance.com/docs/derivatives/usds-margined-futures/account/rest-api/Symbol-Config
         :param str[] [symbols]: a list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.subType]: "linear" or "inverse"
@@ -10067,7 +10071,7 @@ class binance(Exchange, ImplicitAPI):
             if isPortfolioMargin:
                 response = await self.papiGetUmAccount(params)
             else:
-                response = await self.fapiPrivateV2GetAccount(params)
+                response = await self.fapiPrivateGetSymbolConfig(params)
         elif self.is_inverse(type, subType):
             if isPortfolioMargin:
                 response = await self.papiGetCmAccount(params)
@@ -10076,6 +10080,8 @@ class binance(Exchange, ImplicitAPI):
         else:
             raise NotSupported(self.id + ' fetchLeverages() supports linear and inverse contracts only')
         leverages = self.safe_list(response, 'positions', [])
+        if isinstance(response, list):
+            leverages = response
         return self.parse_leverages(leverages, symbols, 'symbol')
 
     def parse_leverage(self, leverage: dict, market: Market = None) -> Leverage:
@@ -10084,6 +10090,9 @@ class binance(Exchange, ImplicitAPI):
         marginMode = None
         if marginModeRaw is not None:
             marginMode = 'isolated' if marginModeRaw else 'cross'
+        marginTypeRaw = self.safe_string_lower(leverage, 'marginType')
+        if marginTypeRaw is not None:
+            marginMode = 'cross' if (marginTypeRaw == 'crossed') else 'isolated'
         side = self.safe_string_lower(leverage, 'positionSide')
         longLeverage = None
         shortLeverage = None
@@ -11763,6 +11772,7 @@ class binance(Exchange, ImplicitAPI):
         fetches margin modes("isolated" or "cross") that the market for the symbol in in, with symbol=None all markets for a subType(linear/inverse) are returned
         :see: https://developers.binance.com/docs/derivatives/coin-margined-futures/account/Account-Information
         :see: https://developers.binance.com/docs/derivatives/usds-margined-futures/account/rest-api/Account-Information-V2
+        :see: https://developers.binance.com/docs/derivatives/usds-margined-futures/account/rest-api/Symbol-Config
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.subType]: "linear" or "inverse"
@@ -11777,70 +11787,17 @@ class binance(Exchange, ImplicitAPI):
         subType, params = self.handle_sub_type_and_params('fetchMarginMode', market, params)
         response = None
         if subType == 'linear':
-            response = await self.fapiPrivateV2GetAccount(params)
+            response = await self.fapiPrivateGetSymbolConfig(params)
             #
-            #    {
-            #        feeTier: '0',
-            #        canTrade: True,
-            #        canDeposit: True,
-            #        canWithdraw: True,
-            #        tradeGroupId: '-1',
-            #        updateTime: '0',
-            #        multiAssetsMargin: True,
-            #        totalInitialMargin: '438.31134352',
-            #        totalMaintMargin: '5.90847101',
-            #        totalWalletBalance: '4345.15626338',
-            #        totalUnrealizedProfit: '376.45220224',
-            #        totalMarginBalance: '4721.60846562',
-            #        totalPositionInitialMargin: '425.45252687',
-            #        totalOpenOrderInitialMargin: '12.85881664',
-            #        totalCrossWalletBalance: '4345.15626338',
-            #        totalCrossUnPnl: '376.45220224',
-            #        availableBalance: '4281.84764041',
-            #        maxWithdrawAmount: '4281.84764041',
-            #        assets: [
-            #            {
-            #                asset: 'ETH',
-            #                walletBalance: '0.00000000',
-            #                unrealizedProfit: '0.00000000',
-            #                marginBalance: '0.00000000',
-            #                maintMargin: '0.00000000',
-            #                initialMargin: '0.00000000',
-            #                positionInitialMargin: '0.00000000',
-            #                openOrderInitialMargin: '0.00000000',
-            #                maxWithdrawAmount: '0.00000000',
-            #                crossWalletBalance: '0.00000000',
-            #                crossUnPnl: '0.00000000',
-            #                availableBalance: '1.26075574',
-            #                marginAvailable: True,
-            #                updateTime: '0'
-            #            },
-            #        ...
-            #        ],
-            #        positions: [
-            #            {
-            #              symbol: 'SNTUSDT',
-            #              initialMargin: '0',
-            #              maintMargin: '0',
-            #              unrealizedProfit: '0.00000000',
-            #              positionInitialMargin: '0',
-            #              openOrderInitialMargin: '0',
-            #              leverage: '20',
-            #              isolated: False,
-            #              entryPrice: '0.0',
-            #              breakEvenPrice: '0.0',
-            #              maxNotional: '25000',
-            #              positionSide: 'BOTH',
-            #              positionAmt: '0',
-            #              notional: '0',
-            #              isolatedWallet: '0',
-            #              updateTime: '0',
-            #              bidNotional: '0',
-            #              askNotional: '0'
-            #            },
-            #            ...
-            #        ]
-            #    }
+            # [
+            #     {
+            #         "symbol": "BTCUSDT",
+            #         "marginType": "CROSSED",
+            #         "isAutoAddMargin": "false",
+            #         "leverage": 21,
+            #         "maxNotionalValue": "1000000",
+            #     }
+            # ]
             #
         elif subType == 'inverse':
             response = await self.dapiPrivateGetAccount(params)
@@ -11895,16 +11852,24 @@ class binance(Exchange, ImplicitAPI):
         else:
             raise BadRequest(self.id + ' fetchMarginModes() supports linear and inverse subTypes only')
         assets = self.safe_list(response, 'positions', [])
+        if isinstance(response, list):
+            assets = response
         return self.parse_margin_modes(assets, symbols, 'symbol', 'swap')
 
     def parse_margin_mode(self, marginMode: dict, market=None) -> MarginMode:
         marketId = self.safe_string(marginMode, 'symbol')
         market = self.safe_market(marketId, market)
-        isIsolated = self.safe_bool(marginMode, 'isolated')
+        marginModeRaw = self.safe_bool(marginMode, 'isolated')
+        reMarginMode = None
+        if marginModeRaw is not None:
+            reMarginMode = 'isolated' if marginModeRaw else 'cross'
+        marginTypeRaw = self.safe_string_lower(marginMode, 'marginType')
+        if marginTypeRaw is not None:
+            reMarginMode = 'cross' if (marginTypeRaw == 'crossed') else 'isolated'
         return {
             'info': marginMode,
             'symbol': market['symbol'],
-            'marginMode': 'isolated' if isIsolated else 'cross',
+            'marginMode': reMarginMode,
         }
 
     async def fetch_option(self, symbol: str, params={}) -> Option:

ccxt/async_support/bingx.py

@@ -1180,7 +1180,6 @@ class bingx(Exchange, ImplicitAPI):
             'fee': {
                 'cost': self.parse_number(Precise.string_abs(self.safe_string_2(trade, 'commission', 'n'))),
                 'currency': currencyCode,
-                'rate': None,
             },
         }, market)
 

ccxt/async_support/bitget.py

@@ -1331,6 +1331,7 @@ class bitget(Exchange, ImplicitAPI):
                 'JADE': 'Jade Protocol',
                 'DEGEN': 'DegenReborn',
                 'TONCOIN': 'TON',
+                'OMNI': 'omni',  # conflict with Omni Network
             },
             'options': {
                 'timeframes': {

ccxt/async_support/bitteam.py

@@ -1886,7 +1886,6 @@ class bitteam(Exchange, ImplicitAPI):
         fee = {
             'currency': self.safe_currency_code(feeCurrencyId),
             'cost': feeCost,
-            'rate': None,
         }
         intTs = self.parse_to_int(timestamp)
         return self.safe_trade({

ccxt/async_support/gate.py

@@ -3294,8 +3294,8 @@ class gate(Exchange, ImplicitAPI):
         side = self.safe_string_2(trade, 'side', 'type', contractSide)
         orderId = self.safe_string(trade, 'order_id')
         feeAmount = self.safe_string(trade, 'fee')
-        gtFee = self.safe_string(trade, 'gt_fee')
-        pointFee = self.safe_string(trade, 'point_fee')
+        gtFee = self.omit_zero(self.safe_string(trade, 'gt_fee'))
+        pointFee = self.omit_zero(self.safe_string(trade, 'point_fee'))
         fees = []
         if feeAmount is not None:
             feeCurrencyId = self.safe_string(trade, 'fee_currency')

ccxt/async_support/kraken.py

@@ -1336,7 +1336,7 @@ class kraken(Exchange, ImplicitAPI):
     async def create_market_order_with_cost(self, symbol: str, side: OrderSide, cost: float, params={}):
         """
         create a market order by providing the symbol, side and cost
-        :see: https://docs.kraken.com/rest/#tag/Trading/operation/addOrder
+        :see: https://docs.kraken.com/rest/#tag/Spot-Trading/operation/addOrder
         :param str symbol: unified symbol of the market to create an order in(only USD markets are supported)
         :param str side: 'buy' or 'sell'
         :param float cost: how much you want to trade in units of the quote currency
@@ -1351,7 +1351,7 @@ class kraken(Exchange, ImplicitAPI):
     async def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
         """
         create a market buy order by providing the symbol, side and cost
-        :see: https://docs.kraken.com/rest/#tag/Trading/operation/addOrder
+        :see: https://docs.kraken.com/rest/#tag/Spot-Trading/operation/addOrder
         :param str symbol: unified symbol of the market to create an order in
         :param float cost: how much you want to trade in units of the quote currency
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1362,7 +1362,7 @@ class kraken(Exchange, ImplicitAPI):
 
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """
-        :see: https://docs.kraken.com/rest/#tag/Trading/operation/addOrder
+        :see: https://docs.kraken.com/rest/#tag/Spot-Trading/operation/addOrder
         create a trade order
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
@@ -1495,6 +1495,8 @@ class kraken(Exchange, ImplicitAPI):
         #         "status": "ok",
         #         "txid": "OAW2BO-7RWEK-PZY5UO",
         #         "originaltxid": "OXL6SS-UPNMC-26WBE7",
+        #         "newuserref": 1234,
+        #         "olduserref": 123,
         #         "volume": "0.00075000",
         #         "price": "13500.0",
         #         "orders_cancelled": 1,
@@ -1623,7 +1625,7 @@ class kraken(Exchange, ImplicitAPI):
         if (id is None) or (id.startswith('[')):
             txid = self.safe_list(order, 'txid')
             id = self.safe_string(txid, 0)
-        clientOrderId = self.safe_string(order, 'userref')
+        clientOrderId = self.safe_string_2(order, 'userref', 'newuserref')
         rawTrades = self.safe_value(order, 'trades', [])
         trades = []
         for i in range(0, len(rawTrades)):
@@ -1750,7 +1752,7 @@ class kraken(Exchange, ImplicitAPI):
         if postOnly:
             extendedPostFlags = flags + ',post' if (flags is not None) else 'post'
             request['oflags'] = extendedPostFlags
-        if (flags is not None) and (request['oflags'] is None):
+        if (flags is not None) and not ('oflags' in request):
             request['oflags'] = flags
         params = self.omit(params, ['timeInForce', 'reduceOnly', 'stopLossPrice', 'takeProfitPrice', 'trailingAmount', 'trailingLimitAmount', 'offset'])
         return [request, params]
@@ -1758,7 +1760,7 @@ class kraken(Exchange, ImplicitAPI):
     async def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
         """
         edit a trade order
-        :see: https://docs.kraken.com/rest/#tag/Trading/operation/editOrder
+        :see: https://docs.kraken.com/rest/#tag/Spot-Trading/operation/editOrder
         :param str id: order id
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
@@ -1817,15 +1819,13 @@ class kraken(Exchange, ImplicitAPI):
         clientOrderId = self.safe_value_2(params, 'userref', 'clientOrderId')
         request: dict = {
             'trades': True,  # whether or not to include trades in output(optional, default False)
-            # 'txid': id,  # do not comma separate a list of ids - use fetchOrdersByIds instead
+            'txid': id,  # do not comma separate a list of ids - use fetchOrdersByIds instead
             # 'userref': 'optional',  # restrict results to given user reference id(optional)
         }
         query = params
         if clientOrderId is not None:
             request['userref'] = clientOrderId
             query = self.omit(params, ['userref', 'clientOrderId'])
-        else:
-            request['txid'] = id
         response = await self.privatePostQueryOrders(self.extend(request, query))
         #
         #     {

ccxt/async_support/kuna.py

@@ -870,7 +870,6 @@ class kuna(Exchange, ImplicitAPI):
             'fee': {
                 'cost': self.safe_string(trade, 'fee'),
                 'currency': self.safe_currency_code(self.safe_string(trade, 'feeCurrency')),
-                'rate': None,
             },
         }, market)
 

ccxt/async_support/vertex.py

@@ -658,6 +658,12 @@ class vertex(Exchange, ImplicitAPI):
         amount = None
         side = None
         fee = None
+        feeCost = self.convert_from_x18(self.safe_string(trade, 'fee'))
+        if feeCost is not None:
+            fee = {
+                'cost': feeCost,
+                'currency': None,
+            }
         id = self.safe_string_2(trade, 'trade_id', 'submission_idx')
         order = self.safe_string(trade, 'digest')
         timestamp = self.safe_timestamp(trade, 'timestamp')
@@ -673,10 +679,6 @@ class vertex(Exchange, ImplicitAPI):
             subOrder = self.safe_dict(trade, 'order', {})
             price = self.convert_from_x18(self.safe_string(subOrder, 'priceX18'))
             amount = self.convert_from_x18(self.safe_string(trade, 'base_filled'))
-            fee = {
-                'cost': self.convert_from_x18(self.safe_string(trade, 'fee')),
-                'currency': None,
-            }
             if Precise.string_lt(amount, '0'):
                 side = 'sell'
             else:

ccxt/async_support/woo.py

@@ -603,6 +603,9 @@ class woo(Exchange, ImplicitAPI):
         amount = self.safe_string(trade, 'executed_quantity')
         order_id = self.safe_string(trade, 'order_id')
         fee = self.parse_token_and_fee_temp(trade, 'fee_asset', 'fee')
+        feeCost = self.safe_string(fee, 'cost')
+        if feeCost is not None:
+            fee['cost'] = feeCost
         cost = Precise.string_mul(price, amount)
         side = self.safe_string_lower(trade, 'side')
         id = self.safe_string(trade, 'id')

ccxt/async_support/woofipro.py

@@ -673,6 +673,9 @@ class woofipro(Exchange, ImplicitAPI):
         amount = self.safe_string(trade, 'executed_quantity')
         order_id = self.safe_string(trade, 'order_id')
         fee = self.parse_token_and_fee_temp(trade, 'fee_asset', 'fee')
+        feeCost = self.safe_string(fee, 'cost')
+        if feeCost is not None:
+            fee['cost'] = feeCost
         cost = Precise.string_mul(price, amount)
         side = self.safe_string_lower(trade, 'side')
         id = self.safe_string(trade, 'id')

ccxt/async_support/xt.py

@@ -2035,7 +2035,6 @@ class xt(Exchange, ImplicitAPI):
             'fee': {
                 'currency': self.safe_currency_code(self.safe_string_2(trade, 'feeCurrency', 'feeCoin')),
                 'cost': self.safe_string(trade, 'fee'),
-                'rate': None,
             },
         }, market)
 

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.77'
+__version__ = '4.3.79'
 
 # -----------------------------------------------------------------------------
 
@@ -1328,7 +1328,7 @@ class Exchange(object):
     def starknet_encode_structured_data (domain, messageTypes, messageData, address):
         types = list(messageTypes.keys())
         if len(types) > 1:
-            raise NotSupported(this.id + 'starknetEncodeStructuredData only support single type')
+            raise NotSupported('starknetEncodeStructuredData only support single type')
 
         request = {
             'domain': domain,
@@ -3276,40 +3276,53 @@ class Exchange(object):
                     multiplyPrice = Precise.string_div('1', price)
                 multiplyPrice = Precise.string_mul(multiplyPrice, contractSize)
             cost = Precise.string_mul(multiplyPrice, amount)
-        parseFee = self.safe_value(trade, 'fee') is None
-        parseFees = self.safe_value(trade, 'fees') is None
-        shouldParseFees = parseFee or parseFees
-        fees = []
-        fee = self.safe_value(trade, 'fee')
-        if shouldParseFees:
-            reducedFees = self.reduce_fees_by_currency(fees) if self.reduceFees else fees
-            reducedLength = len(reducedFees)
-            for i in range(0, reducedLength):
-                reducedFees[i]['cost'] = self.safe_number(reducedFees[i], 'cost')
-                if 'rate' in reducedFees[i]:
-                    reducedFees[i]['rate'] = self.safe_number(reducedFees[i], 'rate')
-            if not parseFee and (reducedLength == 0):
-                # copy fee to avoid modification by reference
-                feeCopy = self.deep_extend(fee)
-                feeCopy['cost'] = self.safe_number(feeCopy, 'cost')
-                if 'rate' in feeCopy:
-                    feeCopy['rate'] = self.safe_number(feeCopy, 'rate')
-                reducedFees.append(feeCopy)
-            if parseFees:
-                trade['fees'] = reducedFees
-            if parseFee and (reducedLength == 1):
-                trade['fee'] = reducedFees[0]
-            tradeFee = self.safe_value(trade, 'fee')
-            if tradeFee is not None:
-                tradeFee['cost'] = self.safe_number(tradeFee, 'cost')
-                if 'rate' in tradeFee:
-                    tradeFee['rate'] = self.safe_number(tradeFee, 'rate')
-                trade['fee'] = tradeFee
+        resultFee, resultFees = self.parsed_fee_and_fees(trade)
+        trade['fee'] = resultFee
+        trade['fees'] = resultFees
         trade['amount'] = self.parse_number(amount)
         trade['price'] = self.parse_number(price)
         trade['cost'] = self.parse_number(cost)
         return trade
 
+    def parsed_fee_and_fees(self, container: Any):
+        fee = self.safe_dict(container, 'fee')
+        fees = self.safe_list(container, 'fees')
+        feeDefined = fee is not None
+        feesDefined = fees is not None
+        # parsing only if at least one of them is defined
+        shouldParseFees = (feeDefined or feesDefined)
+        if shouldParseFees:
+            if feeDefined:
+                fee = self.parse_fee_numeric(fee)
+            if not feesDefined:
+                # just set it directly, no further processing needed
+                fees = [fee]
+            # 'fees' were set, so reparse them
+            reducedFees = self.reduce_fees_by_currency(fees) if self.reduceFees else fees
+            reducedLength = len(reducedFees)
+            for i in range(0, reducedLength):
+                reducedFees[i] = self.parse_fee_numeric(reducedFees[i])
+            fees = reducedFees
+            if reducedLength == 1:
+                fee = reducedFees[0]
+            elif reducedLength == 0:
+                fee = None
+        # in case `fee & fees` are None, set `fees` array
+        if fee is None:
+            fee = {
+                'cost': None,
+                'currency': None,
+            }
+        if fees is None:
+            fees = []
+        return [fee, fees]
+
+    def parse_fee_numeric(self, fee: Any):
+        fee['cost'] = self.safe_number(fee, 'cost')  # ensure numeric
+        if 'rate' in fee:
+            fee['rate'] = self.safe_number(fee, 'rate')
+        return fee
+
     def find_nearest_ceiling(self, arr: List[float], providedValue: float):
         #  i.e. findNearestCeiling([10, 30, 50],  23) returns 30
         length = len(arr)
@@ -3378,12 +3391,13 @@ class Exchange(object):
         reduced = {}
         for i in range(0, len(fees)):
             fee = fees[i]
-            feeCurrencyCode = self.safe_string(fee, 'currency')
+            code = self.safe_string(fee, 'currency')
+            feeCurrencyCode = code is not code if None else str(i)
             if feeCurrencyCode is not None:
                 rate = self.safe_string(fee, 'rate')
-                cost = self.safe_value(fee, 'cost')
-                if Precise.string_eq(cost, '0'):
-                    # omit zero cost fees
+                cost = self.safe_string(fee, 'cost')
+                if cost is None:
+                    # omit None cost, does not make sense, however, don't omit '0' costs, still make sense
                     continue
                 if not (feeCurrencyCode in reduced):
                     reduced[feeCurrencyCode] = {}
@@ -3392,7 +3406,7 @@ class Exchange(object):
                     reduced[feeCurrencyCode][rateKey]['cost'] = Precise.string_add(reduced[feeCurrencyCode][rateKey]['cost'], cost)
                 else:
                     reduced[feeCurrencyCode][rateKey] = {
-                        'currency': feeCurrencyCode,
+                        'currency': code,
                         'cost': cost,
                     }
                     if rate is not None:
@@ -3424,7 +3438,13 @@ class Exchange(object):
             if change is None:
                 change = Precise.string_sub(last, open)
             if average is None:
-                average = Precise.string_div(Precise.string_add(last, open), '2')
+                precision = 18
+                if market is not None and self.is_tick_precision():
+                    marketPrecision = self.safe_dict(market, 'precision')
+                    precisionPrice = self.safe_string(marketPrecision, 'price')
+                    if precisionPrice is not None:
+                        precision = self.precision_from_string(precisionPrice)
+                average = Precise.string_div(Precise.string_add(last, open), '2', precision)
         if (percentage is None) and (change is not None) and (open is not None) and Precise.string_gt(open, '0'):
             percentage = Precise.string_mul(Precise.string_div(change, open), '100')
         if (change is None) and (percentage is not None) and (open is not None):
@@ -6215,7 +6235,7 @@ class Exchange(object):
     def parse_margin_modification(self, data: dict, market: Market = None):
         raise NotSupported(self.id + ' parseMarginModification() is not supported yet')
 
-    def parse_margin_modifications(self, response: List[object], symbols: List[str] = None, symbolKey: Str = None, marketType: MarketType = None):
+    def parse_margin_modifications(self, response: List[object], symbols: Strings = None, symbolKey: Str = None, marketType: MarketType = None):
         marginModifications = []
         for i in range(0, len(response)):
             info = response[i]