ccxt 4.3.62__py2.py3-none-any.whl → 4.3.64__py2.py3-none-any.whl

ccxt/async_support/woo.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.woo import ImplicitAPI
 import hashlib
-from ccxt.base.types import Account, Balances, Bool, Conversion, Currencies, Currency, Int, Leverage, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Trade, TradingFees, Transaction, TransferEntry, TransferEntries
+from ccxt.base.types import Account, Balances, Bool, Conversion, Currencies, Currency, Int, Leverage, MarginModification, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Trade, TradingFees, Transaction, TransferEntry, TransferEntries
 from typing import List
 from typing import Any
 from ccxt.base.errors import ExchangeError
@@ -41,7 +41,7 @@ class woo(Exchange, ImplicitAPI):
                 'swap': True,
                 'future': False,
                 'option': False,
-                'addMargin': False,
+                'addMargin': True,
                 'cancelAllOrders': True,
                 'cancelAllOrdersAfter': True,
                 'cancelOrder': True,
@@ -211,6 +211,7 @@ class woo(Exchange, ImplicitAPI):
                             'positions': 3.33,  # 30 requests per 10 seconds
                             'position/{symbol}': 3.33,
                             'client/transaction_history': 60,
+                            'client/futures_leverage': 60,
                         },
                         'post': {
                             'order': 5,  # 2 requests per 1 second per symbol
@@ -223,6 +224,8 @@ class woo(Exchange, ImplicitAPI):
                             'client/account_mode': 120,
                             'client/position_mode': 5,
                             'client/leverage': 120,
+                            'client/futures_leverage': 30,
+                            'client/isolated_margin': 30,
                         },
                         'delete': {
                             'order': 1,
@@ -905,16 +908,18 @@ class woo(Exchange, ImplicitAPI):
         :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 fulfilled, in units of the quote currency, ignored in market orders
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.marginMode]: *for swap markets only* 'cross' or 'isolated', default 'cross'
         :param float [params.triggerPrice]: The price a trigger order is triggered at
         :param dict [params.takeProfit]: *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered(perpetual swap markets only)
         :param float [params.takeProfit.triggerPrice]: take profit trigger price
         :param dict [params.stopLoss]: *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered(perpetual swap markets only)
         :param float [params.stopLoss.triggerPrice]: stop loss trigger price
-        :param float [params.algoType]: 'STOP'or 'TRAILING_STOP' or 'OCO' or 'CLOSE_POSITION'
+        :param float [params.algoType]: 'STOP' or 'TRAILING_STOP' or 'OCO' or 'CLOSE_POSITION'
         :param float [params.cost]: *spot market buy only* the quote quantity that can be used alternative for the amount
         :param str [params.trailingAmount]: the quote amount to trail away from the current market price
         :param str [params.trailingPercent]: the percent to trail away from the current market price
         :param str [params.trailingTriggerPrice]: the price to trigger a trailing order, default uses the price argument
+        :param str [params.position_side]: 'SHORT' or 'LONG' - if position mode is HEDGE_MODE and the trading involves futures, then is required, otherwise self parameter is not required
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         reduceOnly = self.safe_bool_2(params, 'reduceOnly', 'reduce_only')
@@ -927,6 +932,10 @@ class woo(Exchange, ImplicitAPI):
             'symbol': market['id'],
             'side': orderSide,
         }
+        marginMode: Str = None
+        marginMode, params = self.handle_margin_mode_and_params('createOrder', params)
+        if marginMode is not None:
+            request['margin_mode'] = self.encode_margin_mode(marginMode)
         stopPrice = self.safe_number_2(params, 'triggerPrice', 'stopPrice')
         stopLoss = self.safe_value(params, 'stopLoss')
         takeProfit = self.safe_value(params, 'takeProfit')
@@ -1063,6 +1072,13 @@ class woo(Exchange, ImplicitAPI):
         order['type'] = type
         return order
 
