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

ccxt/woo.py

@@ -6,7 +6,7 @@
 from ccxt.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)
+
     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):
         }
 
     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>`
+        """
         self.load_markets()
+        paginate = False
+        paginate, params = self.handle_option_and_params(params, 'fetchFundingHistory', 'paginate')
+        if paginate:
+            return 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 = 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>`
         """
         self.load_markets()
         market = self.market(symbol)
-        response = 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 = 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 = 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,
         }
 
     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
+        """
         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 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 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 self.v1PrivatePostClientFuturesLeverage(self.extend(request, params))
+        else:
+            raise NotSupported(self.id + ' fetchLeverage() is not supported for ' + market['type'] + ' markets')
+
+    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 self.modify_margin_helper(symbol, amount, 'ADD', params)
+
+    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 self.modify_margin_helper(symbol, amount, 'REDUCE', params)
+
+    def modify_margin_helper(self, symbol: str, amount, type, params={}) -> MarginModification:
+        self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'symbol': market['id'],
+            'adjust_token': 'USDT',  # todo check
+            'adjust_amount': amount,
+            'action': type,
+        }
+        return self.v1PrivatePostClientIsolatedMargin(self.extend(request, params))
 
     def fetch_position(self, symbol: Str = None, params={}):
         self.load_markets()
@@ -2740,17 +2908,26 @@ class woo(Exchange, ImplicitAPI):
         response = 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/xt.py

@@ -3307,7 +3307,7 @@ class xt(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def fetch_ledger(self, code: str = None, since: Int = None, limit: Int = None, params={}):
+    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
@@ -3466,7 +3466,7 @@ class xt(Exchange, ImplicitAPI):
             'info': depositAddress,
         }
 
-    def fetch_deposits(self, code: str = None, since: Int = None, limit: Int = None, params={}):
+    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
@@ -3517,7 +3517,7 @@ class xt(Exchange, ImplicitAPI):
         deposits = self.safe_value(data, 'items', [])
         return self.parse_transactions(deposits, currency, since, limit, params)
 
-    def fetch_withdrawals(self, code: str = None, since: Int = None, limit: Int = None, params={}):
+    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/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/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-4.3.62.dist-info → ccxt-4.3.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.3.62
+Version: 4.3.64
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -268,13 +268,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.3.62/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.3.62/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.3.64/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.3.64/dist/ccxt.browser.min.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.3.62/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.3.64/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object: