ccxt 4.2.55__py2.py3-none-any.whl → 4.2.56__py2.py3-none-any.whl

ccxt/bingx.py

@@ -722,7 +722,7 @@ class bingx(Exchange, ImplicitAPI):
         if paginate:
             return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 1440)
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         request['interval'] = self.safe_string(self.timeframes, timeframe, timeframe)
@@ -849,7 +849,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if limit is not None:
@@ -1037,7 +1037,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if limit is not None:
@@ -1120,7 +1120,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.swapV2PublicGetQuotePremiumIndex(self.extend(request, params))
@@ -1216,7 +1216,7 @@ class bingx(Exchange, ImplicitAPI):
         if paginate:
             return self.fetch_paginated_call_deterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params)
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if since is not None:
@@ -1269,7 +1269,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.swapV2PublicGetQuoteOpenInterest(self.extend(request, params))
@@ -1321,7 +1321,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = None
@@ -1346,7 +1346,8 @@ class bingx(Exchange, ImplicitAPI):
         if symbols is not None:
             symbols = self.market_symbols(symbols)
             firstSymbol = self.safe_string(symbols, 0)
-            market = self.market(firstSymbol)
+            if firstSymbol is not None:
+                market = self.market(firstSymbol)
         type = None
         type, params = self.handle_market_type_and_params('fetchTickers', market, params)
         response = None
@@ -1357,7 +1358,7 @@ class bingx(Exchange, ImplicitAPI):
         tickers = self.safe_value(response, 'data')
         return self.parse_tickers(tickers, symbols)
 
-    def parse_ticker(self, ticker, market: Market = None) -> Ticker:
+    def parse_ticker(self, ticker: dict, market: Market = None) -> Ticker:
         #
         # spot
         #    {
@@ -1715,7 +1716,7 @@ class bingx(Exchange, ImplicitAPI):
         marketType = None
         marketType, params = self.handle_market_type_and_params('createOrder', market, params)
         type = type.upper()
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'type': type,
             'side': side.upper(),
@@ -1814,7 +1815,7 @@ class bingx(Exchange, ImplicitAPI):
                     slTriggerPrice = self.safe_string_2(stopLoss, 'triggerPrice', 'stopPrice', stopLoss)
                     slWorkingType = self.safe_string(stopLoss, 'workingType', 'MARK_PRICE')
                     slType = self.safe_string(stopLoss, 'type', 'STOP_MARKET')