+    def encode_margin_mode(self, mode):
+        modes = {
+            'cross': 'CROSS',
+            'isolated': 'ISOLATED',
+        }
+        return self.safe_string(modes, mode, mode)
+
     async def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
         """
         edit a trade order
@@ -2465,7 +2481,21 @@ class woo(Exchange, ImplicitAPI):
         }
 
     async def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
+        """
+        fetch the history of funding payments paid and received on self account
+        :see: https://docs.woo.org/#get-funding-fee-history
+        :param str [symbol]: unified market symbol
+        :param int [since]: the earliest time in ms to fetch funding history for
+        :param int [limit]: the maximum number of funding history structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+        :returns dict: a `funding history structure <https://docs.ccxt.com/#/?id=funding-history-structure>`
+        """
         await self.load_markets()
+        paginate = False
+        paginate, params = self.handle_option_and_params(params, 'fetchFundingHistory', 'paginate')
+        if paginate:
+            return await self.fetch_paginated_call_cursor('fetchFundingHistory', symbol, since, limit, params, 'page', 'page', 1, 500)
         request: dict = {}
         market: Market = None
         if symbol is not None:
@@ -2473,6 +2503,10 @@ class woo(Exchange, ImplicitAPI):
             request['symbol'] = market['id']
         if since is not None:
             request['start_t'] = since
+        if limit is not None:
+            request['size'] = limit
+        else:
+            request['size'] = 5000
         response = await self.v1PrivateGetFundingFeeHistory(self.extend(request, params))
         #
         #     {
@@ -2497,7 +2531,14 @@ class woo(Exchange, ImplicitAPI):
         #         "success":true
         #     }
         #
+        meta = self.safe_dict(response, 'meta', {})
+        cursor = self.safe_integer(meta, 'current_page')
         result = self.safe_list(response, 'rows', [])
+        resultLength = len(result)
+        if resultLength > 0:
+            lastItem = result[resultLength - 1]
+            lastItem['page'] = cursor
+            result[resultLength - 1] = lastItem
         return self.parse_incomes(result, market, since, limit)
 
     def parse_funding_rate(self, fundingRate, market: Market = None):
@@ -2676,60 +2717,187 @@ class woo(Exchange, ImplicitAPI):
         :see: https://docs.woo.org/#get-account-information-new
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.marginMode]: *for swap markets only* 'cross' or 'isolated'
+        :param str [params.position_mode]: *for swap markets only* 'ONE_WAY' or 'HEDGE_MODE'
         :returns dict: a `leverage structure <https://docs.ccxt.com/#/?id=leverage-structure>`
         """
         await self.load_markets()
         market = self.market(symbol)
