ccxt 4.4.93__py2.py3-none-any.whl → 4.4.95__py2.py3-none-any.whl

ccxt/async_support/woo.py

@@ -7,7 +7,7 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.woo import ImplicitAPI
 import asyncio
 import hashlib
-from ccxt.base.types import Account, Any, Balances, Bool, Conversion, Currencies, Currency, DepositAddress, Int, LedgerEntry, Leverage, MarginModification, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Account, Any, Balances, Bool, Conversion, Currencies, Currency, DepositAddress, Int, LedgerEntry, Leverage, MarginModification, Market, MarketType, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, FundingRate, FundingRates, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -113,7 +113,7 @@ class woo(Exchange, ImplicitAPI):
                 'fetchTickers': False,
                 'fetchTime': True,
                 'fetchTrades': True,
-                'fetchTradingFee': False,
+                'fetchTradingFee': True,
                 'fetchTradingFees': True,
                 'fetchTransactions': 'emulated',
                 'fetchTransfers': True,
@@ -249,19 +249,56 @@ class woo(Exchange, ImplicitAPI):
                 'v3': {
                     'public': {
                         'get': {
-                            'insuranceFund': 3,
+                            'systemInfo': 1,  # 10/1s
+                            'instruments': 1,  # 10/1s
+                            'token': 1,  # 10/1s
+                            'tokenNetwork': 1,  # 10/1s
+                            'tokenInfo': 1,  # 10/1s
+                            'marketTrades': 1,  # 10/1s
+                            'marketTradesHistory': 1,  # 10/1s
+                            'orderbook': 1,  # 10/1s
+                            'kline': 1,  # 10/1s
+                            'klineHistory': 1,  # 10/1s
+                            'futures': 1,  # 10/1s
+                            'fundingRate': 1,  # 10/1s
+                            'fundingRateHistory': 1,  # 10/1s
+                            'insuranceFund': 1,  # 10/1s
                         },
                     },
                     'private': {
                         'get': {
+                            'trade/order': 2,  # 5/1s
+                            'trade/orders': 1,  # 10/1s
+                            'trade/algoOrder': 1,  # 10/1s
+                            'trade/algoOrders': 1,  # 10/1s
+                            'trade/transaction': 1,  # 10/1s
+                            'trade/transactionHistory': 5,  # 2/1s
+                            'trade/tradingFee': 5,  # 2/1s
+                            'account/info': 60,  # 10/60s
+                            'account/tokenConfig': 1,  # 10/1s
+                            'account/symbolConfig': 1,  # 10/1s
+                            'account/subAccounts/all': 60,  # 10/60s
+                            'account/referral/summary': 60,  # 10/60s
+                            'account/referral/rewardHistory': 60,  # 10/60s
+                            'account/credentials': 60,  # 10/60s
+                            'asset/balances': 1,  # 10/1s
+                            'asset/token/history': 60,  # 10/60s
+                            'asset/transfer/history': 30,  # 20/60s
+                            'asset/wallet/history': 60,  # 10/60s
+                            'asset/wallet/deposit': 60,  # 10/60s
+                            'asset/staking/yieldHistory': 60,  # 10/60s
+                            'futures/positions': 3.33,  # 30/10s
+                            'futures/leverage': 60,  # 10/60s
+                            'futures/defaultMarginMode': 60,  # 10/60s
+                            'futures/fundingFee/history': 30,  # 20/60s
+                            'spotMargin/interestRate': 60,  # 10/60s
+                            'spotMargin/interestHistory': 60,  # 10/60s
+                            'spotMargin/maxMargin': 60,  # 10/60s
                             'algo/order/{oid}': 1,
                             'algo/orders': 1,
                             'balances': 1,
-                            'accountinfo': 60,
                             'positions': 3.33,
                             'buypower': 1,
-                            'referrals': 60,
-                            'referral_rewards': 60,
                             'convert/exchangeInfo': 1,
                             'convert/assetInfo': 1,
                             'convert/rfq': 60,
@@ -269,16 +306,34 @@ class woo(Exchange, ImplicitAPI):
                             'convert/trades': 1,
                         },
                         'post': {
+                            'trade/order': 2,  # 5/1s
+                            'trade/algoOrder': 5,  # 2/1s
+                            'trade/cancelAllAfter': 1,  # 10/1s
+                            'account/tradingMode': 120,  # 5/60s
+                            'account/listenKey': 20,  # 5/10s
+                            'asset/transfer': 30,  # 20/60s
+                            'asset/wallet/withdraw': 60,  # 10/60s
+                            'spotMargin/leverage': 120,  # 5/60s
+                            'spotMargin/interestRepay': 60,  # 10/60s
                             'algo/order': 5,
                             'convert/rft': 60,
                         },
                         'put': {
+                            'trade/order': 2,  # 5/1s
+                            'trade/algoOrder': 2,  # 5/1s
+                            'futures/leverage': 60,  # 10/60s
+                            'futures/positionMode': 120,  # 5/60s
                             'order/{oid}': 2,
                             'order/client/{client_order_id}': 2,
                             'algo/order/{oid}': 2,
                             'algo/order/client/{client_order_id}': 2,
                         },
                         'delete': {
+                            'trade/order': 1,  # 10/1s
+                            'trade/orders': 1,  # 10/1s
+                            'trade/algoOrder': 1,  # 10/1s
+                            'trade/algoOrders': 1,  # 10/1s
+                            'trade/allOrders': 1,  # 10/1s
                             'algo/order/{order_id}': 1,
                             'algo/orders/pending': 1,
                             'algo/orders/pending/{symbol}': 1,
@@ -457,20 +512,21 @@ class woo(Exchange, ImplicitAPI):
         """
         the latest known information on the availability of the exchange API
 
-        https://docs.woox.io/#get-system-maintenance-status-public
+        https://developer.woox.io/api-reference/endpoint/public_data/systemInfo
 
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `status structure <https://docs.ccxt.com/#/?id=exchange-status-structure>`
         """
-        response = await self.v1PublicGetSystemInfo(params)
+        response = await self.v3PublicGetSystemInfo(params)
         #
         #     {
         #         "success": True,
         #         "data": {
-        #             "status": "0",
-        #             "msg": "System is functioning properly."
+        #             "status": 0,
+        #             "msg": "System is functioning properly.",
+        #             "estimatedEndTime": 1749963600362
         #         },
-        #         "timestamp": "1709274106602"
+        #         "timestamp": 1751442989564
         #     }
         #
         data = self.safe_dict(response, 'data', {})
@@ -493,20 +549,21 @@ class woo(Exchange, ImplicitAPI):
         """
         fetches the current integer timestamp in milliseconds from the exchange server
 
-        https://docs.woox.io/#get-system-maintenance-status-public
+        https://developer.woox.io/api-reference/endpoint/public_data/systemInfo
 
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns int: the current integer timestamp in milliseconds from the exchange server
         """
-        response = await self.v1PublicGetSystemInfo(params)
+        response = await self.v3PublicGetSystemInfo(params)
         #
         #     {
         #         "success": True,
         #         "data": {
-        #             "status": "0",
-        #             "msg": "System is functioning properly."
+        #             "status": 0,
+        #             "msg": "System is functioning properly.",
+        #             "estimatedEndTime": 1749963600362
         #         },
-        #         "timestamp": "1709274106602"
+        #         "timestamp": 1751442989564
         #     }
         #
         return self.safe_integer(response, 'timestamp')
@@ -515,37 +572,49 @@ class woo(Exchange, ImplicitAPI):
         """
         retrieves data on all markets for woo
 
-        https://docs.woox.io/#exchange-information
+        https://developer.woox.io/api-reference/endpoint/public_data/instruments
 
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
         if self.options['adjustForTimeDifference']:
             await self.load_time_difference()
-        response = await self.v1PublicGetInfo(params)
+        response = await self.v3PublicGetInstruments(params)
         #
-        # {
-        #     "rows": [
-        #         {
-        #             "symbol": "SPOT_AAVE_USDT",
-        #             "quote_min": 0,
-        #             "quote_max": 100000,
-        #             "quote_tick": 0.01,
-        #             "base_min": 0.01,
-        #             "base_max": 7284,
-        #             "base_tick": 0.0001,
-        #             "min_notional": 10,
-        #             "price_range": 0.1,
-        #             "created_time": "0",
-        #             "updated_time": "1639107647.988",
-        #             "is_stable": 0
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "symbol": "SPOT_AAVE_USDT",
+        #                     "status": "TRADING",
+        #                     "baseAsset": "AAVE",
+        #                     "baseAssetMultiplier": 1,
+        #                     "quoteAsset": "USDT",
+        #                     "quoteMin": "0",
+        #                     "quoteMax": "100000",
+        #                     "quoteTick": "0.01",
+        #                     "baseMin": "0.005",
+        #                     "baseMax": "5000",
+        #                     "baseTick": "0.0001",
+        #                     "minNotional": "1",
+        #                     "bidCapRatio": "1.1",
+        #                     "bidFloorRatio": null,
+        #                     "askCapRatio": null,
+        #                     "askFloorRatio": "0.9",
+        #                     "orderMode": "NORMAL",
+        #                     "impactNotional": null,
+        #                     "isAllowedRpi": False,
+        #                     "tickGranularity": null
+        #                 }
+        #             ]
         #         },
-        #         ...
-        #     "success": True
-        # }
+        #         "timestamp": 1751512951338
+        #     }
         #
-        data = self.safe_list(response, 'rows', [])
-        return self.parse_markets(data)
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'rows', [])
+        return self.parse_markets(rows)
 
     def parse_market(self, market: dict) -> Market:
         marketId = self.safe_string(market, 'symbol')
@@ -580,7 +649,7 @@ class woo(Exchange, ImplicitAPI):
             contractSize = self.parse_number('1')
             linear = True
             inverse = False
-        active = self.safe_string(market, 'is_trading') == '1'
+        active = self.safe_string(market, 'status') == 'TRADING'
         return {
             'id': marketId,
             'symbol': symbol,
@@ -606,8 +675,8 @@ class woo(Exchange, ImplicitAPI):
             'strike': None,
             'optionType': None,
             'precision': {
-                'amount': self.safe_number(market, 'base_tick'),
-                'price': self.safe_number(market, 'quote_tick'),
+                'amount': self.safe_number(market, 'baseTick'),
+                'price': self.safe_number(market, 'quoteTick'),
             },
             'limits': {
                 'leverage': {
@@ -615,19 +684,19 @@ class woo(Exchange, ImplicitAPI):
                     'max': None,
                 },
                 'amount': {
-                    'min': self.safe_number(market, 'base_min'),
-                    'max': self.safe_number(market, 'base_max'),
+                    'min': self.safe_number(market, 'baseMin'),
+                    'max': self.safe_number(market, 'baseMax'),
                 },
                 'price': {
-                    'min': self.safe_number(market, 'quote_min'),
-                    'max': self.safe_number(market, 'quote_max'),
+                    'min': self.safe_number(market, 'quoteMin'),
+                    'max': self.safe_number(market, 'quoteMax'),
                 },
                 'cost': {
-                    'min': self.safe_number(market, 'min_notional'),
+                    'min': self.safe_number(market, 'minNotional'),
                     'max': None,
                 },
             },
-            'created': self.safe_timestamp(market, 'created_time'),
+            'created': None,
             'info': market,
         }
 
@@ -635,7 +704,7 @@ class woo(Exchange, ImplicitAPI):
         """
         get the list of most recent trades for a particular symbol
 
-        https://docs.woox.io/#market-trades-public
+        https://developer.woox.io/api-reference/endpoint/public_data/marketTrades
 
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
@@ -650,38 +719,28 @@ class woo(Exchange, ImplicitAPI):
         }
         if limit is not None:
             request['limit'] = limit
-        response = await self.v1PublicGetMarketTrades(self.extend(request, params))
+        response = await self.v3PublicGetMarketTrades(self.extend(request, params))
         #
-        # {
-        #     "success": True,
-        #     "rows": [
-        #         {
-        #             "symbol": "SPOT_BTC_USDT",
-        #             "side": "SELL",
-        #             "executed_price": 46222.35,
-        #             "executed_quantity": 0.0012,
-        #             "executed_timestamp": "1641241162.329"
-        #         },
-        #         {
-        #             "symbol": "SPOT_BTC_USDT",
-        #             "side": "SELL",
-        #             "executed_price": 46222.35,
-        #             "executed_quantity": 0.0012,
-        #             "executed_timestamp": "1641241162.329"
-        #         },
-        #         {
-        #             "symbol": "SPOT_BTC_USDT",
-        #             "side": "BUY",
-        #             "executed_price": 46224.32,
-        #             "executed_quantity": 0.00039,
-        #             "executed_timestamp": "1641241162.287"
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "symbol": "SPOT_BTC_USDT",
+        #                     "side": "SELL",
+        #                     "source": 0,
+        #                     "executedPrice": "108741.01",
+        #                     "executedQuantity": "0.02477",
+        #                     "executedTimestamp": 1751513940144
+        #                 }
+        #             ]
         #         },
-        #         ...
-        #      ]
-        # }
+        #         "timestamp": 1751513988543
+        #     }
         #
-        resultResponse = self.safe_list(response, 'rows', [])
-        return self.parse_trades(resultResponse, market, since, limit)
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'rows', [])
+        return self.parse_trades(rows, market, since, limit)
 
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
@@ -690,36 +749,44 @@ class woo(Exchange, ImplicitAPI):
         #     {
         #         "symbol": "SPOT_BTC_USDT",
         #         "side": "SELL",
-        #         "executed_price": 46222.35,
-        #         "executed_quantity": 0.0012,
-        #         "executed_timestamp": "1641241162.329"
+        #         "source": 0,
+        #         "executedPrice": "108741.01",
+        #         "executedQuantity": "0.02477",
+        #         "executedTimestamp": 1751513940144
         #     }
         #
         # fetchOrderTrades, fetchOrder
         #
         #     {
-        #         "id": "99119876",
-        #         "symbol": "SPOT_WOO_USDT",
-        #         "fee": "0.0024",
+        #         "id": 1734947821,
+        #         "symbol": "SPOT_LTC_USDT",
+        #         "orderId": 60780383217,
+        #         "executedPrice": 87.86,
+        #         "executedQuantity": 0.1,
+        #         "fee": 0.0001,
+        #         "realizedPnl": null,
+        #         "feeAsset": "LTC",
+        #         "orderTag": "default",
         #         "side": "BUY",
-        #         "executed_timestamp": "1641481113.084",
-        #         "order_id": "87001234",
-        #         "order_tag": "default", <-- self param only in "fetchOrderTrades"
-        #         "executed_price": "1",
-        #         "executed_quantity": "12",
-        #         "fee_asset": "WOO",
-        #         "is_maker": "1"
+        #         "executedTimestamp": "1752055173.630",
+        #         "isMaker": 0
         #     }
         #
         isFromFetchOrder = ('id' in trade)
-        timestamp = self.safe_timestamp(trade, 'executed_timestamp')
+        timestampString = self.safe_string_2(trade, 'executed_timestamp', 'executedTimestamp')
+        timestamp = None
+        if timestampString is not None:
+            if timestampString.find('.') > -1:
+                timestamp = self.safe_timestamp_2(trade, 'executed_timestamp', 'executedTimestamp')
+            else:
+                timestamp = self.safe_integer(trade, 'executedTimestamp')
         marketId = self.safe_string(trade, 'symbol')
         market = self.safe_market(marketId, market)
         symbol = market['symbol']
-        price = self.safe_string(trade, 'executed_price')
-        amount = self.safe_string(trade, 'executed_quantity')
-        order_id = self.safe_string(trade, 'order_id')
-        fee = self.parse_token_and_fee_temp(trade, 'fee_asset', 'fee')
+        price = self.safe_string_2(trade, 'executed_price', 'executedPrice')
+        amount = self.safe_string_2(trade, 'executed_quantity', 'executedQuantity')
+        order_id = self.safe_string_2(trade, 'order_id', 'orderId')
+        fee = self.parse_token_and_fee_temp(trade, ['fee_asset', 'feeAsset'], ['fee'])
         feeCost = self.safe_string(fee, 'cost')
         if feeCost is not None:
             fee['cost'] = feeCost
@@ -728,7 +795,7 @@ class woo(Exchange, ImplicitAPI):
         id = self.safe_string(trade, 'id')
         takerOrMaker: Str = None
         if isFromFetchOrder:
-            isMaker = self.safe_string(trade, 'is_maker') == '1'
+            isMaker = self.safe_string_2(trade, 'is_maker', 'isMaker') == '1'
             takerOrMaker = 'maker' if isMaker else 'taker'
         return self.safe_trade({
             'id': id,
@@ -746,11 +813,11 @@ class woo(Exchange, ImplicitAPI):
             'info': trade,
         }, market)
 
-    def parse_token_and_fee_temp(self, item, feeTokenKey, feeAmountKey):
-        feeCost = self.safe_string(item, feeAmountKey)
+    def parse_token_and_fee_temp(self, item, feeTokenKeys, feeAmountKeys):
+        feeCost = self.safe_string_n(item, feeAmountKeys)
         fee = None
         if feeCost is not None:
-            feeCurrencyId = self.safe_string(item, feeTokenKey)
+            feeCurrencyId = self.safe_string_n(item, feeTokenKeys)
             feeCurrencyCode = self.safe_currency_code(feeCurrencyId)
             fee = {
                 'cost': feeCost,
@@ -758,43 +825,90 @@ class woo(Exchange, ImplicitAPI):
             }
         return fee
 
+    def parse_trading_fee(self, fee: dict, market: Market = None) -> TradingFeeInterface:
+        marketId = self.safe_string(fee, 'symbol')
+        symbol = self.safe_symbol(marketId, market)
+        return {
+            'info': fee,
+            'symbol': symbol,
+            'maker': self.parse_number(Precise.string_div(self.safe_string(fee, 'makerFee'), '100')),
+            'taker': self.parse_number(Precise.string_div(self.safe_string(fee, 'takerFee'), '100')),
+            'percentage': None,
+            'tierBased': None,
+        }
+
+    async def fetch_trading_fee(self, symbol: str, params={}) -> TradingFeeInterface:
+        """
+        fetch the trading fees for a market
+
+        https://developer.woox.io/api-reference/endpoint/trading/get_tradingFee
+
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.portfolioMargin]: set to True if you would like to fetch trading fees in a portfolio margin account
+        :param str [params.subType]: "linear" or "inverse"
+        :returns dict: a `fee structure <https://docs.ccxt.com/#/?id=fee-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'symbol': market['id'],
+        }
+        response = await self.v3PrivateGetTradeTradingFee(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "symbol": "SPOT_BTC_USDT",
+        #             "takerFee": "10",
+        #             "makerFee": "8"
+        #         },
+        #         "timestamp": 1751858977368
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        return self.parse_trading_fee(data, market)
+
     async def fetch_trading_fees(self, params={}) -> TradingFees:
         """
         fetch the trading fees for multiple markets
 
-        https://docs.woox.io/#get-account-information-new
+        https://developer.woox.io/api-reference/endpoint/account/get_account_info
 
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `fee structures <https://docs.ccxt.com/#/?id=fee-structure>` indexed by market symbols
         """
         await self.load_markets()
-        response = await self.v3PrivateGetAccountinfo(params)
+        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,
+        #             "applicationId": "251bf5c4-f3c8-4544-bb8b-80001007c3c0",
+        #             "account": "carlos_jose_lima@yahoo.com",
+        #             "alias": "carlos_jose_lima@yahoo.com",
         #             "otpauth": True,
-        #             "marginRatio": 1,
-        #             "openMarginRatio": 1,
-        #             "initialMarginRatio": 1,
-        #             "maintenanceMarginRatio": 1,
-        #             "totalCollateral": 1,
-        #             "freeCollateral": 1,
-        #             "totalAccountValue": 1,
-        #             "totalVaultValue": 1,
-        #             "totalStakingValue": 1
+        #             "accountMode": "FUTURES",
+        #             "positionMode": "ONE_WAY",
+        #             "leverage": 0,
+        #             "makerFeeRate": 0,
+        #             "takerFeeRate": 0,
+        #             "marginRatio": "10",
+        #             "openMarginRatio": "10",
+        #             "initialMarginRatio": "10",
+        #             "maintenanceMarginRatio": "0.03",
+        #             "totalCollateral": "165.55629469",
+        #             "freeCollateral": "165.55629469",
+        #             "totalAccountValue": "167.32418611",
+        #             "totalTradingValue": "167.32418611",
+        #             "totalVaultValue": "0",
+        #             "totalStakingValue": "0",
+        #             "totalLaunchpadValue": "0",
+        #             "totalEarnValue": "0",
+        #             "referrerID": null,
+        #             "accountType": "Main"
         #         },
-        #         "timestamp": 1673323685109
+        #         "timestamp": 1752062807915
         #     }
         #
         data = self.safe_dict(response, 'data', {})
@@ -1049,8 +1163,8 @@ class woo(Exchange, ImplicitAPI):
         """
         create a trade order
 
-        https://docs.woox.io/#send-order
-        https://docs.woox.io/#send-algo-order
+        https://developer.woox.io/api-reference/endpoint/trading/post_order
+        https://developer.woox.io/api-reference/endpoint/trading/post_algo_order
 
         :param str symbol: unified symbol of the market to create an order in
         :param str type: 'market' or 'limit'
@@ -1085,7 +1199,7 @@ class woo(Exchange, ImplicitAPI):
         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)
