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

ccxt/async_support/coinbaseinternational.py

@@ -571,7 +571,7 @@ class coinbaseinternational(Exchange, ImplicitAPI):
         }
         return await self.v1PrivatePostPortfoliosMargin(self.extend(request, params))
 
-    async def fetch_deposits_withdrawals(self, code: str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
+    async def fetch_deposits_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
         """
         fetch history of deposits and withdrawals
         :see: https://docs.cloud.coinbase.com/intx/reference/gettransfers

ccxt/async_support/cryptocom.py

@@ -176,6 +176,9 @@ class cryptocom(Exchange, ImplicitAPI):
                             'public/get-expired-settlement-price': 10 / 3,
                             'public/get-insurance': 1,
                         },
+                        'post': {
+                            'public/staking/get-conversion-rate': 2,
+                        },
                     },
                     'private': {
                         'post': {
@@ -205,6 +208,16 @@ class cryptocom(Exchange, ImplicitAPI):
                             'private/get-accounts': 10 / 3,
                             'private/get-withdrawal-history': 10 / 3,
                             'private/get-deposit-history': 10 / 3,
+                            'private/staking/stake': 2,
+                            'private/staking/unstake': 2,
+                            'private/staking/get-staking-position': 2,
+                            'private/staking/get-staking-instruments': 2,
+                            'private/staking/get-open-stake': 2,
+                            'private/staking/get-stake-history': 2,
+                            'private/staking/get-reward-history': 2,
+                            'private/staking/convert': 2,
+                            'private/staking/get-open-convert': 2,
+                            'private/staking/get-convert-history': 2,
                         },
                     },
                 },
@@ -799,15 +812,17 @@ class cryptocom(Exchange, ImplicitAPI):
             'timeframe': self.safe_string(self.timeframes, timeframe, timeframe),
         }
         if limit is not None:
+            if limit > 300:
+                limit = 300
             request['count'] = limit
         now = self.microseconds()
         duration = self.parse_timeframe(timeframe)
         until = self.safe_integer(params, 'until', now)
         params = self.omit(params, ['until'])
         if since is not None:
-            request['start_ts'] = since
+            request['start_ts'] = since - duration * 1000
             if limit is not None:
-                request['end_ts'] = self.sum(since, duration * (limit + 1) * 1000) - 1
+                request['end_ts'] = self.sum(since, duration * limit * 1000)
             else:
                 request['end_ts'] = until
         else:

ccxt/async_support/mercado.py

@@ -12,6 +12,7 @@ from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import InvalidOrder
 from ccxt.base.decimal_to_precision import TICK_SIZE
+from ccxt.base.precise import Precise
 
 
 class mercado(Exchange, ImplicitAPI):
@@ -444,7 +445,10 @@ class mercado(Exchange, ImplicitAPI):
             if side == 'buy':
                 if price is None:
                     raise InvalidOrder(self.id + ' createOrder() requires the price argument with market buy orders to calculate total order cost(amount to spend), where cost = amount * price. Supply a price argument to createOrder() call if you want the cost to be calculated for you from price and amount')
-                request['cost'] = self.price_to_precision(market['symbol'], amount * price)
+                amountString = self.number_to_string(amount)
+                priceString = self.number_to_string(price)
+                cost = self.parse_to_numeric(Precise.string_mul(amountString, priceString))
+                request['cost'] = self.price_to_precision(market['symbol'], cost)
             else:
                 request['quantity'] = self.amount_to_precision(market['symbol'], amount)
         response = await getattr(self, method)(self.extend(request, params))

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
@@ -2676,60 +2692,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 +2883,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 +2913,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 +2969,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 +3025,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 +3046,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/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',