-        response = await self.v3PrivateGetAccountinfo(params)
-        #
-        #     {
-        #         "success": True,
-        #         "data": {
-        #             "applicationId": "dsa",
-        #             "account": "dsa",
-        #             "alias": "haha",
-        #             "accountMode": "MARGIN",
-        #             "leverage": 1,
-        #             "takerFeeRate": 1,
-        #             "makerFeeRate": 1,
-        #             "interestRate": 1,
-        #             "futuresTakerFeeRate": 1,
-        #             "futuresMakerFeeRate": 1,
-        #             "otpauth": True,
-        #             "marginRatio": 1,
-        #             "openMarginRatio": 1,
-        #             "initialMarginRatio": 1,
-        #             "maintenanceMarginRatio": 1,
-        #             "totalCollateral": 1,
-        #             "freeCollateral": 1,
-        #             "totalAccountValue": 1,
-        #             "totalVaultValue": 1,
-        #             "totalStakingValue": 1
-        #         },
-        #         "timestamp": 1673323685109
-        #     }
-        #
+        response: dict = None
+        if market['spot']:
+            response = await self.v3PrivateGetAccountinfo(params)
+            #
+            #     {
+            #         "success": True,
+            #         "data": {
+            #             "applicationId": "dsa",
+            #             "account": "dsa",
+            #             "alias": "haha",
+            #             "accountMode": "MARGIN",
+            #             "leverage": 1,
+            #             "takerFeeRate": 1,
+            #             "makerFeeRate": 1,
+            #             "interestRate": 1,
+            #             "futuresTakerFeeRate": 1,
+            #             "futuresMakerFeeRate": 1,
+            #             "otpauth": True,
+            #             "marginRatio": 1,
+            #             "openMarginRatio": 1,
+            #             "initialMarginRatio": 1,
+            #             "maintenanceMarginRatio": 1,
+            #             "totalCollateral": 1,
+            #             "freeCollateral": 1,
+            #             "totalAccountValue": 1,
+            #             "totalVaultValue": 1,
+            #             "totalStakingValue": 1
+            #         },
+            #         "timestamp": 1673323685109
+            #     }
+            #
+        elif market['swap']:
+            request: dict = {
+                'symbol': market['id'],
+            }
+            marginMode: Str = None
+            marginMode, params = self.handle_margin_mode_and_params('fetchLeverage', params, 'cross')
+            request['margin_mode'] = self.encode_margin_mode(marginMode)
+            response = await self.v1PrivateGetClientFuturesLeverage(self.extend(request, params))
+            #
+            # HEDGE_MODE
+            #     {
+            #         "success": True,
+            #         "data":
+            #             {
+            #                 "symbol": "PERP_ETH_USDT",
+            #                 "default_margin_mode": "CROSS",
+            #                 "position_mode": "HEDGE_MODE",
+            #                 "details":  [
+            #                     {
+            #                         "position_side": "LONG",
+            #                         "leverage": 10
+            #                     },
+            #                     {
+            #                         "position_side": "SHORT",
+            #                         "leverage": 10
+            #                     }
+            #                 ]
+            #             },
+            #         "timestamp": 1720886470482
+            #     }
+            #
+            # ONE_WAY
+            #     {
+            #         "success": True,
+            #         "data": {
+            #             "symbol": "PERP_ETH_USDT",
+            #             "default_margin_mode": "ISOLATED",
+            #             "position_mode": "ONE_WAY",
+            #             "details": [
+            #                 {
+            #                     "position_side": "BOTH",
+            #                     "leverage": 10
+            #                 }
+            #             ]
+            #         },
+            #         "timestamp": 1720886810317
+            #     }
+            #
+        else:
+            raise NotSupported(self.id + ' fetchLeverage() is not supported for ' + market['type'] + ' markets')
         data = self.safe_dict(response, 'data', {})
         return self.parse_leverage(data, market)
 
     def parse_leverage(self, leverage: dict, market: Market = None) -> Leverage:
-        leverageValue = self.safe_integer(leverage, 'leverage')
+        marketId = self.safe_string(leverage, 'symbol')
+        market = self.safe_market(marketId, market)
+        marginMode = self.safe_string_lower(leverage, 'default_margin_mode')
+        spotLeverage = self.safe_integer(leverage, 'leverage')
+        longLeverage = spotLeverage
+        shortLeverage = spotLeverage
+        details = self.safe_list(leverage, 'details', [])
+        for i in range(0, len(details)):
+            position = self.safe_dict(details, i, {})
+            positionLeverage = self.safe_integer(position, 'leverage')
+            side = self.safe_string(position, 'position_side')
+            if side == 'BOTH':
+                longLeverage = positionLeverage
+                shortLeverage = positionLeverage
+            elif side == 'LONG':
+                longLeverage = positionLeverage
+            elif side == 'SHORT':
+                shortLeverage = positionLeverage
         return {
             'info': leverage,
             'symbol': market['symbol'],
-            'marginMode': None,
-            'longLeverage': leverageValue,
-            'shortLeverage': leverageValue,
+            'marginMode': marginMode,
+            'longLeverage': longLeverage,
+            'shortLeverage': shortLeverage,
         }
 
     async def set_leverage(self, leverage: Int, symbol: Str = None, params={}):
+        """
+        set the level of leverage for a market
+        :see: https://docs.woo.org/#update-leverage-setting
+        :see: https://docs.woo.org/#update-futures-leverage-setting
+        :param float leverage: the rate of leverage(1, 2, 3, 4 or 5 for spot markets, 1, 2, 3, 4, 5, 10, 15, 20 for swap markets)
+        :param str [symbo]: unified market symbol(is mandatory for swap markets)
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.marginMode]: *for swap markets only* 'cross' or 'isolated'
+        :param str [params.position_side]: *for swap markets only* 'LONG' or 'SHORT' in hedge mode, 'BOTH' in one way mode.
+        :returns dict: response from the exchange
+        """
         await self.load_markets()
-        if (leverage < 1) or (leverage > 20):
-            raise BadRequest(self.id + ' leverage should be between 1 and 20')
         request: dict = {
             'leverage': leverage,
         }
-        return await self.v1PrivatePostClientLeverage(self.extend(request, params))
+        market: Market = None
+        if symbol is not None:
+            market = self.market(symbol)
+        if (symbol is None) or market['spot']:
+            return await self.v1PrivatePostClientLeverage(self.extend(request, params))
+        elif market['swap']:
+            request['symbol'] = market['id']
+            marginMode: Str = None
+            marginMode, params = self.handle_margin_mode_and_params('fetchLeverage', params, 'cross')
+            request['margin_mode'] = self.encode_margin_mode(marginMode)
+            return await self.v1PrivatePostClientFuturesLeverage(self.extend(request, params))
+        else:
+            raise NotSupported(self.id + ' fetchLeverage() is not supported for ' + market['type'] + ' markets')
+
+    async def add_margin(self, symbol: str, amount: float, params={}) -> MarginModification:
+        """
+        add margin
+        :see: https://docs.woo.org/#update-isolated-margin-setting
+        :param str symbol: unified market symbol
+        :param float amount: amount of margin to add
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.position_side]: 'LONG' or 'SHORT' in hedge mode, 'BOTH' in one way mode
+        :returns dict: a `margin structure <https://docs.ccxt.com/#/?id=add-margin-structure>`
+        """
+        return await self.modify_margin_helper(symbol, amount, 'ADD', params)
+
+    async def reduce_margin(self, symbol: str, amount: float, params={}) -> MarginModification:
+        """
+        remove margin from a position
+        :see: https://docs.woo.org/#update-isolated-margin-setting
+        :param str symbol: unified market symbol
+        :param float amount: amount of margin to remove
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.position_side]: 'LONG' or 'SHORT' in hedge mode, 'BOTH' in one way mode
+        :returns dict: a `margin structure <https://docs.ccxt.com/#/?id=reduce-margin-structure>`
+        """
+        return await self.modify_margin_helper(symbol, amount, 'REDUCE', params)
+
+    async def modify_margin_helper(self, symbol: str, amount, type, params={}) -> MarginModification:
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'symbol': market['id'],
+            'adjust_token': 'USDT',  # todo check
+            'adjust_amount': amount,
+            'action': type,
+        }
+        return await self.v1PrivatePostClientIsolatedMargin(self.extend(request, params))
 
     async def fetch_position(self, symbol: Str = None, params={}):
         await self.load_markets()
@@ -2740,17 +2908,26 @@ class woo(Exchange, ImplicitAPI):
         response = await self.v1PrivateGetPositionSymbol(self.extend(request, params))
         #
         #     {