+            request['marginMode'] = self.encode_margin_mode(marginMode)
         triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
         stopLoss = self.safe_value(params, 'stopLoss')
         takeProfit = self.safe_value(params, 'takeProfit')
@@ -1100,27 +1214,23 @@ class woo(Exchange, ImplicitAPI):
         isMarket = orderType == 'MARKET'
         timeInForce = self.safe_string_lower(params, 'timeInForce')
         postOnly = self.is_post_only(isMarket, None, params)
-        reduceOnlyKey = 'reduceOnly' if isConditional else 'reduce_only'
-        clientOrderIdKey = 'clientOrderId' if isConditional else 'client_order_id'
-        orderQtyKey = 'quantity' if isConditional else 'order_quantity'
-        priceKey = 'price' if isConditional else 'order_price'
-        typeKey = 'type' if isConditional else 'order_type'
-        request[typeKey] = orderType  # LIMIT/MARKET/IOC/FOK/POST_ONLY/ASK/BID
+        clientOrderIdKey = 'clientAlgoOrderId' if isConditional else 'clientOrderId'
+        request['type'] = orderType  # LIMIT/MARKET/IOC/FOK/POST_ONLY/ASK/BID
         if not isConditional:
             if postOnly:
-                request['order_type'] = 'POST_ONLY'
+                request['type'] = 'POST_ONLY'
             elif timeInForce == 'fok':
-                request['order_type'] = 'FOK'
+                request['type'] = 'FOK'
             elif timeInForce == 'ioc':
-                request['order_type'] = 'IOC'
+                request['type'] = 'IOC'
         if reduceOnly:
-            request[reduceOnlyKey] = reduceOnly
+            request['reduceOnly'] = reduceOnly
         if not isMarket and price is not None:
-            request[priceKey] = self.price_to_precision(symbol, price)
+            request['price'] = self.price_to_precision(symbol, price)
         if isMarket and not isConditional:
             # for market buy it requires the amount of quote currency to spend
-            cost = self.safe_string_2(params, 'cost', 'order_amount')
-            params = self.omit(params, ['cost', 'order_amount'])
+            cost = self.safe_string_n(params, ['cost', 'order_amount', 'orderAmount'])
+            params = self.omit(params, ['cost', 'order_amount', 'orderAmount'])
             isPriceProvided = price is not None
             if market['spot'] and (isPriceProvided or (cost is not None)):
                 quoteAmount = None
@@ -1131,11 +1241,11 @@ class woo(Exchange, ImplicitAPI):
                     priceString = self.number_to_string(price)
                     costRequest = Precise.string_mul(amountString, priceString)
                     quoteAmount = self.cost_to_precision(symbol, costRequest)
-                request['order_amount'] = quoteAmount
+                request['amount'] = quoteAmount
             else:
-                request['order_quantity'] = self.amount_to_precision(symbol, amount)
+                request['quantity'] = self.amount_to_precision(symbol, amount)
         elif algoType != 'POSITIONAL_TP_SL':
-            request[orderQtyKey] = self.amount_to_precision(symbol, amount)
+            request['quantity'] = self.amount_to_precision(symbol, amount)
         clientOrderId = self.safe_string_n(params, ['clOrdID', 'clientOrderId', 'client_order_id'])
         if clientOrderId is not None:
             request[clientOrderIdKey] = clientOrderId
@@ -1187,41 +1297,44 @@ class woo(Exchange, ImplicitAPI):
         params = self.omit(params, ['clOrdID', 'clientOrderId', 'client_order_id', 'postOnly', 'timeInForce', 'stopPrice', 'triggerPrice', 'stopLoss', 'takeProfit', 'trailingPercent', 'trailingAmount', 'trailingTriggerPrice'])
         response = None
         if isConditional:
-            response = await self.v3PrivatePostAlgoOrder(self.extend(request, params))
+            response = await self.v3PrivatePostTradeAlgoOrder(self.extend(request, params))
+            #
+            # {
+            #     "success": True,
+            #     "data": {
+            #       "rows": [
+            #         {
+            #           "orderId": "1578938",
+            #           "clientOrderId": "0",
+            #           "algoType": "STOP_LOSS",
+            #           "quantity": "0.1"
+            #         }
+            #       ]
+            #     },
+            #     "timestamp": "1686149372216"
+            # }
+            #
         else:
-            response = await self.v1PrivatePostOrder(self.extend(request, params))
-        # {
-        #     "success": True,
-        #     "timestamp": "1641383206.489",
-        #     "order_id": "86980774",
-        #     "order_type": "LIMIT",
-        #     "order_price": "1",  # null for "MARKET" order
-        #     "order_quantity": "12",  # null for "MARKET" order
-        #     "order_amount": null,  # NOT-null for "MARKET" order
-        #     "client_order_id": "0"
-        # }
-        # stop orders
-        # {
-        #     "success": True,
-        #     "data": {
-        #       "rows": [
-        #         {
-        #           "orderId": "1578938",
-        #           "clientOrderId": "0",
-        #           "algoType": "STOP_LOSS",
-        #           "quantity": "0.1"
-        #         }
-        #       ]
-        #     },
-        #     "timestamp": "1686149372216"
-        # }
-        data = self.safe_dict(response, 'data')
-        if data is not None:
-            rows = self.safe_list(data, 'rows', [])
-            return self.parse_order(rows[0], market)
-        order = self.parse_order(response, market)
-        order['type'] = type
-        return order
+            response = await self.v3PrivatePostTradeOrder(self.extend(request, params))
+            #
+            #     {
+            #         "success": True,
+            #         "data": {
+            #             "orderId": 60667653330,
+            #             "clientOrderId": 0,
+            #             "type": "LIMIT",
+            #             "price": 60,
+            #             "quantity": 0.1,
+            #             "amount": null,
+            #             "bidAskLevel": null
+            #         },
+            #         "timestamp": 1751871779855
+            #     }
+            #
+        data = self.safe_dict(response, 'data', {})
+        data = self.safe_dict(self.safe_list(data, 'rows'), 0, data)
+        data['timestamp'] = self.safe_string(response, 'timestamp')
+        return self.parse_order(data, market)
 
     def encode_margin_mode(self, mode):
         modes = {
@@ -1317,9 +1430,8 @@ class woo(Exchange, ImplicitAPI):
     async def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
 
-        https://docs.woox.io/#cancel-algo-order
-        https://docs.woox.io/#cancel-order
-        https://docs.woox.io/#cancel-order-by-client_order_id
+        https://developer.woox.io/api-reference/endpoint/trading/cancel_order
+        https://developer.woox.io/api-reference/endpoint/trading/cancel_algo_order
 
         cancels an open order
         :param str id: order id
@@ -1339,36 +1451,44 @@ class woo(Exchange, ImplicitAPI):
         request: dict = {}
         clientOrderIdUnified = self.safe_string_2(params, 'clOrdID', 'clientOrderId')
         clientOrderIdExchangeSpecific = self.safe_string(params, 'client_order_id', clientOrderIdUnified)
+        params = self.omit(params, ['clOrdID', 'clientOrderId', 'client_order_id'])
         isByClientOrder = clientOrderIdExchangeSpecific is not None
         response = None
         if isTrigger:
-            request['order_id'] = id
-            response = await self.v3PrivateDeleteAlgoOrderOrderId(self.extend(request, params))
+            if isByClientOrder:
+                request['clientAlgoOrderId'] = clientOrderIdExchangeSpecific
+            else:
+                request['algoOrderId'] = id
+            response = await self.v3PrivateDeleteTradeAlgoOrder(self.extend(request, params))
         else:
             request['symbol'] = market['id']
             if isByClientOrder:
-                request['client_order_id'] = clientOrderIdExchangeSpecific
-                params = self.omit(params, ['clOrdID', 'clientOrderId', 'client_order_id'])
-                response = await self.v1PrivateDeleteClientOrder(self.extend(request, params))
+                request['clientOrderId'] = clientOrderIdExchangeSpecific
             else:
-                request['order_id'] = id
-                response = await self.v1PrivateDeleteOrder(self.extend(request, params))
+                request['orderId'] = id
+            response = await self.v3PrivateDeleteTradeOrder(self.extend(request, params))
         #
-        # {success: True, status: "CANCEL_SENT"}
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "status": "CANCEL_SENT"
+        #         },
+        #         "timestamp": 1751940315838
+        #     }
         #
-        extendParams: dict = {'symbol': symbol}
+        data = self.safe_dict(response, 'data', {})
+        data['timestamp'] = self.safe_string(response, 'timestamp')
         if isByClientOrder:
-            extendParams['client_order_id'] = clientOrderIdExchangeSpecific
+            data['clientOrderId'] = clientOrderIdExchangeSpecific
         else:
-            extendParams['id'] = id
-        return self.extend(self.parse_order(response), extendParams)
+            data['orderId'] = id
+        return self.parse_order(data, market)
 
     async def cancel_all_orders(self, symbol: Str = None, params={}):
         """
 
-        https://docs.woox.io/#cancel-all-pending-orders
-        https://docs.woox.io/#cancel-orders
-        https://docs.woox.io/#cancel-all-pending-algo-orders
+        https://developer.woox.io/api-reference/endpoint/trading/cancel_all_order
+        https://developer.woox.io/api-reference/endpoint/trading/cancel_algo_orders
 
         cancel all open orders in a market
         :param str symbol: unified market symbol
@@ -1379,30 +1499,28 @@ class woo(Exchange, ImplicitAPI):
         await self.load_markets()
         trigger = self.safe_bool_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
+        request: dict = {}
+        if symbol is not None:
+            market = self.market(symbol)
+            request['symbol'] = market['id']
         if trigger:
-            return await self.v3PrivateDeleteAlgoOrdersPending(params)
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' cancelOrders() requires a symbol argument')
-        market = self.market(symbol)
-        request: dict = {
-            'symbol': market['id'],
-        }
-        response = await self.v1PrivateDeleteOrders(self.extend(request, params))
+            return await self.v3PrivateDeleteTradeAlgoOrders(params)
         #
         #     {
-        #         "success":true,
-        #         "status":"CANCEL_ALL_SENT"
+        #         "success": True,
+        #         "data": {
+        #             "status": "CANCEL_ALL_SENT"
+        #         },
+        #         "timestamp": 1751941988134
         #     }
         #
-        return [
-            self.safe_order(response),
-        ]
+        return await self.v3PrivateDeleteTradeOrders(self.extend(request, params))
 
     async def cancel_all_orders_after(self, timeout: Int, params={}):
         """
         dead man's switch, cancel all orders after the given timeout
 
-        https://docs.woox.io/#cancel-all-after
+        https://developer.woox.io/api-reference/endpoint/trading/cancel_all_after
 
         :param number timeout: time in milliseconds, 0 represents cancel the timer
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1410,27 +1528,25 @@ class woo(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         request: dict = {
-            'trigger_after': timeout if (timeout > 0) else 0,
+            'triggerAfter': min(timeout, 900000) if (timeout > 0) else 0,
         }
-        response = await self.v1PrivatePostOrderCancelAllAfter(self.extend(request, params))
+        response = await self.v3PrivatePostTradeCancelAllAfter(self.extend(request, params))
         #
-        #     {
-        #         "success": True,
-        #         "data": {
-        #             "expected_trigger_time": 1711534302938
-        #         },
-        #         "timestamp": 1711534302943
+        # {
+        #     "success": True,
+        #     "timestamp": 123,
+        #     "data": {
+        #         "expectedTriggerTime": 123
         #     }
+        # }
         #
-        return [
-            self.safe_order(response),
-        ]
+        return response
 
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
 
-        https://docs.woox.io/#get-algo-order
-        https://docs.woox.io/#get-order
+        https://developer.woox.io/api-reference/endpoint/trading/get_order
+        https://developer.woox.io/api-reference/endpoint/trading/get_algo_order
 
         fetches information on an order made by the user
         :param str id: the order id
@@ -1440,65 +1556,102 @@ class woo(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        market = self.market(symbol) if (symbol is not None) else None
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
         trigger = self.safe_bool_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
         request: dict = {}
         clientOrderId = self.safe_string_2(params, 'clOrdID', 'clientOrderId')
         response = None
         if trigger:
-            request['oid'] = id
-            response = await self.v3PrivateGetAlgoOrderOid(self.extend(request, params))
-        elif clientOrderId:
-            request['client_order_id'] = clientOrderId
-            response = await self.v1PrivateGetClientOrderClientOrderId(self.extend(request, params))
+            if clientOrderId is not None:
+                request['clientAlgoOrderId'] = id
+            else:
+                request['algoOrderId'] = id
+            response = await self.v3PrivateGetTradeAlgoOrder(self.extend(request, params))
+            #
+            #     {
+            #         "success": True,
+            #         "data": {
+            #             "algoOrderId": 10399260,
+            #             "clientAlgoOrderId": 0,
+            #             "rootAlgoOrderId": 10399260,
+            #             "parentAlgoOrderId": 0,
+            #             "symbol": "SPOT_LTC_USDT",
+            #             "algoOrderTag": "default",
+            #             "algoType": "TAKE_PROFIT",
+            #             "side": "BUY",
+            #             "quantity": 0.1,
+            #             "isTriggered": False,
+            #             "triggerPrice": 65,
+            #             "triggerStatus": "USELESS",
+            #             "type": "LIMIT",
+            #             "rootAlgoStatus": "NEW",
+            #             "algoStatus": "NEW",
+            #             "triggerPriceType": "MARKET_PRICE",
+            #             "price": 60,
+            #             "triggerTime": "0",
+            #             "totalExecutedQuantity": 0,
+            #             "visibleQuantity": 0.1,
+            #             "averageExecutedPrice": 0,
+            #             "totalFee": 0,
+            #             "feeAsset": "",
+            #             "totalRebate": 0,
+            #             "rebateAsset": "",
+            #             "reduceOnly": False,
+            #             "createdTime": "1752049747.732",
+            #             "updatedTime": "1752049747.732",
+            #             "positionSide": "BOTH"
+            #         },
+            #         "timestamp": 1752049767550
+            #     }
+            #
         else:
-            request['oid'] = id
-            response = await self.v1PrivateGetOrderOid(self.extend(request, params))
-        #
-        # {
-        #     "success": True,
-        #     "symbol": "SPOT_WOO_USDT",
-        #     "status": "FILLED",  # FILLED, NEW
-        #     "side": "BUY",
-        #     "created_time": "1641480933.000",
-        #     "order_id": "87541111",
-        #     "order_tag": "default",
-        #     "price": "1",
-        #     "type": "LIMIT",
-        #     "quantity": "12",
-        #     "amount": null,
-        #     "visible": "12",
-        #     "executed": "12",  # or any partial amount
-        #     "total_fee": "0.0024",
-        #     "fee_asset": "WOO",
-        #     "client_order_id": null,
-        #     "average_executed_price": "1",
-        #     "Transactions": [
-        #       {
-        #         "id": "99111647",
-        #         "symbol": "SPOT_WOO_USDT",
-        #         "fee": "0.0024",
-        #         "side": "BUY",
-        #         "executed_timestamp": "1641482113.084",
-        #         "order_id": "87541111",
-        #         "executed_price": "1",
-        #         "executed_quantity": "12",
-        #         "fee_asset": "WOO",
-        #         "is_maker": "1"
-        #       }
-        #     ]
-        # }
-        #
-        orders = self.safe_dict(response, 'data', response)
-        return self.parse_order(orders, market)
+            if clientOrderId is not None:
+                request['clientOrderId'] = clientOrderId
+            else:
+                request['orderId'] = id
+            response = await self.v3PrivateGetTradeOrder(self.extend(request, params))
+            #
+            #     {
+            #         "success": True,
+            #         "data": {
+            #             "orderId": 60780315704,
+            #             "clientOrderId": 0,
+            #             "symbol": "SPOT_LTC_USDT",
+            #             "orderTag": "default",
+            #             "side": "BUY",
+            #             "quantity": 0.1,
+            #             "amount": null,
+            #             "type": "LIMIT",
+            #             "status": "NEW",
+            #             "price": 60,
+            #             "executed": 0,
+            #             "visible": 0.1,
+            #             "averageExecutedPrice": 0,
+            #             "totalFee": 0,
+            #             "feeAsset": "LTC",
+            #             "totalRebate": 0,
+            #             "rebateAsset": "USDT",
+            #             "reduceOnly": False,
+            #             "createdTime": "1752049062.496",
+            #             "realizedPnl": null,
+            #             "positionSide": "BOTH",
+            #             "bidAskLevel": null
+            #         },
+            #         "timestamp": 1752049393466
+            #     }
+            #
+        data = self.safe_dict(response, 'data', {})
+        return self.parse_order(data, market)
 
     async def fetch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetches information on multiple orders made by the user
 
-        https://docs.woox.io/#get-orders
-        https://docs.woox.io/#get-algo-orders
+        https://developer.woox.io/api-reference/endpoint/trading/get_orders
+        https://developer.woox.io/api-reference/endpoint/trading/get_algo_orders
 
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
@@ -1507,7 +1660,6 @@ class woo(Exchange, ImplicitAPI):
         :param boolean [params.trigger]: whether the order is a trigger/algo order
         :param boolean [params.isTriggered]: whether the order has been triggered(False by default)
         :param str [params.side]: 'buy' or 'sell'
-        :param boolean [params.trailing]: set to True if you want to fetch trailing orders
         :param boolean [params.paginate]: set to True if you want to fetch orders with pagination
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
@@ -1519,70 +1671,118 @@ class woo(Exchange, ImplicitAPI):
         request: dict = {}
         market: Market = None
         trigger = self.safe_bool_2(params, 'stop', 'trigger')
-        trailing = self.safe_bool(params, 'trailing', False)
-        params = self.omit(params, ['stop', 'trailing', 'trigger'])
+        params = self.omit(params, ['stop', 'trigger'])
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
         if since is not None:
-            if trigger or trailing:
-                request['createdTimeStart'] = since
-            else:
-                request['start_t'] = since
+            request['startTime'] = since
+        until = self.safe_integer(params, 'until')  # unified in milliseconds
+        params = self.omit(params, ['until'])
+        if until is not None:
+            request['endTime'] = until
         if limit is not None:
-            request['size'] = limit
-        else:
-            request['size'] = 50 if trailing else 500
-        if trigger:
-            request['algoType'] = 'stop'
-        elif trailing:
-            request['algoType'] = 'TRAILING_STOP'
+            request['size'] = min(limit, 500)
         response = None
-        if trigger or trailing:
-            response = await self.v3PrivateGetAlgoOrders(self.extend(request, params))
+        if trigger:
+            response = await self.v3PrivateGetTradeAlgoOrders(self.extend(request, params))
+            #
+            #     {
+            #         "success": True,
+            #         "data": {
+            #             "rows": [
+            #                 {
+            #                     "algoOrderId": 10399260,
+            #                     "clientAlgoOrderId": 0,
+            #                     "rootAlgoOrderId": 10399260,
+            #                     "parentAlgoOrderId": 0,
+            #                     "symbol": "SPOT_LTC_USDT",
+            #                     "algoOrderTag": "default",
+            #                     "algoType": "TAKE_PROFIT",
+            #                     "side": "BUY",
+            #                     "quantity": 0.1,
+            #                     "isTriggered": False,
+            #                     "triggerPrice": 65,
+            #                     "triggerStatus": "USELESS",
+            #                     "type": "LIMIT",
+            #                     "rootAlgoStatus": "NEW",
+            #                     "algoStatus": "NEW",
+            #                     "triggerPriceType": "MARKET_PRICE",
+            #                     "price": 60,
+            #                     "triggerTime": "0",
+            #                     "totalExecutedQuantity": 0,
+            #                     "visibleQuantity": 0.1,
+            #                     "averageExecutedPrice": 0,
+            #                     "totalFee": 0,
+            #                     "feeAsset": "",
+            #                     "totalRebate": 0,
+            #                     "rebateAsset": "",
+            #                     "reduceOnly": False,
+            #                     "createdTime": "1752049747.730",
+            #                     "updatedTime": "1752049747.730",
+            #                     "positionSide": "BOTH"
+            #                 }
+            #             ],
+            #             "meta": {
+            #                 "total": 7,
+            #                 "recordsPerPage": 1,
+            #                 "currentPage": 1
+            #             }
+            #         },
+            #         "timestamp": 1752053127448
+            #     }
+            #
         else:
-            response = await self.v1PrivateGetOrders(self.extend(request, params))
-        #
-        #     {
-        #         "success":true,
-        #         "meta":{
-        #             "total":1,
-        #             "records_per_page":100,
-        #             "current_page":1
-        #         },
-        #         "rows":[
-        #             {
-        #                 "symbol":"PERP_BTC_USDT",
-        #                 "status":"FILLED",
-        #                 "side":"SELL",
-        #                 "created_time":"1611617776.000",
-        #                 "updated_time":"1611617776.000",
-        #                 "order_id":52121167,
-        #                 "order_tag":"default",
-        #                 "price":null,
-        #                 "type":"MARKET",
-        #                 "quantity":0.002,
-        #                 "amount":null,
-        #                 "visible":0,
-        #                 "executed":0.002,
-        #                 "total_fee":0.01732885,
-        #                 "fee_asset":"USDT",
-        #                 "client_order_id":null,
-        #                 "average_executed_price":28881.41
-        #             }
-        #         ]
-        #     }
-        #
-        data = self.safe_value(response, 'data', response)
-        orders = self.safe_list(data, 'rows')
+            response = await self.v3PrivateGetTradeOrders(self.extend(request, params))
+            #
+            #     {
+            #         "success": True,
+            #         "data": {
+            #             "rows": [
+            #                 {
+            #                     "orderId": 60780315704,
+            #                     "clientOrderId": 0,
+            #                     "symbol": "SPOT_LTC_USDT",
+            #                     "orderTag": "default",
+            #                     "side": "BUY",
+            #                     "quantity": 0.1,
+            #                     "amount": null,
+            #                     "type": "LIMIT",
+            #                     "status": "NEW",
+            #                     "price": 60,
+            #                     "executed": 0,
+            #                     "visible": 0.1,
+            #                     "averageExecutedPrice": 0,
+            #                     "totalFee": 0,
+            #                     "feeAsset": "LTC",
+            #                     "totalRebate": 0,
+            #                     "rebateAsset": "USDT",
+            #                     "reduceOnly": False,
+            #                     "createdTime": "1752049062.496",
+            #                     "realizedPnl": null,
+            #                     "positionSide": "BOTH",
+            #                     "bidAskLevel": null
+            #                 }
+            #             ],
+            #             "meta": {
+            #                 "total": 11,
+            #                 "recordsPerPage": 1,
+            #                 "currentPage": 1
+            #             }
+            #         },
+            #         "timestamp": 1752053061236
+            #     }
+            #
+        data = self.safe_value(response, 'data', {})
+        orders = self.safe_list(data, 'rows', [])
         return self.parse_orders(orders, market, since, limit)
 
     async def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         fetches information on multiple orders made by the user
 
-        https://docs.woox.io/#get-orders
-        https://docs.woox.io/#get-algo-orders
+        https://developer.woox.io/api-reference/endpoint/trading/get_orders
+        https://developer.woox.io/api-reference/endpoint/trading/get_algo_orders
 
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
@@ -1603,8 +1803,8 @@ class woo(Exchange, ImplicitAPI):
         """
         fetches information on multiple orders made by the user
 
-        https://docs.woox.io/#get-orders
-        https://docs.woox.io/#get-algo-orders
+        https://developer.woox.io/api-reference/endpoint/trading/get_orders
+        https://developer.woox.io/api-reference/endpoint/trading/get_algo_orders
 
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
@@ -1631,81 +1831,107 @@ class woo(Exchange, ImplicitAPI):
 
     def parse_order(self, order: dict, market: Market = None) -> Order:
         #
-        # Possible input functions:
-        # * createOrder
-        # * cancelOrder
-        # * fetchOrder
-        # * fetchOrders
-        # isFromFetchOrder = ('order_tag' in order); TO_DO
-        #
-        # stop order after creating it:
-        #   {
-        #     "orderId": "1578938",
-        #     "clientOrderId": "0",
-        #     "algoType": "STOP_LOSS",
-        #     "quantity": "0.1"
-        #   }
-        # stop order after fetching it:
-        #   {
-        #       "algoOrderId": "1578958",
-        #       "clientOrderId": "0",
-        #       "rootAlgoOrderId": "1578958",
-        #       "parentAlgoOrderId": "0",
-        #       "symbol": "SPOT_LTC_USDT",
-        #       "orderTag": "default",
-        #       "algoType": "STOP_LOSS",
-        #       "side": "BUY",
-        #       "quantity": "0.1",
-        #       "isTriggered": False,
-        #       "triggerPrice": "100",
-        #       "triggerStatus": "USELESS",
-        #       "type": "LIMIT",
-        #       "rootAlgoStatus": "CANCELLED",
-        #       "algoStatus": "CANCELLED",
-        #       "triggerPriceType": "MARKET_PRICE",
-        #       "price": "75",
-        #       "triggerTime": "0",
-        #       "totalExecutedQuantity": "0",
-        #       "averageExecutedPrice": "0",
-        #       "totalFee": "0",
-        #       "feeAsset": '',
-        #       "reduceOnly": False,
-        #       "createdTime": "1686149609.744",
-        #       "updatedTime": "1686149903.362"
-        #   }
-        #
-        timestamp = self.safe_timestamp_n(order, ['timestamp', 'created_time', 'createdTime'])
-        orderId = self.safe_string_n(order, ['order_id', 'orderId', 'algoOrderId'])
-        clientOrderId = self.omit_zero(self.safe_string_2(order, 'client_order_id', 'clientOrderId'))  # Somehow, self always returns 0 for limit order
+        # createOrder
+        #     {
+        #         "orderId": 60667653330,
+        #         "clientOrderId": 0,
+        #         "type": "LIMIT",
+        #         "price": 60,
+        #         "quantity": 0.1,
+        #         "amount": null,
+        #         "bidAskLevel": null,
+        #         "timestamp": 1751871779855
+        #     }
+        #
+        # createOrder - algo
+        #     {
+        #         "orderId": "1578938",
+        #         "clientOrderId": "0",
+        #         "algoType": "STOP_LOSS",
+        #         "quantity": "0.1",
+        #         "timestamp": "1686149372216"
+        #     }
+        #
+        # fetchOrder
+        #     {
+        #         "orderId": 60780315704,
+        #         "clientOrderId": 0,
+        #         "symbol": "SPOT_LTC_USDT",
+        #         "orderTag": "default",
+        #         "side": "BUY",
+        #         "quantity": 0.1,
+        #         "amount": null,
+        #         "type": "LIMIT",
+        #         "status": "NEW",
+        #         "price": 60,
+        #         "executed": 0,
+        #         "visible": 0.1,
+        #         "averageExecutedPrice": 0,
+        #         "totalFee": 0,
+        #         "feeAsset": "LTC",
+        #         "totalRebate": 0,
+        #         "rebateAsset": "USDT",
+        #         "reduceOnly": False,
+        #         "createdTime": "1752049062.496",
+        #         "realizedPnl": null,
+        #         "positionSide": "BOTH",
+        #         "bidAskLevel": null
+        #     }
+        #
+        # fetchOrder - algo
+        #     {
+        #         "algoOrderId": 10399260,
+        #         "clientAlgoOrderId": 0,
+        #         "rootAlgoOrderId": 10399260,
+        #         "parentAlgoOrderId": 0,
+        #         "symbol": "SPOT_LTC_USDT",
+        #         "algoOrderTag": "default",
+        #         "algoType": "TAKE_PROFIT",
+        #         "side": "BUY",
+        #         "quantity": 0.1,
+        #         "isTriggered": False,
+        #         "triggerPrice": 65,
+        #         "triggerStatus": "USELESS",
+        #         "type": "LIMIT",
+        #         "rootAlgoStatus": "NEW",
+        #         "algoStatus": "NEW",
+        #         "triggerPriceType": "MARKET_PRICE",
+        #         "price": 60,
+        #         "triggerTime": "0",
+        #         "totalExecutedQuantity": 0,
+        #         "visibleQuantity": 0.1,
+        #         "averageExecutedPrice": 0,
+        #         "totalFee": 0,
+        #         "feeAsset": "",
+        #         "totalRebate": 0,
+        #         "rebateAsset": "",
+        #         "reduceOnly": False,
+        #         "createdTime": "1752049747.732",
+        #         "updatedTime": "1752049747.732",
+        #         "positionSide": "BOTH"
+        #     }
+        #
+        timestamp = self.safe_timestamp(order, 'createdTime')
+        if timestamp is None:
+            timestamp = self.safe_integer(order, 'timestamp')
+        orderId = self.safe_string_2(order, 'orderId', 'algoOrderId')
+        clientOrderId = self.omit_zero(self.safe_string_2(order, 'clientOrderId', 'clientAlgoOrderId'))  # Somehow, self always returns 0 for limit order
         marketId = self.safe_string(order, 'symbol')
         market = self.safe_market(marketId, market)
         symbol = market['symbol']
-        price = self.safe_string_2(order, 'order_price', 'price')
-        amount = self.safe_string_2(order, 'order_quantity', 'quantity')  # This is base amount
-        cost = self.safe_string_2(order, 'order_amount', 'amount')  # This is quote amount
-        orderType = self.safe_string_lower_2(order, 'order_type', 'type')
+        price = self.safe_string(order, 'price')
+        amount = self.safe_string(order, 'quantity')  # This is base amount
+        cost = self.safe_string(order, 'amount')  # This is quote amount
+        orderType = self.safe_string_lower(order, 'type')
         status = self.safe_value_2(order, 'status', 'algoStatus')
         side = self.safe_string_lower(order, 'side')
         filled = self.omit_zero(self.safe_value_2(order, 'executed', 'totalExecutedQuantity'))
-        average = self.omit_zero(self.safe_string_2(order, 'average_executed_price', 'averageExecutedPrice'))
+        average = self.omit_zero(self.safe_string(order, 'averageExecutedPrice'))
         # remaining = Precise.string_sub(cost, filled)
-        fee = self.safe_number_2(order, 'total_fee', 'totalFee')
-        feeCurrency = self.safe_string_2(order, 'fee_asset', 'feeAsset')
-        transactions = self.safe_value(order, 'Transactions')
+        fee = self.safe_number(order, 'totalFee')
+        feeCurrency = self.safe_string(order, 'feeAsset')
         triggerPrice = self.safe_number(order, 'triggerPrice')
-        takeProfitPrice: Num = None
-        stopLossPrice: Num = None
-        childOrders = self.safe_value(order, 'childOrders')
-        if childOrders is not None:
-            first = self.safe_value(childOrders, 0)
-            innerChildOrders = self.safe_value(first, 'childOrders', [])
-            innerChildOrdersLength = len(innerChildOrders)
-            if innerChildOrdersLength > 0:
-                takeProfitOrder = self.safe_value(innerChildOrders, 0)
-                stopLossOrder = self.safe_value(innerChildOrders, 1)
-                takeProfitPrice = self.safe_number(takeProfitOrder, 'triggerPrice')
-                stopLossPrice = self.safe_number(stopLossOrder, 'triggerPrice')
-        lastUpdateTimestamp = self.safe_timestamp_2(order, 'updatedTime', 'updated_time')
+        lastUpdateTimestamp = self.safe_timestamp(order, 'updatedTime')
         return self.safe_order({
             'id': orderId,
             'clientOrderId': clientOrderId,
@@ -1718,18 +1944,18 @@ class woo(Exchange, ImplicitAPI):
             'type': orderType,
             'timeInForce': self.parse_time_in_force(orderType),
             'postOnly': None,  # TO_DO
-            'reduceOnly': self.safe_bool(order, 'reduce_only'),
+            'reduceOnly': self.safe_bool(order, 'reduceOnly'),
             'side': side,
             'price': price,
             'triggerPrice': triggerPrice,
-            'takeProfitPrice': takeProfitPrice,
-            'stopLossPrice': stopLossPrice,
+            'takeProfitPrice': None,
+            'stopLossPrice': None,
             'average': average,
             'amount': amount,
             'filled': filled,
             'remaining': None,  # TO_DO
             'cost': cost,
-            'trades': transactions,
+            'trades': None,
             'fee': {
                 'cost': fee,
                 'currency': feeCurrency,
@@ -1757,7 +1983,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
 
-        https://docs.woox.io/#orderbook-snapshot-public
+        https://developer.woox.io/api-reference/endpoint/public_data/orderbook
 
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
@@ -1770,33 +1996,37 @@ class woo(Exchange, ImplicitAPI):
             'symbol': market['id'],
         }
         if limit is not None:
-            limit = min(limit, 1000)
-            request['max_level'] = limit
-        response = await self.v1PublicGetOrderbookSymbol(self.extend(request, params))
+            request['maxLevel'] = limit
+        response = await self.v3PublicGetOrderbook(self.extend(request, params))
         #
-        # {
-        #   "success": True,
-        #   "timestamp": "1641562961192",
-        #   "asks": [
-        #     {price: '0.921', quantity: "76.01"},
-        #     {price: '0.933', quantity: "477.10"},
-        #     ...
-        #   ],
-        #   "bids": [
-        #     {price: '0.940', quantity: "13502.47"},
-        #     {price: '0.932', quantity: "43.91"},
-        #     ...
-        #   ]
         # }
+        #     {
+        #         "success": True,
+        #         "timestamp": 1751620923344,
+        #         "data": {
+        #             "asks": [
+        #                 {
+        #                     "price": "108924.86",
+        #                     "quantity": "0.032126"
+        #                 }
+        #             ],
+        #             "bids": [
+        #                 {
+        #                     "price": "108924.85",
+        #                     "quantity": "1.714147"
+        #                 }
+        #             ]
+        #         }
+        #     }
         #
+        data = self.safe_dict(response, 'data', {})
         timestamp = self.safe_integer(response, 'timestamp')
-        return self.parse_order_book(response, symbol, timestamp, 'bids', 'asks', 'price', 'quantity')
+        return self.parse_order_book(data, symbol, timestamp, 'bids', 'asks', 'price', 'quantity')
 
     async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
 
-        https://docs.woox.io/#kline-public
-        https://docs.woox.io/#kline-historical-data-public
+        https://developer.woox.io/api-reference/endpoint/public_data/klineHistory
 
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
         :param str symbol: unified symbol of the market to fetch OHLCV data for
@@ -1804,6 +2034,7 @@ class woo(Exchange, ImplicitAPI):
         :param int [since]: timestamp in ms of the earliest candle to fetch
         :param int [limit]: max=1000, max=100 when since is defined and is less than(now - (999 * (timeframe in ms)))
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: the latest time in ms to fetch entries for
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         await self.load_markets()
@@ -1812,70 +2043,44 @@ class woo(Exchange, ImplicitAPI):
             'symbol': market['id'],
             'type': self.safe_string(self.timeframes, timeframe, timeframe),
         }
-        useHistEndpoint = since is not None
-        if (limit is not None) and (since is not None):
-            oneThousandCandles = self.parse_timeframe(timeframe) * 1000 * 999  # 999 because there will be delay between self and the request, causing the latest candle to be excluded sometimes
-            startWithLimit = self.milliseconds() - oneThousandCandles
-            useHistEndpoint = since < startWithLimit
-        if useHistEndpoint:
-            request['start_time'] = since
-        elif limit is not None:  # the hist endpoint does not accept limit
+        if limit is not None:
             request['limit'] = min(limit, 1000)
-        response = None
-        if not useHistEndpoint:
-            response = await self.v1PublicGetKline(self.extend(request, params))
-            #
-            #    {
-            #        "success": True,
-            #        "rows": [
-            #            {
-            #                "open": "0.94238",
-            #                "close": "0.94271",
-            #                "low": "0.94238",
-            #                "high": "0.94296",
-            #                "volume": "73.55",
-            #                "amount": "69.32040520",
-            #                "symbol": "SPOT_WOO_USDT",
-            #                "type": "1m",
-            #                "start_timestamp": "1641584700000",
-            #                "end_timestamp": "1641584760000"
-            #            },
-            #            ...
-            #        ]
-            #    }
-            #
-        else:
-            response = await self.v1PubGetHistKline(self.extend(request, params))
-            response = self.safe_dict(response, 'data')
-            #
-            #    {
-            #        "success": True,
-            #        "data": {
-            #            "rows": [
-            #                {
-            #                    "symbol": "SPOT_BTC_USDT",
-            #                    "open": 44181.40000000,
-            #                    "close": 44174.29000000,
-            #                    "high": 44193.44000000,
-            #                    "low": 44148.34000000,
-            #                    "volume": 110.11930100,
-            #                    "amount": 4863796.24318878,
-            #                    "type": "1m",
-            #                    "start_timestamp": 1704153600000,
-            #                    "end_timestamp": 1704153660000
-            #                },
-            #                ...
-            #            ]
-            #        }
-            #    }
-            #
-        rows = self.safe_list(response, 'rows', [])
+        if since is not None:
+            request['after'] = since
+        until = self.safe_integer(params, 'until')
+        params = self.omit(params, 'until')
+        if until is not None:
+            request['before'] = until
+        response = await self.v3PublicGetKlineHistory(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "symbol": "SPOT_BTC_USDT",
+        #                     "open": "108994.16",
+        #                     "close": "108994.16",
+        #                     "high": "108994.16",
+        #                     "low": "108994.16",
+        #                     "volume": "0",
+        #                     "amount": "0",
+        #                     "type": "1m",
+        #                     "startTimestamp": 1751622120000,
+        #                     "endTimestamp": 1751622180000
+        #                 }
+        #             ]
+        #         },
+        #         "timestamp": 1751622205410
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'rows', [])
         return self.parse_ohlcvs(rows, market, timeframe, since, limit)
 
     def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
-        # example response in fetchOHLCV
         return [
-            self.safe_integer(ohlcv, 'start_timestamp'),
+            self.safe_integer(ohlcv, 'startTimestamp'),
             self.safe_number(ohlcv, 'open'),
             self.safe_number(ohlcv, 'high'),
             self.safe_number(ohlcv, 'low'),
@@ -1929,7 +2134,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch all trades made by the user
 
-        https://docs.woox.io/#get-trade-history
+        https://developer.woox.io/api-reference/endpoint/trading/get_transactions
 
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch trades for
@@ -1949,83 +2154,149 @@ class woo(Exchange, ImplicitAPI):
             market = self.market(symbol)
             request['symbol'] = market['id']
         if since is not None:
-            request['start_t'] = since
-        request, params = self.handle_until_option('end_t', request, params)
+            request['startTime'] = since
+        until = self.safe_integer(params, 'until')  # unified in milliseconds
+        params = self.omit(params, ['until'])
+        if until is not None:
+            request['endTime'] = until
         if limit is not None:
-            request['size'] = limit
-        else:
-            request['size'] = 500
-        response = await self.v1PrivateGetClientTrades(self.extend(request, params))
-        # {
-        #     "success": True,
-        #     "meta": {
-        #         "records_per_page": 25,
-        #         "current_page": 1
-        #     },
-        #     "rows": [
-        #         {
-        #             "id": 5,
-        #             "symbol": "SPOT_BTC_USDT",
-        #             "order_id": 211,
-        #             "order_tag": "default",
-        #             "executed_price": 10892.84,
-        #             "executed_quantity": 0.002,
-        #             "is_maker": 0,
-        #             "side": "SELL",
-        #             "fee": 0,
-        #             "fee_asset": "USDT",
-        #             "executed_timestamp": "1566264290.250"
+            request['limit'] = limit
+        response = await self.v3PrivateGetTradeTransactionHistory(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "id": 1734947821,
+        #                     "symbol": "SPOT_LTC_USDT",
+        #                     "orderId": 60780383217,
+        #                     "executedPrice": 87.86,
+        #                     "executedQuantity": 0.1,
+        #                     "fee": 0.0001,
+        #                     "realizedPnl": null,
+        #                     "feeAsset": "LTC",
+        #                     "orderTag": "default",
+        #                     "side": "BUY",
+        #                     "executedTimestamp": "1752055173.630",
+        #                     "isMaker": 0
+        #                 }
+        #             ],
+        #             "meta": {
+        #                 "total": 1,
+        #                 "recordsPerPage": 100,
+        #                 "currentPage": 1
+        #             }
         #         },
-        #         ...
-        #     ]
-        # }
-        trades = self.safe_list(response, 'rows', [])
+        #         "timestamp": 1752055545121
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        trades = self.safe_list(data, 'rows', [])
         return self.parse_trades(trades, market, since, limit, params)
 
     async def fetch_accounts(self, params={}) -> List[Account]:
         """
         fetch all the accounts associated with a profile
 
-        https://docs.woox.io/#get-assets-of-subaccounts
+        https://developer.woox.io/api-reference/endpoint/account/get_account_info
+        https://developer.woox.io/api-reference/endpoint/account/sub_accounts
 
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `account structures <https://docs.ccxt.com/#/?id=account-structure>` indexed by the account type
         """
-        response = await self.v1PrivateGetSubAccountAssets(params)
+        mainAccountPromise = self.v3PrivateGetAccountInfo(params)
         #
         #     {
-        #         "rows": [{
-        #                 "application_id": "13e4fc34-e2ff-4cb7-b1e4-4c22fee7d365",
-        #                 "account": "Main",
-        #                 "usdt_balance": "4.0"
-        #             },
-        #             {
-        #                 "application_id": "432952aa-a401-4e26-aff6-972920aebba3",
-        #                 "account": "subaccount",
-        #                 "usdt_balance": "1.0"
-        #             }
-        #         ],
-        #         "success": True
+        #         "success": True,
+        #         "data": {
+        #             "applicationId": "251bf5c4-f3c8-4544-bb8b-80001007c3c0",
+        #             "account": "carlos_jose_lima@yahoo.com",
+        #             "alias": "carlos_jose_lima@yahoo.com",
+        #             "otpauth": True,
+        #             "accountMode": "FUTURES",
+        #             "positionMode": "ONE_WAY",
+        #             "leverage": 0,
+        #             "marginRatio": "10",
+        #             "openMarginRatio": "10",
+        #             "initialMarginRatio": "10",
+        #             "maintenanceMarginRatio": "0.03",
+        #             "totalCollateral": "165.55629469",
+        #             "freeCollateral": "165.55629469",
+        #             "totalAccountValue": "167.32418611",
+        #             "totalTradingValue": "167.32418611",
+        #             "totalVaultValue": "0",
+        #             "totalStakingValue": "0",
+        #             "totalLaunchpadValue": "0",
+        #             "totalEarnValue": "0",
+        #             "referrerID": null,
+        #             "accountType": "Main"
+        #         },
+        #         "timestamp": 1752062807915
         #     }
         #
-        rows = self.safe_list(response, 'rows', [])
+        subAccountPromise = self.v3PrivateGetAccountSubAccountsAll(params)
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "applicationId": "6b43de5c-0955-4887-9862-d84e4689f9fe",
+        #                     "name": "sub_account_2",
+        #                     "createdTime": "1606897264.994"
+        #                 },
+        #             ]
+        #         },
+        #         "timestamp": 1721295317627
+        #     }
+        #
+        mainAccountResponse, subAccountResponse = await asyncio.gather(*[mainAccountPromise, subAccountPromise])
+        mainData = self.safe_dict(mainAccountResponse, 'data', {})
+        mainRows = [mainData]
+        subData = self.safe_dict(subAccountResponse, 'data', {})
+        subRows = self.safe_list(subData, 'rows', [])
+        rows = self.array_concat(mainRows, subRows)
         return self.parse_accounts(rows, params)
 
     def parse_account(self, account):
         #
         #     {
-        #         "application_id": "336952aa-a401-4e26-aff6-972920aebba3",
-        #         "account": "subaccount",
-        #         "usdt_balance": "1.0",
+        #         "applicationId": "251bf5c4-f3c8-4544-bb8b-80001007c3c0",
+        #         "account": "carlos_jose_lima@yahoo.com",
+        #         "alias": "carlos_jose_lima@yahoo.com",
+        #         "otpauth": True,
+        #         "accountMode": "FUTURES",
+        #         "positionMode": "ONE_WAY",
+        #         "leverage": 0,
+        #         "marginRatio": "10",
+        #         "openMarginRatio": "10",
+        #         "initialMarginRatio": "10",
+        #         "maintenanceMarginRatio": "0.03",
+        #         "totalCollateral": "165.55629469",
+        #         "freeCollateral": "165.55629469",
+        #         "totalAccountValue": "167.32418611",
+        #         "totalTradingValue": "167.32418611",
+        #         "totalVaultValue": "0",
+        #         "totalStakingValue": "0",
+        #         "totalLaunchpadValue": "0",
+        #         "totalEarnValue": "0",
+        #         "referrerID": null,
+        #         "accountType": "Main"
+        #     }
+        #
+        #     {
+        #         "applicationId": "6b43de5c-0955-4887-9862-d84e4689f9fe",
+        #         "name": "sub_account_2",
+        #         "createdTime": "1606897264.994"
         #     }
         #
-        accountId = self.safe_string(account, 'account')
         return {
             'info': account,
-            'id': self.safe_string(account, 'application_id'),
-            'name': accountId,
+            'id': self.safe_string(account, 'applicationId'),
+            'name': self.safe_string_n(account, ['name', 'account', 'alias']),
             'code': None,
-            'type': accountId == 'main' if 'Main' else 'subaccount',
+            'type': self.safe_string_lower(account, 'accountType', 'subaccount'),
         }
 
     async def fetch_balance(self, params={}) -> Balances:
@@ -2083,7 +2354,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch the deposit address for a currency associated with self account
 
-        https://docs.woox.io/#get-token-deposit-address
+        https://developer.woox.io/api-reference/endpoint/assets/get_wallet_deposit
 
         :param str code: unified currency code
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2092,18 +2363,25 @@ class woo(Exchange, ImplicitAPI):
         # self method is TODO because of networks unification
         await self.load_markets()
         currency = self.currency(code)
-        specialNetworkId: Str = None
-        specialNetworkId, params = self.get_dedicated_network_id(currency, params)
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
         request: dict = {
-            'token': specialNetworkId,
+            'token': currency['id'],
+            'network': self.network_code_to_id(networkCode),
         }
-        response = await self.v1PrivateGetAssetDeposit(self.extend(request, params))
-        # {
-        #     "success": True,
-        #     "address": "3Jmtjx5544T4smrit9Eroe4PCrRkpDeKjP",
-        #     "extra": ''
-        # }
-        return self.parse_deposit_address(response, currency)
+        response = await self.v3PrivateGetAssetWalletDeposit(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "address": "0x31d64B3230f8baDD91dE1710A65DF536aF8f7cDa",
+        #             "extra": ""
+        #         },
+        #         "timestamp": 1721300689532
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        return self.parse_deposit_address(data, currency)
 
     def get_dedicated_network_id(self, currency, params: dict) -> Any:
         networkCode = None
@@ -2133,57 +2411,63 @@ class woo(Exchange, ImplicitAPI):
         currency: Currency = None
         if code is not None:
             currency = self.currency(code)
-            request['balance_token'] = currency['id']
+            request['token'] = currency['id']
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
+        if networkCode is not None:
+            request['network'] = self.network_code_to_id(networkCode)
         if since is not None:
-            request['start_t'] = since
+            request['startTime'] = since
         if limit is not None:
-            request['pageSize'] = limit
+            request['size'] = min(limit, 1000)
         transactionType = self.safe_string(params, 'type')
         params = self.omit(params, 'type')
         if transactionType is not None:
             request['type'] = transactionType
-        response = await self.v1PrivateGetAssetHistory(self.extend(request, params))
-        # {
-        #     "rows": [
-        #       {
-        #         "id": "22010508193900165",
-        #         "token": "TRON_USDT",
-        #         "extra": '',
-        #         "amount": "13.75848500",
-        #         "status": "COMPLETED",
-        #         "account": null,
-        #         "description": null,
-        #         "user_id": "42222",
-        #         "application_id": "6ad2b303-f354-45c0-8105-9f5f19d0e335",
-        #         "external_id": "220105081900134",
-        #         "target_address": "TXnyFSnAYad3YCaqtwMw9jvXKkeU39NLnK",
-        #         "source_address": "TYDzsYUEpvnYmQk4zGP9sWWcTEd2MiAtW6",
-        #         "type": "BALANCE",
-        #         "token_side": "DEPOSIT",
-        #         "tx_id": "35b0004022f6b3ad07f39a0b7af199f6b258c2c3e2c7cdc93c67efa74fd625ee",
-        #         "fee_token": '',
-        #         "fee_amount": "0.00000000",
-        #         "created_time": "1641370779.442",
-        #         "updated_time": "1641370779.465",
-        #         "is_new_target_address": null,
-        #         "confirmed_number": "29",
-        #         "confirming_threshold": "27",
-        #         "audit_tag": "1",
-        #         "audit_result": "0",
-        #         "balance_token": null,  # TODO -write to support, that self seems broken. here should be the token id
-        #         "network_name": null  # TODO -write to support, that self seems broken. here should be the network id
-        #       }
-        #     ],
-        #     "meta": {total: '1', records_per_page: "25", current_page: "1"},
-        #     "success": True
-        # }
-        return [currency, self.safe_list(response, 'rows', [])]
+        response = await self.v3PrivateGetAssetWalletHistory(self.extend(request, params))
+        #
+        #     {
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "createdTime": "1734964440.523",
+        #                     "updatedTime": "1734964614.081",
+        #                     "id": "24122314340000585",
+        #                     "externalId": "241223143600621",
+        #                     "applicationId": "251bf5c4-f3c8-4544-bb8b-80001007c3c0",
+        #                     "token": "ARB_USDCNATIVE",
+        #                     "targetAddress": "0x4d6802d2736daa85e6242ef0dc0f00aa0e68f635",
+        #                     "sourceAddress": "0x63DFE4e34A3bFC00eB0220786238a7C6cEF8Ffc4",
+        #                     "extra": "",
+        #                     "type": "BALANCE",
+        #                     "tokenSide": "WITHDRAW",
+        #                     "amount": "10.00000000",
+        #                     "txId": "0x891ade0a47fd55466bb9d06702bea4edcb75ed9367d9afbc47b93a84f496d2e6",
+        #                     "feeToken": "USDC",
+        #                     "feeAmount": "2",
+        #                     "status": "COMPLETED",
+        #                     "confirmingThreshold": null,
+        #                     "confirmedNumber": null
+        #                 }
+        #             ],
+        #             "meta": {
+        #                 "total": 1,
+        #                 "records_per_page": 25,
+        #                 "current_page": 1
+        #             }
+        #         },
+        #         "timestamp": 1752485344719
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        return [currency, self.safe_list(data, 'rows', [])]
 
     async def fetch_ledger(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[LedgerEntry]:
         """
         fetch the history of changes, actions done by the user or operations that altered balance of the user
 
-        https://docs.woox.io/#get-asset-history
+        https://developer.woox.io/api-reference/endpoint/assets/get_wallet_history
 
         :param str [code]: unified currency code, default is None
         :param int [since]: timestamp in ms of the earliest ledger entry, default is None
@@ -2197,22 +2481,43 @@ class woo(Exchange, ImplicitAPI):
         return self.parse_ledger(rows, currency, since, limit, params)
 
     def parse_ledger_entry(self, item: dict, currency: Currency = None) -> LedgerEntry:
+        #
+        #     {
+        #         "createdTime": "1734964440.523",
+        #         "updatedTime": "1734964614.081",
+        #         "id": "24122314340000585",
+        #         "externalId": "241223143600621",
+        #         "applicationId": "251bf5c4-f3c8-4544-bb8b-80001007c3c0",
+        #         "token": "ARB_USDCNATIVE",
+        #         "targetAddress": "0x4d6802d2736daa85e6242ef0dc0f00aa0e68f635",
+        #         "sourceAddress": "0x63DFE4e34A3bFC00eB0220786238a7C6cEF8Ffc4",
+        #         "extra": "",
+        #         "type": "BALANCE",
+        #         "tokenSide": "WITHDRAW",
+        #         "amount": "10.00000000",
+        #         "txId": "0x891ade0a47fd55466bb9d06702bea4edcb75ed9367d9afbc47b93a84f496d2e6",
+        #         "feeToken": "USDC",
+        #         "feeAmount": "2",
+        #         "status": "COMPLETED",
+        #         "confirmingThreshold": null,
+        #         "confirmedNumber": null
+        #     }
+        #
         networkizedCode = self.safe_string(item, 'token')
-        currencyDefined = self.get_currency_from_chaincode(networkizedCode, currency)
-        code = currencyDefined['code']
+        code = self.safe_currency_code(networkizedCode, currency)
         currency = self.safe_currency(code, currency)
         amount = self.safe_number(item, 'amount')
-        side = self.safe_string(item, 'token_side')
+        side = self.safe_string(item, 'tokenSide')
         direction = 'in' if (side == 'DEPOSIT') else 'out'
-        timestamp = self.safe_timestamp(item, 'created_time')
-        fee = self.parse_token_and_fee_temp(item, 'fee_token', 'fee_amount')
+        timestamp = self.safe_timestamp(item, 'createdTime')
+        fee = self.parse_token_and_fee_temp(item, ['feeToken'], ['feeAmount'])
         return self.safe_ledger_entry({
             'info': item,
             'id': self.safe_string(item, 'id'),
             'currency': code,
             'account': self.safe_string(item, 'account'),
             'referenceAccount': None,
-            'referenceId': self.safe_string(item, 'tx_id'),
+            'referenceId': self.safe_string(item, 'txId'),
             'status': self.parse_transaction_status(self.safe_string(item, 'status')),
             'amount': amount,
             'before': None,
@@ -2248,7 +2553,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch all deposits made to an account
 
-        https://docs.woox.io/#get-asset-history
+        https://developer.woox.io/api-reference/endpoint/assets/get_wallet_history
 
         :param str code: unified currency code
         :param int [since]: the earliest time in ms to fetch deposits for
@@ -2257,7 +2562,7 @@ class woo(Exchange, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         request: dict = {
-            'token_side': 'DEPOSIT',
+            'tokenSide': 'DEPOSIT',
         }
         return await self.fetch_deposits_withdrawals(code, since, limit, self.extend(request, params))
 
@@ -2265,7 +2570,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch all withdrawals made from an account
 
-        https://docs.woox.io/#get-asset-history
+        https://developer.woox.io/api-reference/endpoint/assets/get_wallet_history
 
         :param str code: unified currency code
         :param int [since]: the earliest time in ms to fetch withdrawals for
@@ -2274,7 +2579,7 @@ class woo(Exchange, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         request: dict = {
-            'token_side': 'WITHDRAW',
+            'tokenSide': 'WITHDRAW',
         }
         return await self.fetch_deposits_withdrawals(code, since, limit, self.extend(request, params))
 
@@ -2282,7 +2587,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch history of deposits and withdrawals
 
-        https://docs.woox.io/#get-asset-history
+        https://developer.woox.io/api-reference/endpoint/assets/get_wallet_history
 
         :param str [code]: unified currency code for the currency of the deposit/withdrawals, default is None
         :param int [since]: timestamp in ms of the earliest deposit/withdrawal, default is None
@@ -2296,35 +2601,45 @@ class woo(Exchange, ImplicitAPI):
         currencyRows = await self.get_asset_history_rows(code, since, limit, self.extend(request, params))
         currency = self.safe_value(currencyRows, 0)
         rows = self.safe_list(currencyRows, 1)
+        return self.parse_transactions(rows, currency, since, limit, params)
+
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         #     {
-        #         "rows":[],
-        #         "meta":{
-        #             "total":0,
-        #             "records_per_page":25,
-        #             "current_page":1
-        #         },
-        #         "success":true
+        #         "createdTime": "1734964440.523",
+        #         "updatedTime": "1734964614.081",
+        #         "id": "24122314340000585",
+        #         "externalId": "241223143600621",
+        #         "applicationId": "251bf5c4-f3c8-4544-bb8b-80001007c3c0",
+        #         "token": "ARB_USDCNATIVE",
+        #         "targetAddress": "0x4d6802d2736daa85e6242ef0dc0f00aa0e68f635",
+        #         "sourceAddress": "0x63DFE4e34A3bFC00eB0220786238a7C6cEF8Ffc4",
+        #         "extra": "",
+        #         "type": "BALANCE",
+        #         "tokenSide": "WITHDRAW",
+        #         "amount": "10.00000000",
+        #         "txId": "0x891ade0a47fd55466bb9d06702bea4edcb75ed9367d9afbc47b93a84f496d2e6",
+        #         "feeToken": "USDC",
+        #         "feeAmount": "2",
+        #         "status": "COMPLETED",
+        #         "confirmingThreshold": null,
+        #         "confirmedNumber": null
         #     }
         #
-        return self.parse_transactions(rows, currency, since, limit, params)
-
-    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
-        # example in fetchLedger
         networkizedCode = self.safe_string(transaction, 'token')
         currencyDefined = self.get_currency_from_chaincode(networkizedCode, currency)
         code = currencyDefined['code']
-        movementDirection = self.safe_string_lower(transaction, 'token_side')
+        movementDirection = self.safe_string_lower_2(transaction, 'token_side', 'tokenSide')
         if movementDirection == 'withdraw':
             movementDirection = 'withdrawal'
-        fee = self.parse_token_and_fee_temp(transaction, 'fee_token', 'fee_amount')
-        addressTo = self.safe_string(transaction, 'target_address')
-        addressFrom = self.safe_string(transaction, 'source_address')
-        timestamp = self.safe_timestamp(transaction, 'created_time')
+        fee = self.parse_token_and_fee_temp(transaction, ['fee_token', 'feeToken'], ['fee_amount', 'feeAmount'])
+        addressTo = self.safe_string_2(transaction, 'target_address', 'targetAddress')
+        addressFrom = self.safe_string_2(transaction, 'source_address', 'sourceAddress')
+        timestamp = self.safe_timestamp_2(transaction, 'created_time', 'createdTime')
         return {
             'info': transaction,
-            'id': self.safe_string_2(transaction, 'id', 'withdraw_id'),
-            'txid': self.safe_string(transaction, 'tx_id'),
+            'id': self.safe_string_n(transaction, ['id', 'withdraw_id', 'withdrawId']),
+            'txid': self.safe_string_2(transaction, 'tx_id', 'txId'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'address': None,
@@ -2337,7 +2652,7 @@ class woo(Exchange, ImplicitAPI):
             'amount': self.safe_number(transaction, 'amount'),
             'currency': code,
             'status': self.parse_transaction_status(self.safe_string(transaction, 'status')),
-            'updated': self.safe_timestamp(transaction, 'updated_time'),
+            'updated': self.safe_timestamp_2(transaction, 'updated_time', 'updatedTime'),
             'comment': None,
             'internal': None,
             'fee': fee,
@@ -2395,7 +2710,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch a history of internal transfers made on an account
 
-        https://docs.woox.io/#get-transfer-history
+        https://developer.woox.io/api-reference/endpoint/assets/get_transfer_history
 
         :param str code: unified currency code of the currency transferred
         :param int [since]: the earliest time in ms to fetch transfers for
@@ -2405,41 +2720,52 @@ class woo(Exchange, ImplicitAPI):
         :returns dict[]: a list of `transfer structures <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
         request: dict = {}
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
         if limit is not None:
             request['size'] = limit
         if since is not None:
-            request['start_t'] = since
+            request['startTime'] = since
         until = self.safe_integer(params, 'until')  # unified in milliseconds
         params = self.omit(params, ['until'])
         if until is not None:
-            request['end_t'] = until
-        response = await self.v1PrivateGetAssetMainSubTransferHistory(self.extend(request, params))
+            request['endTime'] = until
+        response = await self.v3PrivateGetAssetTransferHistory(self.extend(request, params))
         #
         #     {
-        #         "rows": [
-        #             {
-        #                 "id": 46704,
-        #                 "token": "USDT",
-        #                 "amount": 30000.00000000,
-        #                 "status": "COMPLETED",
-        #                 "from_application_id": "0f1bd3cd-dba2-4563-b8bb-0adb1bfb83a3",
-        #                 "to_application_id": "c01e6940-a735-4022-9b6c-9d3971cdfdfa",
-        #                 "from_user": "LeverageLow",
-        #                 "to_user": "dev",
-        #                 "created_time": "1709022325.427",
-        #                 "updated_time": "1709022325.542"
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "id": 225,
+        #                     "token": "USDT",
+        #                     "amount": "1000000",
+        #                     "status": "COMPLETED",
+        #                     "from": {
+        #                         "applicationId": "046b5c5c-5b44-4d27-9593-ddc32c0a08ae",
+        #                         "accountName": "Main"
+        #                     },
+        #                     "to": {
+        #                         "applicationId": "082ae5ae-e26a-4fb1-be5b-03e5b4867663",
+        #                         "accountName": "sub001"
+        #                     },
+        #                     "createdTime": "1642660941.534",
+        #                     "updatedTime": "1642660941.950"
+        #                 }
+        #             ],
+        #             "meta": {
+        #                 "total": 46,
+        #                 "recordsPerPage": 1,
+        #                 "currentPage": 1
         #             }
-        #         ],
-        #         "meta": {
-        #             "total": 50,
-        #             "records_per_page": 25,
-        #             "current_page": 1
         #         },
-        #         "success": True
+        #         "timestamp": 1721295317627
         #     }
         #
-        data = self.safe_list(response, 'rows', [])
-        return self.parse_transfers(data, None, since, limit, params)
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'rows', [])
+        return self.parse_transfers(rows, currency, since, limit, params)
 
     def parse_transfer(self, transfer: dict, currency: Currency = None) -> TransferEntry:
         #
@@ -2456,6 +2782,22 @@ class woo(Exchange, ImplicitAPI):
         #         "created_time": "1709022325.427",
         #         "updated_time": "1709022325.542"
         #     }
+        #     {
+        #         "id": 225,
+        #         "token": "USDT",
+        #         "amount": "1000000",
+        #         "status": "COMPLETED",
+        #         "from": {
+        #             "applicationId": "046b5c5c-5b44-4d27-9593-ddc32c0a08ae",
+        #             "accountName": "Main"
+        #         },
+        #         "to": {
+        #             "applicationId": "082ae5ae-e26a-4fb1-be5b-03e5b4867663",
+        #             "accountName": "sub001"
+        #         },
+        #         "createdTime": "1642660941.534",
+        #         "updatedTime": "1642660941.950"
+        #     }
         #
         #    transfer
         #        {
@@ -2463,22 +2805,22 @@ class woo(Exchange, ImplicitAPI):
         #            "id": 200
         #        }
         #
-        networkizedCode = self.safe_string(transfer, 'token')
-        currencyDefined = self.get_currency_from_chaincode(networkizedCode, currency)
-        code = currencyDefined['code']
-        timestamp = self.safe_timestamp(transfer, 'created_time')
+        code = self.safe_currency_code(self.safe_string(transfer, 'token'), currency)
+        timestamp = self.safe_timestamp(transfer, 'createdTime')
         success = self.safe_bool(transfer, 'success')
         status: Str = None
         if success is not None:
             status = 'ok' if success else 'failed'
+        fromAccount = self.safe_dict(transfer, 'from', {})
+        toAccount = self.safe_dict(transfer, 'to', {})
         return {
             'id': self.safe_string(transfer, 'id'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'currency': code,
             'amount': self.safe_number(transfer, 'amount'),
-            'fromAccount': self.safe_string(transfer, 'from_application_id'),
-            'toAccount': self.safe_string(transfer, 'to_application_id'),
+            'fromAccount': self.safe_string(fromAccount, 'applicationId'),
+            'toAccount': self.safe_string(toAccount, 'applicationId'),
             'status': self.parse_transfer_status(self.safe_string(transfer, 'status', status)),
             'info': transfer,
         }
@@ -2599,7 +2941,7 @@ class woo(Exchange, ImplicitAPI):
                 url += '?' + self.urlencode(params)
         else:
             self.check_required_credentials()
-            if method == 'POST' and (path == 'algo/order' or path == 'order'):
+            if method == 'POST' and (path == 'trade/algoOrder' or path == 'trade/order'):
                 isSandboxMode = self.safe_bool(self.options, 'sandboxMode', False)
                 if not isSandboxMode:
                     applicationId = 'bc830de7-50f3-460b-9ee0-f430f83f9dad'
@@ -2619,15 +2961,15 @@ class woo(Exchange, ImplicitAPI):
             }
             if version == 'v3':
                 auth = ts + method + '/' + version + '/' + pathWithParams
-                if method == 'POST' or method == 'PUT' or method == 'DELETE':
+                if method == 'POST' or method == 'PUT':
                     body = self.json(params)
                     auth += body
+                    headers['content-type'] = 'application/json'
                 else:
                     if params:
                         query = self.urlencode(params)
                         url += '?' + query
                         auth += '?' + query
-                headers['content-type'] = 'application/json'
             else:
                 auth = self.urlencode(params)
                 if method == 'POST' or method == 'PUT' or method == 'DELETE':
@@ -2658,25 +3000,26 @@ class woo(Exchange, ImplicitAPI):
     def parse_income(self, income, market: Market = None):
         #
         #     {
-        #         "id":666666,
-        #         "symbol":"PERP_BTC_USDT",
-        #         "funding_rate":0.00001198,
-        #         "mark_price":28941.04000000,
-        #         "funding_fee":0.00069343,
-        #         "payment_type":"Pay",
-        #         "status":"COMPLETED",
-        #         "created_time":"1653616000.666",
-        #         "updated_time":"1653616000.605"
+        #         "id": 1286360,
+        #         "symbol": "PERP_BTC_USDT",
+        #         "fundingRate": -0.00001445,
+        #         "markPrice": "26930.60000000",
+        #         "fundingFee": "9.56021744",
+        #         "fundingIntervalHours": 8,
+        #         "paymentType": "Pay",
+        #         "status": "COMPLETED",
+        #         "createdTime": 1696060873259,
+        #         "updatedTime": 1696060873286
         #     }
         #
         marketId = self.safe_string(income, 'symbol')
         symbol = self.safe_symbol(marketId, market)
-        amount = self.safe_string(income, 'funding_fee')
+        amount = self.safe_string(income, 'fundingFee')
         code = self.safe_currency_code('USD')
         id = self.safe_string(income, 'id')
-        timestamp = self.safe_timestamp(income, 'updated_time')
-        rate = self.safe_number(income, 'funding_rate')
-        paymentType = self.safe_string(income, 'payment_type')
+        timestamp = self.safe_integer(income, 'updatedTime')
+        rate = self.safe_number(income, 'fundingRate')
+        paymentType = self.safe_string(income, 'paymentType')
         amount = Precise.string_neg(amount) if (paymentType == 'Pay') else amount
         return {
             'info': income,
@@ -2693,7 +3036,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch the history of funding payments paid and received on self account
 
-        https://docs.woox.io/#get-funding-fee-history
+        https://developer.woox.io/api-reference/endpoint/futures/get_fundingFee_history
 
         :param str [symbol]: unified market symbol
         :param int [since]: the earliest time in ms to fetch funding history for
@@ -2706,73 +3049,71 @@ class woo(Exchange, ImplicitAPI):
         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)
+            return await self.fetch_paginated_call_incremental('fetchFundingHistory', symbol, since, limit, params, 'page', 500)
         request: dict = {}
         market: Market = None
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
         if since is not None:
-            request['start_t'] = since
+            request['startTime'] = since
+        until = self.safe_integer(params, 'until')  # unified in milliseconds
+        params = self.omit(params, ['until'])
+        if until is not None:
+            request['endTime'] = until
         if limit is not None:
-            request['size'] = limit
-        else:
-            request['size'] = 5000
-        response = await self.v1PrivateGetFundingFeeHistory(self.extend(request, params))
+            request['size'] = min(limit, 500)
+        response = await self.v3PrivateGetFuturesFundingFeeHistory(self.extend(request, params))
         #
         #     {
-        #         "rows":[
-        #             {
-        #                 "id":666666,
-        #                 "symbol":"PERP_BTC_USDT",
-        #                 "funding_rate":0.00001198,
-        #                 "mark_price":28941.04000000,
-        #                 "funding_fee":0.00069343,
-        #                 "payment_type":"Pay",
-        #                 "status":"COMPLETED",
-        #                 "created_time":"1653616000.666",
-        #                 "updated_time":"1653616000.605"
-        #             }
-        #         ],
-        #         "meta":{
-        #             "total":235,
-        #             "records_per_page":25,
-        #             "current_page":1
+        #         "success": True,
+        #         "data": {
+        #             "meta": {
+        #                 "total": 670,
+        #                 "recordsPerPage": 25,
+        #                 "currentPage": 1
+        #             },
+        #             "rows": [
+        #                 {
+        #                     "id": 1286360,
+        #                     "symbol": "PERP_BTC_USDT",
+        #                     "fundingRate": -0.00001445,
+        #                     "markPrice": "26930.60000000",
+        #                     "fundingFee": "9.56021744",
+        #                     "fundingIntervalHours": 8,
+        #                     "paymentType": "Pay",
+        #                     "status": "COMPLETED",
+        #                     "createdTime": 1696060873259,
+        #                     "updatedTime": 1696060873286
+        #                 }
+        #             ]
         #         },
-        #         "success":true
+        #         "timestamp": 1721351502594
         #     }
         #
-        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)
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'rows', [])
+        return self.parse_incomes(rows, market, since, limit)
 
     def parse_funding_rate(self, fundingRate, market: Market = None) -> FundingRate:
         #
         #     {
-        #         "success": True,
-        #         "timestamp": 1727427915529,
         #         "symbol": "PERP_BTC_USDT",
-        #         "est_funding_rate": -0.00092719,
-        #         "est_funding_rate_timestamp": 1727427899060,
-        #         "last_funding_rate": -0.00092610,
-        #         "last_funding_rate_timestamp": 1727424000000,
-        #         "next_funding_time": 1727452800000,
-        #         "last_funding_rate_interval": 8,
-        #         "est_funding_rate_interval": 8
+        #         "estFundingRate": "-0.00000441",
+        #         "estFundingRateTimestamp": 1751623979022,
+        #         "lastFundingRate": "-0.00004953",
+        #         "lastFundingRateTimestamp": 1751616000000,
+        #         "nextFundingTime": 1751644800000,
+        #         "lastFundingIntervalHours": 8,
+        #         "estFundingIntervalHours": 8
         #     }
         #
         symbol = self.safe_string(fundingRate, 'symbol')
         market = self.market(symbol)
-        nextFundingTimestamp = self.safe_integer(fundingRate, 'next_funding_time')
-        estFundingRateTimestamp = self.safe_integer(fundingRate, 'est_funding_rate_timestamp')
-        lastFundingRateTimestamp = self.safe_integer(fundingRate, 'last_funding_rate_timestamp')
-        intervalString = self.safe_string(fundingRate, 'est_funding_rate_interval')
+        nextFundingTimestamp = self.safe_integer(fundingRate, 'nextFundingTime')
+        estFundingRateTimestamp = self.safe_integer(fundingRate, 'estFundingRateTimestamp')
+        lastFundingRateTimestamp = self.safe_integer(fundingRate, 'lastFundingRateTimestamp')
+        intervalString = self.safe_string(fundingRate, 'estFundingIntervalHours')
         return {
             'info': fundingRate,
             'symbol': market['symbol'],
@@ -2782,13 +3123,13 @@ class woo(Exchange, ImplicitAPI):
             'estimatedSettlePrice': None,
             'timestamp': estFundingRateTimestamp,
             'datetime': self.iso8601(estFundingRateTimestamp),
-            'fundingRate': self.safe_number(fundingRate, 'est_funding_rate'),
+            'fundingRate': self.safe_number(fundingRate, 'estFundingRate'),
             'fundingTimestamp': nextFundingTimestamp,
             'fundingDatetime': self.iso8601(nextFundingTimestamp),
             'nextFundingRate': None,
             'nextFundingTimestamp': None,
             'nextFundingDatetime': None,
-            'previousFundingRate': self.safe_number(fundingRate, 'last_funding_rate'),
+            'previousFundingRate': self.safe_number(fundingRate, 'lastFundingRate'),
             'previousFundingTimestamp': lastFundingRateTimestamp,
             'previousFundingDatetime': self.iso8601(lastFundingRateTimestamp),
             'interval': intervalString + 'h',
@@ -2798,7 +3139,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch the current funding rate interval
 
-        https://docs.woox.io/#get-predicted-funding-rate-for-one-market-public
+        https://developer.woox.io/api-reference/endpoint/public_data/fundingRate
 
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2810,7 +3151,7 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch the current funding rate
 
-        https://docs.woox.io/#get-predicted-funding-rate-for-one-market-public
+        https://developer.woox.io/api-reference/endpoint/public_data/fundingRate
 
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2821,28 +3162,37 @@ class woo(Exchange, ImplicitAPI):
         request: dict = {
             'symbol': market['id'],
         }
-        response = await self.v1PublicGetFundingRateSymbol(self.extend(request, params))
+        response = await self.v3PublicGetFundingRate(self.extend(request, params))
         #
         #     {
         #         "success": True,
-        #         "timestamp": 1727428037877,
-        #         "symbol": "PERP_BTC_USDT",
-        #         "est_funding_rate": -0.00092674,
-        #         "est_funding_rate_timestamp": 1727428019064,
-        #         "last_funding_rate": -0.00092610,
-        #         "last_funding_rate_timestamp": 1727424000000,
-        #         "next_funding_time": 1727452800000,
-        #         "last_funding_rate_interval": 8,
-        #         "est_funding_rate_interval": 8
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "symbol": "PERP_BTC_USDT",
+        #                     "estFundingRate": "-0.00000441",
+        #                     "estFundingRateTimestamp": 1751623979022,
+        #                     "lastFundingRate": "-0.00004953",
+        #                     "lastFundingRateTimestamp": 1751616000000,
+        #                     "nextFundingTime": 1751644800000,
+        #                     "lastFundingIntervalHours": 8,
+        #                     "estFundingIntervalHours": 8
+        #                 }
+        #             ]
+        #         },
+        #         "timestamp": 1751624037798
         #     }
         #
-        return self.parse_funding_rate(response, market)
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'rows', [])
+        first = self.safe_dict(rows, 0, {})
+        return self.parse_funding_rate(first, market)
 
     async def fetch_funding_rates(self, symbols: Strings = None, params={}) -> FundingRates:
         """
         fetch the funding rate for multiple markets
 
-        https://docs.woox.io/#get-predicted-funding-rate-for-all-markets-public
+        https://developer.woox.io/api-reference/endpoint/public_data/fundingRate
 
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2850,31 +3200,36 @@ class woo(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         symbols = self.market_symbols(symbols)
-        response = await self.v1PublicGetFundingRates(params)
+        response = await self.v3PublicGetFundingRate(params)
         #
         #     {
-        #         "success":true,
-        #         "rows":[
-        #             {
-        #                 "symbol":"PERP_AAVE_USDT",
-        #                 "est_funding_rate":-0.00003447,
-        #                 "est_funding_rate_timestamp":1653633959001,
-        #                 "last_funding_rate":-0.00002094,
-        #                 "last_funding_rate_timestamp":1653631200000,
-        #                 "next_funding_time":1653634800000
-        #             }
-        #         ],
-        #         "timestamp":1653633985646
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "symbol": "PERP_BTC_USDT",
+        #                     "estFundingRate": "-0.00000441",
+        #                     "estFundingRateTimestamp": 1751623979022,
+        #                     "lastFundingRate": "-0.00004953",
+        #                     "lastFundingRateTimestamp": 1751616000000,
+        #                     "nextFundingTime": 1751644800000,
+        #                     "lastFundingIntervalHours": 8,
+        #                     "estFundingIntervalHours": 8
+        #                 }
+        #             ]
+        #         },
+        #         "timestamp": 1751624037798
         #     }
         #
-        rows = self.safe_list(response, 'rows', [])
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'rows', [])
         return self.parse_funding_rates(rows, symbols)
 
     async def fetch_funding_rate_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetches historical funding rate prices
 
-        https://docs.woox.io/#get-funding-rate-history-for-one-market-public
+        https://developer.woox.io/api-reference/endpoint/public_data/fundingRateHistory
 
         :param str symbol: unified symbol of the market to fetch the funding rate history for
         :param int [since]: timestamp in ms of the earliest funding rate to fetch
@@ -2889,44 +3244,50 @@ class woo(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchFundingRateHistory', 'paginate')
         if paginate:
             return await self.fetch_paginated_call_incremental('fetchFundingRateHistory', symbol, since, limit, params, 'page', 25)
-        request: dict = {}
-        if symbol is not None:
-            market = self.market(symbol)
-            symbol = market['symbol']
-            request['symbol'] = market['id']
+        if symbol is None:
+            raise ArgumentsRequired(self.id + ' fetchFundingRateHistory() requires a symbol argument')
+        market = self.market(symbol)
+        symbol = market['symbol']
+        request: dict = {
+            'symbol': market['id'],
+        }
         if since is not None:
-            request['start_t'] = self.parse_to_int(since / 1000)
-        request, params = self.handle_until_option('end_t', request, params, 0.001)
-        response = await self.v1PublicGetFundingRateHistory(self.extend(request, params))
+            request['startTime'] = since
+        request, params = self.handle_until_option('endTime', request, params)
+        response = await self.v3PublicGetFundingRateHistory(self.extend(request, params))
         #
         #     {
-        #         "success":true,
-        #         "meta":{
-        #             "total":2464,
-        #             "records_per_page":25,
-        #             "current_page":1
-        #         },
-        #         "rows":[
-        #             {
-        #                 "symbol":"PERP_BTC_USDT",
-        #                 "funding_rate":0.00000629,
-        #                 "funding_rate_timestamp":1653638400000,
-        #                 "next_funding_time":1653642000000
+        #         "success": True,
+        #         "data": {
+        #             "rows": [
+        #                 {
+        #                     "symbol": "PERP_BTC_USDT",
+        #                     "fundingRate": "-0.00004953",
+        #                     "fundingRateTimestamp": 1751616000000,
+        #                     "nextFundingTime": 1751644800000,
+        #                     "markPrice": "108708"
+        #                 }
+        #             ],
+        #             "meta": {
+        #                 "total": 11690,
+        #                 "recordsPerPage": 25,
+        #                 "currentPage": 1
         #             }
-        #         ],
-        #         "timestamp":1653640814885
+        #         },
+        #         "timestamp": 1751632390031
         #     }
         #
-        result = self.safe_list(response, 'rows')
+        data = self.safe_dict(response, 'data', {})
+        rows = self.safe_list(data, 'rows', [])
         rates = []
-        for i in range(0, len(result)):
-            entry = result[i]
+        for i in range(0, len(rows)):
+            entry = rows[i]
             marketId = self.safe_string(entry, 'symbol')
-            timestamp = self.safe_integer(entry, 'funding_rate_timestamp')
+            timestamp = self.safe_integer(entry, 'fundingRateTimestamp')
             rates.append({
                 'info': entry,
                 'symbol': self.safe_symbol(marketId),
-                'fundingRate': self.safe_number(entry, 'funding_rate'),
+                'fundingRate': self.safe_number(entry, 'fundingRate'),
                 'timestamp': timestamp,
                 'datetime': self.iso8601(timestamp),
             })
@@ -2937,7 +3298,7 @@ class woo(Exchange, ImplicitAPI):
         """
         set hedged to True or False for a market
 
-        https://docs.woox.io/#update-position-mode
+        https://developer.woox.io/api-reference/endpoint/futures/position_mode
 
         :param bool hedged: set to True to use HEDGE_MODE, False for ONE_WAY
         :param str symbol: not used by woo setPositionMode
@@ -2950,14 +3311,13 @@ class woo(Exchange, ImplicitAPI):
         else:
             hedgeMode = 'ONE_WAY'
         request: dict = {
-            'position_mode': hedgeMode,
+            'positionMode': hedgeMode,
         }
-        response = await self.v1PrivatePostClientPositionMode(self.extend(request, params))
+        response = await self.v3PrivatePutFuturesPositionMode(self.extend(request, params))
         #
         #     {
         #         "success": True,
-        #         "data": {},
-        #         "timestamp": "1709195608551"
+        #         "timestamp": 1752550492845
         #     }
         #
         return response
@@ -2966,19 +3326,20 @@ class woo(Exchange, ImplicitAPI):
         """
         fetch the set leverage for a market
 
-        https://docs.woox.io/#get-account-information-new
+        https://developer.woox.io/api-reference/endpoint/account/get_account_info
+        https://developer.woox.io/api-reference/endpoint/futures/get_leverage
 
         :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'
+        :param str [params.positionMode]: *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: dict = None
         if market['spot']:
-            response = await self.v3PrivateGetAccountinfo(params)
+            response = await self.v3PrivateGetAccountInfo(params)
             #
             #     {
             #         "success": True,
@@ -2986,25 +3347,26 @@ class woo(Exchange, ImplicitAPI):
             #             "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
+            #             "accountMode": "FUTURES",
+            #             "positionMode": "ONE_WAY",
+            #             "leverage": 0,
+            #             "marginRatio": "10",
+            #             "openMarginRatio": "10",
+            #             "initialMarginRatio": "10",
+            #             "maintenanceMarginRatio": "0.03",
+            #             "totalCollateral": "165.6115334",
+            #             "freeCollateral": "165.6115334",
+            #             "totalAccountValue": "167.52723093",
+            #             "totalTradingValue": "167.52723093",
+            #             "totalVaultValue": "0",
+            #             "totalStakingValue": "0",
+            #             "totalLaunchpadValue": "0",
+            #             "totalEarnValue": "0",
+            #             "referrerID": null,
+            #             "accountType": "Main"
             #         },
-            #         "timestamp": 1673323685109
+            #         "timestamp": 1752645129054
             #     }
             #
         elif market['swap']:
@@ -3013,8 +3375,8 @@ class woo(Exchange, ImplicitAPI):
             }
             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))
+            request['marginMode'] = self.encode_margin_mode(marginMode)
+            response = await self.v3PrivateGetFuturesLeverage(self.extend(request, params))
             #
             # HEDGE_MODE
             #     {
@@ -3022,15 +3384,15 @@ class woo(Exchange, ImplicitAPI):
             #         "data":
             #             {
             #                 "symbol": "PERP_ETH_USDT",
-            #                 "default_margin_mode": "CROSS",
-            #                 "position_mode": "HEDGE_MODE",
+            #                 "marginMode": "CROSS",
+            #                 "positionMode": "HEDGE_MODE",
             #                 "details":  [
             #                     {
-            #                         "position_side": "LONG",
+            #                         "positionSide": "LONG",
             #                         "leverage": 10
             #                     },
             #                     {
-            #                         "position_side": "SHORT",
+            #                         "positionSide": "SHORT",
             #                         "leverage": 10
             #                     }
             #                 ]
@@ -3043,11 +3405,11 @@ class woo(Exchange, ImplicitAPI):
             #         "success": True,
             #         "data": {
             #             "symbol": "PERP_ETH_USDT",
-            #             "default_margin_mode": "ISOLATED",
-            #             "position_mode": "ONE_WAY",
+            #             "marginMode": "ISOLATED",
+            #             "positionMode": "ONE_WAY",
             #             "details": [
             #                 {
-            #                     "position_side": "BOTH",
+            #                     "positionSide": "BOTH",
             #                     "leverage": 10
             #                 }
             #             ]
@@ -3063,15 +3425,17 @@ class woo(Exchange, ImplicitAPI):
     def parse_leverage(self, leverage: dict, market: Market = None) -> Leverage:
         marketId = self.safe_string(leverage, 'symbol')
         market = self.safe_market(marketId, market)
-        marginMode = self.safe_string_lower(leverage, 'default_margin_mode')
+        marginMode = self.safe_string_lower(leverage, 'marginMode')
         spotLeverage = self.safe_integer(leverage, 'leverage')
+        if spotLeverage == 0:
+            spotLeverage = None
         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')
+            side = self.safe_string(position, 'positionSide')
             if side == 'BOTH':
                 longLeverage = positionLeverage
                 shortLeverage = positionLeverage
@@ -3091,14 +3455,14 @@ class woo(Exchange, ImplicitAPI):
         """
         set the level of leverage for a market
 
-        https://docs.woox.io/#update-leverage-setting
-        https://docs.woox.io/#update-futures-leverage-setting
+        https://developer.woox.io/api-reference/endpoint/spot_margin/set_leverage
+        https://developer.woox.io/api-reference/endpoint/futures/set_leverage
 
         :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 [symbol]: 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.
+        :param str [params.positionMode]: *for swap markets only* 'ONE_WAY' or 'HEDGE_MODE'
         :returns dict: response from the exchange
         """
         await self.load_markets()
@@ -3109,13 +3473,13 @@ class woo(Exchange, ImplicitAPI):
         if symbol is not None:
             market = self.market(symbol)
         if (symbol is None) or market['spot']:
-            return await self.v1PrivatePostClientLeverage(self.extend(request, params))
+            return await self.v3PrivatePostSpotMarginLeverage(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))
+            request['marginMode'] = self.encode_margin_mode(marginMode)
+            return await self.v3PrivatePutFuturesLeverage(self.extend(request, params))
         else:
             raise NotSupported(self.id + ' fetchLeverage() is not supported for ' + market['type'] + ' markets')
 
@@ -3159,92 +3523,98 @@ class woo(Exchange, ImplicitAPI):
         return await self.v1PrivatePostClientIsolatedMargin(self.extend(request, params))
 
     async def fetch_position(self, symbol: Str, params={}):
+        """
+        fetch data on an open position
+
+        https://developer.woox.io/api-reference/endpoint/futures/get_positions
+
+        :param str symbol: unified market symbol of the market the position is held in
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `position structure <https://docs.ccxt.com/#/?id=position-structure>`
+        """
         await self.load_markets()
         market = self.market(symbol)
         request: dict = {
             'symbol': market['id'],
         }
-        response = await self.v1PrivateGetPositionSymbol(self.extend(request, params))
+        response = await self.v3PrivateGetFuturesPositions(self.extend(request, params))
         #
         #     {
-        #         "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"
+        #         "data": {
+        #             "positions": [
+        #                 {
+        #                     "symbol": "PERP_LTC_USDT",
+        #                     "holding": "0.1",
+        #                     "pendingLongQty": "0",
+        #                     "pendingShortQty": "0",
+        #                     "settlePrice": "96.87",
+        #                     "averageOpenPrice": "96.87",
+        #                     "pnl24H": "0",
+        #                     "fee24H": "0.0048435",
+        #                     "markPrice": "96.83793449",
+        #                     "estLiqPrice": "0",
+        #                     "timestamp": 1752500555823,
+        #                     "adlQuantile": 2,
+        #                     "positionSide": "BOTH",
+        #                     "marginMode": "CROSS",
+        #                     "isolatedMarginToken": "",
+        #                     "isolatedMarginAmount": "0",
+        #                     "isolatedFrozenLong": "0",
+        #                     "isolatedFrozenShort": "0",
+        #                     "leverage": 10
+        #                 }
+        #             ]
+        #         },
+        #         "timestamp": 1752500579848
         #     }
         #
-        return self.parse_position(response, market)
+        result = self.safe_dict(response, 'data', {})
+        positions = self.safe_list(result, 'positions', [])
+        first = self.safe_dict(positions, 0, {})
+        return self.parse_position(first, market)
 
     async def fetch_positions(self, symbols: Strings = None, params={}) -> List[Position]:
+        """
+        fetch all open positions
+
+        https://developer.woox.io/api-reference/endpoint/futures/get_positions
+
+        :param str[] [symbols]: list of unified market symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `position structure <https://docs.ccxt.com/#/?id=position-structure>`
+        """
         await self.load_markets()
-        response = await self.v3PrivateGetPositions(params)
+        response = await self.v3PrivateGetFuturesPositions(params)
         #
         #     {
         #         "success": True,
-        #         "data":
-        #         {
+        #         "data": {
         #             "positions": [
         #                 {
-        #                     "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,
+        #                     "symbol": "PERP_LTC_USDT",
+        #                     "holding": "0.1",
+        #                     "pendingLongQty": "0",
+        #                     "pendingShortQty": "0",
+        #                     "settlePrice": "96.87",
+        #                     "averageOpenPrice": "96.87",
+        #                     "pnl24H": "0",
+        #                     "fee24H": "0.0048435",
+        #                     "markPrice": "96.83793449",
+        #                     "estLiqPrice": "0",
+        #                     "timestamp": 1752500555823,
+        #                     "adlQuantile": 2,
         #                     "positionSide": "BOTH",
         #                     "marginMode": "CROSS",
         #                     "isolatedMarginToken": "",
-        #                     "isolatedMarginAmount": 0.0,
-        #                     "isolatedFrozenLong": 0.0,
-        #                     "isolatedFrozenShort": 0.0,
+        #                     "isolatedMarginAmount": "0",
+        #                     "isolatedFrozenLong": "0",
+        #                     "isolatedFrozenShort": "0",
         #                     "leverage": 10
         #                 }
         #             ]
         #         },
-        #         "timestamp": 1720628675078
+        #         "timestamp": 1752500579848
         #     }
         #
         result = self.safe_dict(response, 'data', {})
@@ -3279,24 +3649,24 @@ class woo(Exchange, ImplicitAPI):
         #
         # v3PrivateGetPositions
         #     {
-        #         "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,
+        #         "symbol": "PERP_LTC_USDT",
+        #         "holding": "0.1",
+        #         "pendingLongQty": "0",
+        #         "pendingShortQty": "0",
+        #         "settlePrice": "96.87",
+        #         "averageOpenPrice": "96.87",
+        #         "pnl24H": "0",
+        #         "fee24H": "0.0048435",
+        #         "markPrice": "96.83793449",
+        #         "estLiqPrice": "0",
+        #         "timestamp": 1752500555823,
+        #         "adlQuantile": 2,
         #         "positionSide": "BOTH",
-        #         "marginMode": "ISOLATED",
-        #         "isolatedMarginToken": "USDT",  # todo: check
-        #         "isolatedMarginAmount": 314.62426,  # todo: check
-        #         "isolatedFrozenLong": 0.0,  # todo: check
-        #         "isolatedFrozenShort": 0.0,  # todo: check
+        #         "marginMode": "CROSS",
+        #         "isolatedMarginToken": "",
+        #         "isolatedMarginAmount": "0",
+        #         "isolatedFrozenLong": "0",
+        #         "isolatedFrozenShort": "0",
         #         "leverage": 10
         #     }
         #
@@ -3310,7 +3680,13 @@ class woo(Exchange, ImplicitAPI):
             side = 'short'
         contractSize = self.safe_string(market, 'contractSize')
         markPrice = self.safe_string_2(position, 'markPrice', 'mark_price')
-        timestamp = self.safe_timestamp(position, 'timestamp')
+        timestampString = self.safe_string(position, 'timestamp')
+        timestamp = None
+        if timestampString is not None:
+            if timestampString.find('.') > -1:
+                timestamp = self.safe_timestamp(position, 'timestamp')
+            else:
+                timestamp = self.safe_integer(position, 'timestamp')
         entryPrice = self.safe_string_2(position, 'averageOpenPrice', 'average_open_price')
         priceDifference = Precise.string_sub(markPrice, entryPrice)
         unrealisedPnl = Precise.string_mul(priceDifference, size)