-                    slRequest = {
+                    slRequest: dict = {
                         'stopPrice': self.parse_to_numeric(self.price_to_precision(symbol, slTriggerPrice)),
                         'workingType': slWorkingType,
                         'type': slType,
@@ -1829,7 +1830,7 @@ class bingx(Exchange, ImplicitAPI):
                     tkTriggerPrice = self.safe_string_2(takeProfit, 'triggerPrice', 'stopPrice', takeProfit)
                     tkWorkingType = self.safe_string(takeProfit, 'workingType', 'MARK_PRICE')
                     tpType = self.safe_string(takeProfit, 'type', 'TAKE_PROFIT_MARKET')
-                    tpRequest = {
+                    tpRequest: dict = {
                         'stopPrice': self.parse_to_numeric(self.price_to_precision(symbol, tkTriggerPrice)),
                         'workingType': tkWorkingType,
                         'type': tpType,
@@ -1960,7 +1961,7 @@ class bingx(Exchange, ImplicitAPI):
             orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams)
             ordersRequests.append(orderRequest)
         market = self.market(symbol)
-        request = {}
+        request: dict = {}
         response = None
         if market['swap']:
             request['batchOrders'] = self.json(ordersRequests)
@@ -2334,7 +2335,7 @@ class bingx(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' cancelOrder() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         clientOrderId = self.safe_string_2(params, 'clientOrderId', 'clientOrderID')
@@ -2412,7 +2413,7 @@ class bingx(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' cancelAllOrders() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = None
@@ -2490,7 +2491,7 @@ class bingx(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' cancelOrders() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         clientOrderIds = self.safe_value(params, 'clientOrderIds')
@@ -2559,7 +2560,7 @@ class bingx(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchOrders() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'orderId': id,
         }
@@ -2637,7 +2638,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = None
-        request = {}
+        request: dict = {}
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
@@ -2724,7 +2725,7 @@ class bingx(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchClosedOrders() requires a symbol argument')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = None
@@ -2812,7 +2813,7 @@ class bingx(Exchange, ImplicitAPI):
         accountsByType = self.safe_value(self.options, 'accountsByType', {})
         fromId = self.safe_string(accountsByType, fromAccount, fromAccount)
         toId = self.safe_string(accountsByType, toAccount, toAccount)
-        request = {
+        request: dict = {
             'asset': currency['id'],
             'amount': self.currency_to_precision(code, amount),
             'type': fromId + '_' + toId,
@@ -2856,7 +2857,7 @@ class bingx(Exchange, ImplicitAPI):
         toId = self.safe_string(accountsByType, toAccount, toAccount)
         if fromId is None or toId is None:
             raise ExchangeError(self.id + ' fromAccount & toAccount parameter are required')
-        request = {
+        request: dict = {
             'type': fromId + '_' + toId,
         }
         if since is not None:
@@ -2918,7 +2919,7 @@ class bingx(Exchange, ImplicitAPI):
         currency = self.currency(code)
         defaultRecvWindow = self.safe_integer(self.options, 'recvWindow')
         recvWindow = self.safe_integer(self.parse_params, 'recvWindow', defaultRecvWindow)
-        request = {
+        request: dict = {
             'coin': currency['id'],
             'offset': 0,
             'limit': 1000,
@@ -3007,7 +3008,7 @@ class bingx(Exchange, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
         }
         currency = None
         if code is not None:
@@ -3048,7 +3049,7 @@ class bingx(Exchange, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
         }
         currency = None
         if code is not None:
@@ -3173,7 +3174,7 @@ class bingx(Exchange, ImplicitAPI):
             'internal': None,
         }
 
-    def parse_transaction_status(self, status):
+    def parse_transaction_status(self, status: str):
         statuses = {
             '0': 'pending',
             '1': 'ok',
@@ -3212,7 +3213,7 @@ class bingx(Exchange, ImplicitAPI):
             marginMode = 'CROSSED'
         if marginMode != 'ISOLATED' and marginMode != 'CROSSED':
             raise BadRequest(self.id + ' setMarginMode() marginMode argument should be isolated or cross')
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'marginType': marginMode,
         }
@@ -3234,7 +3235,7 @@ class bingx(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' setMargin() requires a type parameter either 1(increase margin) or 2(decrease margin)')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'amount': self.amount_to_precision(market['symbol'], amount),
             'type': type,
@@ -3260,7 +3261,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.swapV2PrivateGetTradeLeverage(self.extend(request, params))
@@ -3292,7 +3293,7 @@ class bingx(Exchange, ImplicitAPI):
         self.check_required_argument('setLeverage', side, 'side', ['LONG', 'SHORT', 'BOTH'])
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'side': side,
             'leverage': leverage,
@@ -3328,7 +3329,7 @@ class bingx(Exchange, ImplicitAPI):
         market = self.market(symbol)
         now = self.milliseconds()
         response = None
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if since is not None:
@@ -3492,7 +3493,7 @@ class bingx(Exchange, ImplicitAPI):
             walletType = 1
         if not self.in_array(walletType, [1, 2, 3]):
             raise BadRequest(self.id + ' withdraw() requires either 1 fund account, 2 standard futures account, 3 perpetual account for walletType')
-        request = {
+        request: dict = {
             'coin': currency['id'],
             'address': address,
             'amount': self.number_to_string(amount),
@@ -3640,7 +3641,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.swapV2PrivatePostTradeCloseAllPositions(self.extend(request, params))
@@ -3674,7 +3675,7 @@ class bingx(Exchange, ImplicitAPI):
         marketType, params = self.handle_market_type_and_params('closeAllPositions', None, params)
         if marketType == 'margin':
             raise BadRequest(self.id + ' closePositions() cannot be used for ' + marketType + ' markets')
-        request = {
+        request: dict = {
             'recvWindow': recvWindow,
         }
         response = self.swapV2PrivatePostTradeCloseAllPositions(self.extend(request, params))
@@ -3739,7 +3740,7 @@ class bingx(Exchange, ImplicitAPI):
             dualSidePosition = 'true'
         else:
             dualSidePosition = 'false'
-        request = {
+        request: dict = {
             'dualSidePosition': dualSidePosition,
         }
         #
@@ -3928,7 +3929,7 @@ class bingx(Exchange, ImplicitAPI):
     def nonce(self):
         return self.milliseconds()
 
-    def set_sandbox_mode(self, enable):
+    def set_sandbox_mode(self, enable: bool):
         super(bingx, self).set_sandbox_mode(enable)
         self.options['sandboxMode'] = enable
 

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.55'
+__version__ = '4.2.56'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitget.py

@@ -96,7 +96,9 @@ class bitget(ccxt.async_support.bitget):
 
     def get_inst_type(self, market, params={}):
         instType = None
-        if (market['swap']) or (market['future']):
+        if market is None:
+            instType, params = self.handleProductTypeAndParams(None, params)
+        elif (market['swap']) or (market['future']):
             instType, params = self.handleProductTypeAndParams(market, params)
         else:
             instType = 'SPOT'
@@ -635,9 +637,12 @@ class bitget(ccxt.async_support.bitget):
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             stored = ArrayCache(limit)
             self.trades[symbol] = stored
-        data = self.safe_value(message, 'data', [])
-        for j in range(0, len(data)):
-            rawTrade = data[j]
+        data = self.safe_list(message, 'data', [])
+        length = len(data)
+        maxLength = max(length - 1, 0)
+        # fix chronological order by reversing
+        for i in range(maxLength, 0):
+            rawTrade = data[i]
             parsed = self.parse_ws_trade(rawTrade, market)
             stored.append(parsed)
         messageHash = 'trade:' + symbol
@@ -653,22 +658,69 @@ class bitget(ccxt.async_support.bitget):
         #         "tradeId": "1116461060594286593"
         #     }
         #
-        market = self.safe_market(None, market)
-        timestamp = self.safe_integer(trade, 'ts')
+        # order with trade in it
+        #     {
+        #         accBaseVolume: '0.1',
+        #         baseVolume: '0.1',
+        #         cTime: '1709221342922',
+        #         clientOid: '1147122943507734528',
+        #         enterPointSource: 'API',
+        #         feeDetail: [Array],
+        #         fillFee: '-0.0049578',
+        #         fillFeeCoin: 'USDT',
+        #         fillNotionalUsd: '8.263',
+        #         fillPrice: '82.63',
+        #         fillTime: '1709221342986',
+        #         force: 'gtc',
+        #         instId: 'LTCUSDT',
+        #         leverage: '10',
+        #         marginCoin: 'USDT',
+        #         marginMode: 'crossed',
+        #         notionalUsd: '8.268',
+        #         orderId: '1147122943499345921',
+        #         orderType: 'market',
+        #         pnl: '0',
+        #         posMode: 'hedge_mode',
+        #         posSide: 'short',
+        #         price: '0',
+        #         priceAvg: '82.63',
+        #         reduceOnly: 'no',
+        #         side: 'sell',
+        #         size: '0.1',
+        #         status: 'filled',
+        #         tradeId: '1147122943772479563',
+        #         tradeScope: 'T',
+        #         tradeSide: 'open',
+        #         uTime: '1709221342986'
+        #     }
+        #
+        instId = self.safe_string(trade, 'instId')
+        if market is None:
+            market = self.safe_market(instId, None, None, 'contract')
+        timestamp = self.safe_integer_n(trade, ['uTime', 'cTime', 'ts'])
+        feeCost = self.safe_string(trade, 'fillFee')
+        fee = None
+        if feeCost is not None:
+            feeCurrencyId = self.safe_string(trade, 'fillFeeCoin')
+            feeCurrencyCode = self.safe_currency_code(feeCurrencyId)
+            fee = {
+                'cost': Precise.string_abs(feeCost),
+                'currency': feeCurrencyCode,
+            }
         return self.safe_trade({
             'info': trade,
             'id': self.safe_string(trade, 'tradeId'),
-            'order': None,
+            'order': self.safe_string(trade, 'orderId'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'symbol': market['symbol'],
             'type': None,
             'side': self.safe_string(trade, 'side'),
             'takerOrMaker': None,
-            'price': self.safe_string(trade, 'price'),
+            'price': self.safe_string_2(trade, 'priceAvg', 'price'),
             'amount': self.safe_string(trade, 'size'),
-            'cost': None,
-            'fee': None,
+            'cost': self.safe_string(trade, 'fillNotionalUsd'),
+            'fee': fee,
         }, market)
 
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
@@ -1047,6 +1099,8 @@ class bitget(ccxt.async_support.bitget):
         marketSymbols = {}
         for i in range(0, len(data)):
             order = data[i]
+            if 'tradeId' in order:
+                self.handle_my_trades(client, order)
             marketId = self.safe_string(order, 'instId')
             market = self.safe_market(marketId, None, None, marketType)
             parsed = self.parse_ws_order(order, market)
@@ -1299,7 +1353,7 @@ class bitget(ccxt.async_support.bitget):
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             self.myTrades = ArrayCache(limit)
         stored = self.myTrades
-        parsed = self.parse_ws_my_trade(message)
+        parsed = self.parse_ws_trade(message)
         stored.append(parsed)
         symbol = parsed['symbol']
         messageHash = 'myTrades'
@@ -1307,67 +1361,6 @@ class bitget(ccxt.async_support.bitget):
         symbolSpecificMessageHash = 'myTrades:' + symbol
         client.resolve(stored, symbolSpecificMessageHash)
 
-    def parse_ws_my_trade(self, trade, market=None):
-        #
-        # order and trade mixin(contract)
-        #
-        #     {
-        #         "accBaseVolume": "0",
-        #         "cTime": "1701920553759",
-        #         "clientOid": "1116501214318198793",
-        #         "enterPointSource": "WEB",
-        #         "feeDetail": [{
-        #             "feeCoin": "USDT",
-        #             "fee": "-0.162003"
-        #         }],
-        #         "force": "gtc",
-        #         "instId": "BTCUSDT",
-        #         "leverage": "20",
-        #         "marginCoin": "USDT",
-        #         "marginMode": "isolated",
-        #         "notionalUsd": "105",
-        #         "orderId": "1116501214293032964",
-        #         "orderType": "limit",
-        #         "posMode": "hedge_mode",
-        #         "posSide": "long",
-        #         "price": "35000",
-        #         "reduceOnly": "no",
-        #         "side": "buy",
-        #         "size": "0.003",
-        #         "status": "canceled",
-        #         "tradeSide": "open",
-        #         "uTime": "1701920595866"
-        #     }
-        #
-        marketId = self.safe_string(trade, 'instId')
-        market = self.safe_market(marketId, market, None, 'contract')
-        timestamp = self.safe_integer_2(trade, 'uTime', 'cTime')
-        orderFee = self.safe_value(trade, 'feeDetail', [])
-        fee = self.safe_value(orderFee, 0)
-        feeAmount = self.safe_string(fee, 'fee')
-        feeObject = None
-        if feeAmount is not None:
-            feeCurrency = self.safe_string(fee, 'feeCoin')
-            feeObject = {
-                'cost': Precise.string_abs(feeAmount),
-                'currency': self.safe_currency_code(feeCurrency),
-            }
-        return self.safe_trade({
-            'info': trade,
-            'id': None,
-            'order': self.safe_string(trade, 'orderId'),
-            'timestamp': timestamp,
-            'datetime': self.iso8601(timestamp),
-            'symbol': market['symbol'],
-            'type': self.safe_string(trade, 'orderType'),
-            'side': self.safe_string(trade, 'side'),
-            'takerOrMaker': None,
-            'price': self.safe_string(trade, 'price'),
-            'amount': self.safe_string(trade, 'size'),
-            'cost': self.safe_string(trade, 'notionalUsd'),
-            'fee': feeObject,
-        }, market)
-
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders

ccxt/pro/bybit.py

@@ -324,15 +324,29 @@ class bybit(ccxt.async_support.bybit):
         #             "price24hPcnt": "-0.0388"
         #         }
         #     }
+        # swap delta
+        #     {
+        #         "topic":"tickers.AAVEUSDT",
+        #         "type":"delta",
+        #         "data":{
+        #            "symbol":"AAVEUSDT",
+        #            "bid1Price":"112.89",
+        #            "bid1Size":"2.12",
+        #            "ask1Price":"112.90",
+        #            "ask1Size":"5.02"
+        #         },
+        #         "cs":78039939929,
+        #         "ts":1709210212704
+        #     }
         #
         topic = self.safe_string(message, 'topic', '')
         updateType = self.safe_string(message, 'type', '')
-        data = self.safe_value(message, 'data', {})
-        isSpot = self.safe_string(data, 'fundingRate') is None
+        data = self.safe_dict(message, 'data', {})
+        isSpot = self.safe_string(data, 'usdIndexPrice') is not None
         type = 'spot' if isSpot else 'contract'
         symbol = None
         parsed = None
-        if (updateType == 'snapshot') or isSpot:
+        if (updateType == 'snapshot'):
             parsed = self.parse_ticker(data)
             symbol = parsed['symbol']
         elif updateType == 'delta':
@@ -342,8 +356,8 @@ class bybit(ccxt.async_support.bybit):
             market = self.safe_market(marketId, None, None, type)
             symbol = market['symbol']
             # update the info in place
-            ticker = self.safe_value(self.tickers, symbol, {})
-            rawTicker = self.safe_value(ticker, 'info', {})
+            ticker = self.safe_dict(self.tickers, symbol, {})
+            rawTicker = self.safe_dict(ticker, 'info', {})
             merged = self.extend(rawTicker, data)
             parsed = self.parse_ticker(merged)
         timestamp = self.safe_integer(message, 'ts')

ccxt/pro/currencycom.py

@@ -96,7 +96,7 @@ class currencycom(ccxt.async_support.currencycom):
         #                     "accountId": 5470310874305732,
         #                     "collateralCurrency": True,
         #                     "asset": "USD",
-        #                     "free": 47.82576735,
+        #                     "free": 47.82576736,
         #                     "locked": 1.187925,
         #                     "default": True
         #                 },
@@ -445,6 +445,7 @@ class currencycom(ccxt.async_support.currencycom):
         if orderbook is None:
             orderbook = self.order_book()
         orderbook.reset({
+            'symbol': symbol,
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
         })

ccxt/pro/kraken.py

@@ -361,7 +361,7 @@ class kraken(ccxt.async_support.kraken):
         #     [
         #         0,  # channelID
         #         [ #     price        volume         time             side type misc
-        #             ["5541.20000", "0.15850568", "1534614057.321597", "s", "l", ""],
+        #             ["5541.20000", "0.15850568", "1534614057.321596", "s", "l", ""],
         #             ["6060.00000", "0.02455000", "1534614057.324998", "b", "l", ""],
         #         ],
         #         "trade",

ccxt/upbit.py

@@ -604,7 +604,7 @@ class upbit(Exchange, ImplicitAPI):
         #                    "trade_time": "104543",
         #                "trade_date_kst": "20181122",
         #                "trade_time_kst": "194543",
-        #               "trade_timestamp":  1542883543097,
+        #               "trade_timestamp":  1542883543096,
         #                 "opening_price":  0.02976455,
         #                    "high_price":  0.02992577,
         #                     "low_price":  0.02934283,

ccxt/woo.py

@@ -106,6 +106,7 @@ class woo(Exchange, ImplicitAPI):
                 'reduceMargin': False,
                 'setLeverage': True,
                 'setMargin': False,
+                'setPositionMode': True,
                 'transfer': True,
                 'withdraw': True,  # exchange have that endpoint disabled atm, but was once implemented in ccxt per old docs: https://kronosresearch.github.io/wootrade-documents/#token-withdraw
             },
@@ -180,10 +181,16 @@ class woo(Exchange, ImplicitAPI):
                             'client/trade/{tid}': 1,
                             'order/{oid}/trades': 1,
                             'client/trades': 1,
+                            'client/hist_trades': 1,
+                            'staking/yield_history': 1,
+                            'client/holding': 1,
                             'asset/deposit': 10,
                             'asset/history': 60,
                             'sub_account/all': 60,
                             'sub_account/assets': 60,
+                            'sub_account/asset_detail': 60,
+                            'sub_account/ip_restriction': 10,
+                            'asset/main_sub_transfer_history': 30,
                             'token_interest': 60,
                             'token_interest/{token}': 60,
                             'interest/history': 60,
@@ -196,9 +203,12 @@ class woo(Exchange, ImplicitAPI):
                         'post': {
                             'order': 5,  # 2 requests per 1 second per symbol
                             'asset/main_sub_transfer': 30,  # 20 requests per 60 seconds
+                            'asset/ltv': 30,
                             'asset/withdraw': 30,  # implemented in ccxt, disabled on the exchange side https://kronosresearch.github.io/wootrade-documents/#token-withdraw
+                            'asset/internal_withdraw': 30,
                             'interest/repay': 60,
                             'client/account_mode': 120,
+                            'client/position_mode': 5,
                             'client/leverage': 120,
                         },
                         'delete': {
@@ -2434,6 +2444,33 @@ class woo(Exchange, ImplicitAPI):
         sorted = self.sort_by(rates, 'timestamp')
         return self.filter_by_symbol_since_limit(sorted, symbol, since, limit)
 
+    def set_position_mode(self, hedged: bool, symbol: Str = None, params={}):
+        """
+        set hedged to True or False for a market
+        :see: https://docs.woo.org/#update-position-mode
+        :param bool hedged: set to True to use HEDGE_MODE, False for ONE_WAY
+        :param str symbol: not used by woo setPositionMode
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: response from the exchange
+        """
+        hedgeMode = None
+        if hedged:
+            hedgeMode = 'HEDGE_MODE'
+        else:
+            hedgeMode = 'ONE_WAY'
+        request = {
+            'position_mode': hedgeMode,
+        }
+        response = self.v1PrivatePostClientPositionMode(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {},
+        #         "timestamp": "1709195608551"
+        #     }
+        #
+        return response
+
     def fetch_leverage(self, symbol: str, params={}):
         self.load_markets()
         response = self.v3PrivateGetAccountinfo(params)