-        #         "symbol":"PERP_ETC_USDT",
-        #         "holding":0.0,
-        #         "pnl_24_h":0,
-        #         "settle_price":0.0,
-        #         "average_open_price":0,
-        #         "success":true,
-        #         "mark_price":22.6955,
-        #         "pending_short_qty":0.0,
-        #         "pending_long_qty":0.0,
-        #         "fee_24_h":0,
-        #         "timestamp":"1652231044.920"
+        #         "symbol": "PERP_ETH_USDT",
+        #         "position_side": "BOTH",
+        #         "leverage": 10,
+        #         "margin_mode": "CROSS",
+        #         "average_open_price": 3139.9,
+        #         "isolated_margin_amount": 0.0,
+        #         "isolated_margin_token": "",
+        #         "opening_time": "1720627963.094",
+        #         "mark_price": 3155.19169891,
+        #         "pending_short_qty": 0.0,
+        #         "pending_long_qty": 0.0,
+        #         "holding": -0.7,
+        #         "pnl_24_h": 0.0,
+        #         "est_liq_price": 9107.40055552,
+        #         "settle_price": 3151.0319904,
+        #         "success": True,
+        #         "fee_24_h": 0.0,
+        #         "isolated_frozen_long": 0.0,
+        #         "isolated_frozen_short": 0.0,
+        #         "timestamp": "1720867502.544"
         #     }
         #
         return self.parse_position(response, market)
@@ -2761,24 +2938,54 @@ class woo(Exchange, ImplicitAPI):
         #
         #     {
         #         "success": True,
-        #         "data": {
+        #         "data":
+        #         {
         #             "positions": [
         #                 {
-        #                     "symbol": "0_symbol",
-        #                     "holding": 1,
-        #                     "pendingLongQty": 0,
-        #                     "pendingShortQty": 1,
-        #                     "settlePrice": 1,
-        #                     "averageOpenPrice": 1,
-        #                     "pnl24H": 1,
-        #                     "fee24H": 1,
-        #                     "markPrice": 1,
-        #                     "estLiqPrice": 1,
-        #                     "timestamp": 12321321
+        #                     "symbol": "PERP_ETH_USDT",
+        #                     "holding": -1.0,
+        #                     "pendingLongQty": 0.0,
+        #                     "pendingShortQty": 0.0,
+        #                     "settlePrice": 3143.2,
+        #                     "averageOpenPrice": 3143.2,
+        #                     "pnl24H": 0.0,
+        #                     "fee24H": 1.5716,
+        #                     "markPrice": 3134.97984158,
+        #                     "estLiqPrice": 3436.176349,
+        #                     "timestamp": 1720628031.463,
+        #                     "adlQuantile": 5,
+        #                     "positionSide": "BOTH",
+        #                     "marginMode": "ISOLATED",
+        #                     "isolatedMarginToken": "USDT",
+        #                     "isolatedMarginAmount": 314.62426,
+        #                     "isolatedFrozenLong": 0.0,
+        #                     "isolatedFrozenShort": 0.0,
+        #                     "leverage": 10
+        #                 },
+        #                 {
+        #                     "symbol": "PERP_SOL_USDT",
+        #                     "holding": -1.0,
+        #                     "pendingLongQty": 0.0,
+        #                     "pendingShortQty": 0.0,
+        #                     "settlePrice": 141.89933923,
+        #                     "averageOpenPrice": 171.38,
+        #                     "pnl24H": 0.0,
+        #                     "fee24H": 0.0,
+        #                     "markPrice": 141.65155427,
+        #                     "estLiqPrice": 4242.73548551,
+        #                     "timestamp": 1720616702.68,
+        #                     "adlQuantile": 5,
+        #                     "positionSide": "BOTH",
+        #                     "marginMode": "CROSS",
+        #                     "isolatedMarginToken": "",
+        #                     "isolatedMarginAmount": 0.0,
+        #                     "isolatedFrozenLong": 0.0,
+        #                     "isolatedFrozenShort": 0.0,
+        #                     "leverage": 10
         #                 }
         #             ]
         #         },
-        #         "timestamp": 1673323880342
+        #         "timestamp": 1720628675078
         #     }
         #
         result = self.safe_dict(response, 'data', {})
@@ -2787,18 +2994,51 @@ class woo(Exchange, ImplicitAPI):
 
     def parse_position(self, position: dict, market: Market = None):
         #
+        # v1PrivateGetPositionSymbol
+        #     {
+        #         "symbol": "PERP_ETH_USDT",
+        #         "position_side": "BOTH",
+        #         "leverage": 10,
+        #         "margin_mode": "CROSS",
+        #         "average_open_price": 3139.9,
+        #         "isolated_margin_amount": 0.0,
+        #         "isolated_margin_token": "",
+        #         "opening_time": "1720627963.094",
+        #         "mark_price": 3155.19169891,
+        #         "pending_short_qty": 0.0,
+        #         "pending_long_qty": 0.0,
+        #         "holding": -0.7,
+        #         "pnl_24_h": 0.0,
+        #         "est_liq_price": 9107.40055552,
+        #         "settle_price": 3151.0319904,
+        #         "success": True,
+        #         "fee_24_h": 0.0,
+        #         "isolated_frozen_long": 0.0,
+        #         "isolated_frozen_short": 0.0,
+        #         "timestamp": "1720867502.544"
+        #     }
+        #
+        # v3PrivateGetPositions
         #     {
-        #         "symbol": "0_symbol",
-        #         "holding": 1,
-        #         "pendingLongQty": 0,
-        #         "pendingShortQty": 1,
-        #         "settlePrice": 1,
-        #         "averageOpenPrice": 1,
-        #         "pnl24H": 1,
-        #         "fee24H": 1,
-        #         "markPrice": 1,
-        #         "estLiqPrice": 1,
-        #         "timestamp": 12321321
+        #         "symbol": "PERP_ETH_USDT",
+        #         "holding": -1.0,
+        #         "pendingLongQty": 0.0,  # todo: check
+        #         "pendingShortQty": 0.0,  # todo: check
+        #         "settlePrice": 3143.2,
+        #         "averageOpenPrice": 3143.2,
+        #         "pnl24H": 0.0,  # todo: check
+        #         "fee24H": 1.5716,  # todo: check
+        #         "markPrice": 3134.97984158,
+        #         "estLiqPrice": 3436.176349,
+        #         "timestamp": 1720628031.463,
+        #         "adlQuantile": 5,
+        #         "positionSide": "BOTH",
+        #         "marginMode": "ISOLATED",
+        #         "isolatedMarginToken": "USDT",  # todo: check
+        #         "isolatedMarginAmount": 314.62426,  # todo: check
+        #         "isolatedFrozenLong": 0.0,  # todo: check
+        #         "isolatedFrozenShort": 0.0,  # todo: check
+        #         "leverage": 10
         #     }
         #
         contract = self.safe_string(position, 'symbol')
@@ -2810,13 +3050,14 @@ class woo(Exchange, ImplicitAPI):
         else:
             side = 'short'
         contractSize = self.safe_string(market, 'contractSize')
-        markPrice = self.safe_string(position, 'markPrice')
+        markPrice = self.safe_string_2(position, 'markPrice', 'mark_price')
         timestamp = self.safe_timestamp(position, 'timestamp')
-        entryPrice = self.safe_string(position, 'averageOpenPrice')
+        entryPrice = self.safe_string_2(position, 'averageOpenPrice', 'average_open_price')
         priceDifference = Precise.string_sub(markPrice, entryPrice)
         unrealisedPnl = Precise.string_mul(priceDifference, size)
         size = Precise.string_abs(size)
         notional = Precise.string_mul(size, markPrice)
+        positionSide = self.safe_string(position, 'positionSide')  # 'SHORT' or 'LONG' for hedged, 'BOTH' for non-hedged
         return self.safe_position({
             'info': position,
             'id': None,
@@ -2830,20 +3071,19 @@ class woo(Exchange, ImplicitAPI):
             'maintenanceMarginPercentage': None,
             'entryPrice': self.parse_number(entryPrice),
             'notional': self.parse_number(notional),
-            'leverage': None,
+            'leverage': self.safe_number(position, 'leverage'),
             'unrealizedPnl': self.parse_number(unrealisedPnl),
             'contracts': self.parse_number(size),
             'contractSize': self.parse_number(contractSize),
             'marginRatio': None,
-            'liquidationPrice': self.safe_number(position, 'estLiqPrice'),
+            'liquidationPrice': self.safe_number_2(position, 'estLiqPrice', 'est_liq_price'),
             'markPrice': self.parse_number(markPrice),
             'lastPrice': None,
             'collateral': None,
-            'marginMode': 'cross',
-            'marginType': None,
+            'marginMode': self.safe_string_lower_2(position, 'marginMode', 'margin_mode'),
             'side': side,
             'percentage': None,
-            'hedged': None,
+            'hedged': positionSide != 'BOTH',
             'stopLossPrice': None,
             'takeProfitPrice': None,
         })

ccxt/async_support/xt.py

@@ -3308,7 +3308,7 @@ class xt(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    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={}):
         """
         fetch the history of changes, actions done by the user or operations that altered the balance of the user
         :see: https://doc.xt.com/#futures_usergetBalanceBill
@@ -3467,7 +3467,7 @@ class xt(Exchange, ImplicitAPI):
             'info': depositAddress,
         }
 
-    async def fetch_deposits(self, code: str = None, since: Int = None, limit: Int = None, params={}):
+    async def fetch_deposits(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all deposits made to an account
         :see: https://doc.xt.com/#deposit_withdrawalhistoryDepositGet
@@ -3518,7 +3518,7 @@ class xt(Exchange, ImplicitAPI):
         deposits = self.safe_value(data, 'items', [])
         return self.parse_transactions(deposits, currency, since, limit, params)
 
-    async def fetch_withdrawals(self, code: str = None, since: Int = None, limit: Int = None, params={}):
+    async def fetch_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all withdrawals made from an account
         :see: https://doc.xt.com/#deposit_withdrawalwithdrawHistory

ccxt/async_support/yobit.py

@@ -558,7 +558,7 @@ class yobit(Exchange, ImplicitAPI):
             ids = self.ids
         else:
             ids = self.market_ids(symbols)
-        idsLength = len(ids)
+        idsLength: number = len(ids)
         idsString = '-'.join(ids)
         maxLength = self.safe_integer(self.options, 'maxUrlLength', 2048)
         # max URL length is 2048 symbols, including http schema, hostname, tld, etc...

ccxt/async_support/zonda.py

@@ -1467,7 +1467,7 @@ class zonda(Exchange, ImplicitAPI):
         # {status: "Ok", errors: []}
         return self.parse_order(response)
 
-    def is_fiat(self, currency):
+    def is_fiat(self, currency: str):
         fiatCurrencies: dict = {
             'USD': True,
             'EUR': True,

ccxt/base/errors.py

@@ -40,7 +40,9 @@ error_hierarchy = {
                 'ExchangeNotAvailable': {
                     'OnMaintenance': {},
                 },
-                'InvalidNonce': {},
+                'InvalidNonce': {
+                    'ChecksumError': {},
+                },
                 'RequestTimeout': {},
             },
             'BadResponse': {
@@ -184,6 +186,10 @@ class InvalidNonce(NetworkError):
     pass
 
 
+class ChecksumError(InvalidNonce):
+    pass
+
+
 class RequestTimeout(NetworkError):
     pass
 
@@ -235,6 +241,7 @@ __all__ = [
     'ExchangeNotAvailable',
     'OnMaintenance',
     'InvalidNonce',
+    'ChecksumError',
     'RequestTimeout',
     'BadResponse',
     'NullResponse',