ccxt 4.4.85__py2.py3-none-any.whl → 4.4.87__py2.py3-none-any.whl

ccxt/async_support/whitebit.py

@@ -623,25 +623,51 @@ class whitebit(Exchange, ImplicitAPI):
         for i in range(0, len(ids)):
             id = ids[i]
             currency = response[id]
-            # breaks down in Python due to utf8 encoding issues on the exchange side
-            # name = self.safe_string(currency, 'name')
-            canDeposit = self.safe_bool(currency, 'can_deposit', True)
-            canWithdraw = self.safe_bool(currency, 'can_withdraw', True)
-            active = canDeposit and canWithdraw
+            # name = self.safe_string(currency, 'name')  # breaks down in Python due to utf8 encoding issues on the exchange side
             code = self.safe_currency_code(id)
             hasProvider = ('providers' in currency)
-            result[code] = {
+            networks = {}
+            rawNetworks = self.safe_dict(currency, 'networks', {})
+            depositsNetworks = self.safe_list(rawNetworks, 'deposits', [])
+            withdrawsNetworks = self.safe_list(rawNetworks, 'withdraws', [])
+            networkLimits = self.safe_dict(currency, 'limits', {})
+            depositLimits = self.safe_dict(networkLimits, 'deposit', {})
+            withdrawLimits = self.safe_dict(networkLimits, 'withdraw', {})
+            allNetworks = self.array_concat(depositsNetworks, withdrawsNetworks)
+            for j in range(0, len(allNetworks)):
+                networkId = allNetworks[j]
+                networkCode = self.network_id_to_code(networkId)
+                networks[networkCode] = {
+                    'id': networkId,
+                    'network': networkCode,
+                    'active': None,
+                    'deposit': self.in_array(networkId, depositsNetworks),
+                    'withdraw': self.in_array(networkId, withdrawsNetworks),
+                    'fee': None,
+                    'precision': None,
+                    'limits': {
+                        'deposit': {
+                            'min': self.safe_number(depositLimits, 'min', None),
+                            'max': self.safe_number(depositLimits, 'max', None),
+                        },
+                        'withdraw': {
+                            'min': self.safe_number(withdrawLimits, 'min', None),
+                            'max': self.safe_number(withdrawLimits, 'max', None),
+                        },
+                    },
+                }
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': currency,  # the original payload
                 'name': None,  # see the comment above
-                'active': active,
-                'deposit': canDeposit,
-                'withdraw': canWithdraw,
+                'active': None,
+                'deposit': self.safe_bool(currency, 'can_deposit'),
+                'withdraw': self.safe_bool(currency, 'can_withdraw'),
                 'fee': None,
                 'networks': None,  # todo
                 'type': 'fiat' if hasProvider else 'crypto',
-                'precision': None,
+                'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'currency_precision'))),
                 'limits': {
                     'amount': {
                         'min': None,
@@ -651,8 +677,12 @@ class whitebit(Exchange, ImplicitAPI):
                         'min': self.safe_number(currency, 'min_withdraw'),
                         'max': self.safe_number(currency, 'max_withdraw'),
                     },
+                    'deposit': {
+                        'min': self.safe_number(currency, 'min_deposit'),
+                        'max': self.safe_number(currency, 'max_deposit'),
+                    },
                 },
-            }
+            })
         return result
 
     async def fetch_transaction_fees(self, codes: Strings = None, params={}):

ccxt/async_support/woo.py

@@ -5,6 +5,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 typing import List
@@ -311,6 +312,11 @@ class woo(Exchange, ImplicitAPI):
                     'TRC20': 'TRON',
                     'ERC20': 'ETH',
                     'BEP20': 'BSC',
+                    'ARB': 'Arbitrum',
+                },
+                'networksById': {
+                    'TRX': 'TRC20',
+                    'TRON': 'TRC20',
                 },
                 # override defaultNetworkCodePriorities for a specific currency
                 'defaultNetworkCodeForCurrencies': {
@@ -817,33 +823,45 @@ class woo(Exchange, ImplicitAPI):
         :returns dict: an associative dictionary of currencies
         """
         result: dict = {}
-        tokenResponse = await self.v1PublicGetToken(params)
+        tokenResponsePromise = self.v1PublicGetToken(params)
         #
-        # {
-        #     "rows": [
+        #    {
+        #      "rows": [
         #         {
         #             "token": "ETH_USDT",
         #             "fullname": "Tether",
-        #             "decimals": 6,
+        #             "network": "ETH",
+        #             "decimals": "6",
+        #             "delisted": False,
         #             "balance_token": "USDT",
-        #             "created_time": "0",
-        #             "updated_time": "0"
+        #             "created_time": "1710123398",
+        #             "updated_time": "1746528481",
+        #             "can_collateral": True,
+        #             "can_short": True
         #         },
         #         {
         #             "token": "BSC_USDT",
         #             "fullname": "Tether",
-        #             "decimals": 18,
+        #             "network": "BSC",
+        #             "decimals": "18",
+        #             "delisted": False,
         #             "balance_token": "USDT",
-        #             "created_time": "0",
-        #             "updated_time": "0"
+        #             "created_time": "1710123395",
+        #             "updated_time": "1746528601",
+        #             "can_collateral": True,
+        #             "can_short": True
         #         },
         #         {
-        #             "token": "ZEC",
-        #             "fullname": "ZCash",
-        #             "decimals": 8,
-        #             "balance_token": "ZEC",
-        #             "created_time": "0",
-        #             "updated_time": "0"
+        #             "token": "ALGO",
+        #             "fullname": "Algorand",
+        #             "network": "ALGO",
+        #             "decimals": "6",
+        #             "delisted": False,
+        #             "balance_token": "ALGO",
+        #             "created_time": "1710123394",
+        #             "updated_time": "1723087518",
+        #             "can_collateral": True,
+        #             "can_short": True
         #         },
         #         ...
         #     ],
@@ -851,58 +869,66 @@ class woo(Exchange, ImplicitAPI):
         # }
         #
         # only make one request for currrencies...
-        # tokenNetworkResponse = await self.v1PublicGetTokenNetwork(params)
+        tokenNetworkResponsePromise = self.v1PublicGetTokenNetwork(params)
         #
         # {
         #     "rows": [
         #         {
         #             "protocol": "ERC20",
+        #             "network": "ETH",
         #             "token": "USDT",
-        #             "name": "Ethereum",
-        #             "minimum_withdrawal": 30,
-        #             "withdrawal_fee": 25,
-        #             "allow_deposit": 1,
-        #             "allow_withdraw": 1
+        #             "name": "Ethereum(ERC20)",
+        #             "minimum_withdrawal": "10.00000000",
+        #             "withdrawal_fee": "2.00000000",
+        #             "allow_deposit": "1",
+        #             "allow_withdraw": "1"
         #         },
         #         {
         #             "protocol": "TRC20",
+        #             "network": "TRX",
         #             "token": "USDT",
-        #             "name": "Tron",
-        #             "minimum_withdrawal": 30,
-        #             "withdrawal_fee": 1,
-        #             "allow_deposit": 1,
-        #             "allow_withdraw": 1
+        #             "name": "Tron(TRC20)",
+        #             "minimum_withdrawal": "10.00000000",
+        #             "withdrawal_fee": "4.50000000",
+        #             "allow_deposit": "1",
+        #             "allow_withdraw": "1"
         #         },
         #         ...
         #     ],
         #     "success": True
         # }
         #
+        tokenResponse, tokenNetworkResponse = await asyncio.gather(*[tokenResponsePromise, tokenNetworkResponsePromise])
         tokenRows = self.safe_list(tokenResponse, 'rows', [])
-        networksByCurrencyId = self.group_by(tokenRows, 'balance_token')
-        currencyIds = list(networksByCurrencyId.keys())
+        tokenNetworkRows = self.safe_list(tokenNetworkResponse, 'rows', [])
+        networksById = self.group_by(tokenNetworkRows, 'token')
+        tokensById = self.group_by(tokenRows, 'balance_token')
+        currencyIds = list(tokensById.keys())
         for i in range(0, len(currencyIds)):
             currencyId = currencyIds[i]
-            networks = networksByCurrencyId[currencyId]
             code = self.safe_currency_code(currencyId)
-            name: Str = None
-            minPrecision = None
+            tokensByNetworkId = self.index_by(tokensById[currencyId], 'network')
+            chainsByNetworkId = self.index_by(networksById[currencyId], 'network')
+            keys = list(chainsByNetworkId.keys())
             resultingNetworks: dict = {}
-            for j in range(0, len(networks)):
-                network = networks[j]
-                name = self.safe_string(network, 'fullname')
-                networkId = self.safe_string(network, 'token')
-                splitted = networkId.split('_')
-                unifiedNetwork = splitted[0]
-                precision = self.parse_precision(self.safe_string(network, 'decimals'))
-                if precision is not None:
-                    minPrecision = precision if (minPrecision is None) else Precise.string_min(precision, minPrecision)
-                resultingNetworks[unifiedNetwork] = {
+            for j in range(0, len(keys)):
+                networkId = keys[j]
+                tokenEntry = self.safe_dict(tokensByNetworkId, networkId, {})
+                networkEntry = self.safe_dict(chainsByNetworkId, networkId, {})
+                networkCode = self.network_id_to_code(networkId, code)
+                specialNetworkId = self.safe_string(tokenEntry, 'token')
+                resultingNetworks[networkCode] = {
                     'id': networkId,
-                    'network': unifiedNetwork,
+                    'currencyNetworkId': specialNetworkId,  # exchange uses special crrency-ids(coin + network junction)
+                    'network': networkCode,
+                    'active': None,
+                    'deposit': self.safe_string(networkEntry, 'allow_deposit') == '1',
+                    'withdraw': self.safe_string(networkEntry, 'allow_withdraw') == '1',
+                    'fee': self.safe_number(networkEntry, 'withdrawal_fee'),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(tokenEntry, 'decimals'))),
                     'limits': {
                         'withdraw': {
-                            'min': None,
+                            'min': self.safe_number(networkEntry, 'minimum_withdrawal'),
                             'max': None,
                         },
                         'deposit': {
@@ -910,18 +936,13 @@ class woo(Exchange, ImplicitAPI):
                             'max': None,
                         },
                     },
-                    'active': None,
-                    'deposit': None,
-                    'withdraw': None,
-                    'fee': None,
-                    'precision': self.parse_number(precision),
-                    'info': network,
+                    'info': [networkEntry, tokenEntry],
                 }
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': currencyId,
-                'name': name,
+                'name': None,
                 'code': code,
-                'precision': self.parse_number(minPrecision),
+                'precision': None,
                 'active': None,
                 'fee': None,
                 'networks': resultingNetworks,
@@ -938,8 +959,8 @@ class woo(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'info': networks,
-            }
+                'info': [tokensByNetworkId, chainsByNetworkId],
+            })
         return result
 
     async def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
@@ -1511,7 +1532,7 @@ class woo(Exchange, ImplicitAPI):
         if limit is not None:
             request['size'] = limit
         else:
-            request['size'] = 500
+            request['size'] = 50 if trailing else 500
         if trigger:
             request['algoType'] = 'stop'
         elif trailing:
@@ -2071,12 +2092,10 @@ class woo(Exchange, ImplicitAPI):
         # self method is TODO because of networks unification
         await self.load_markets()
         currency = self.currency(code)
-        networkCodeDefault = self.default_network_code_for_currency(code)
-        networkCode = self.safe_string(params, 'network', networkCodeDefault)
-        params = self.omit(params, 'network')
-        codeForExchange = networkCode + '_' + currency['code']
+        specialNetworkId: Str = None
+        specialNetworkId, params = self.get_dedicated_network_id(currency, params)
         request: dict = {
-            'token': codeForExchange,
+            'token': specialNetworkId,
         }
         response = await self.v1PrivateGetAssetDeposit(self.extend(request, params))
         # {
@@ -2084,15 +2103,28 @@ class woo(Exchange, ImplicitAPI):
         #     "address": "3Jmtjx5544T4smrit9Eroe4PCrRkpDeKjP",
         #     "extra": ''
         # }
-        tag = self.safe_string(response, 'extra')
-        address = self.safe_string(response, 'address')
+        return self.parse_deposit_address(response, currency)
+
+    def get_dedicated_network_id(self, currency, params: dict) -> Any:
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
+        networkCode = self.network_id_to_code(networkCode, currency['code'])
+        networkEntry = self.safe_dict(currency['networks'], networkCode)
+        if networkEntry is None:
+            supportedNetworks = list(currency['networks'].keys())
+            raise BadRequest(self.id + '  can not determine a network code, please provide unified "network" param, one from the following: ' + self.json(supportedNetworks))
+        currentyNetworkId = self.safe_string(networkEntry, 'currencyNetworkId')
+        return [currentyNetworkId, params]
+
+    def parse_deposit_address(self, depositEntry, currency: Currency = None) -> DepositAddress:
+        address = self.safe_string(depositEntry, 'address')
         self.check_address(address)
         return {
-            'info': response,
-            'currency': code,
-            'network': networkCode,
+            'info': depositEntry,
+            'currency': self.safe_string(currency, 'code'),
+            'network': None,
             'address': address,
-            'tag': tag,
+            'tag': self.safe_string(depositEntry, 'extra'),
         }
 
     async def get_asset_history_rows(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> Any:
@@ -2484,15 +2516,9 @@ class woo(Exchange, ImplicitAPI):
         }
         if tag is not None:
             request['extra'] = tag
-        networks = self.safe_dict(self.options, 'networks', {})
-        currencyNetworks = self.safe_dict(currency, 'networks', {})
-        network = self.safe_string_upper(params, 'network')
-        networkId = self.safe_string(networks, network, network)
-        coinNetwork = self.safe_dict(currencyNetworks, networkId, {})
-        coinNetworkId = self.safe_string(coinNetwork, 'id')
-        if coinNetworkId is None:
-            raise BadRequest(self.id + ' withdraw() require network parameter')
-        request['token'] = coinNetworkId
+        specialNetworkId: Str = None
+        specialNetworkId, params = self.get_dedicated_network_id(currency, params)
+        request['token'] = specialNetworkId
         response = await self.v1PrivatePostAssetWithdraw(self.extend(request, params))
         #
         #     {

ccxt/async_support/woofipro.py

@@ -5,6 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.woofipro import ImplicitAPI
+import asyncio
 from ccxt.base.types import Any, Balances, Currencies, Currency, Int, LedgerEntry, Leverage, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, FundingRate, FundingRates, Trade, TradingFees, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -633,13 +634,14 @@ class woofipro(Exchange, ImplicitAPI):
         """
         fetches all available currencies on an exchange
 
-        https://orderly.network/docs/build-on-evm/evm-api/restful-api/public/get-token-info
+        https://orderly.network/docs/build-on-omnichain/evm-api/restful-api/public/get-supported-collateral-info#get-supported-collateral-info
+        https://orderly.network/docs/build-on-omnichain/evm-api/restful-api/public/get-supported-chains-per-builder#get-supported-chains-per-builder
 
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an associative dictionary of currencies
         """
         result: dict = {}
-        response = await self.v1PublicGetPublicToken(params)
+        tokenPromise = self.v1PublicGetPublicToken(params)
         #
         # {
         #     "success": True,
@@ -662,25 +664,28 @@ class woofipro(Exchange, ImplicitAPI):
         #     }
         # }
         #
-        data = self.safe_dict(response, 'data', {})
-        tokenRows = self.safe_list(data, 'rows', [])
+        chainPromise = self.v1PublicGetPublicChainInfo(params)
+        tokenResponse, chainResponse = await asyncio.gather(*[tokenPromise, chainPromise])
+        tokenData = self.safe_dict(tokenResponse, 'data', {})
+        tokenRows = self.safe_list(tokenData, 'rows', [])
+        chainData = self.safe_dict(chainResponse, 'data', {})
+        chainRows = self.safe_list(chainData, 'rows', [])
+        indexedChains = self.index_by(chainRows, 'chain_id')
         for i in range(0, len(tokenRows)):
             token = tokenRows[i]
             currencyId = self.safe_string(token, 'token')
             networks = self.safe_list(token, 'chain_details')
             code = self.safe_currency_code(currencyId)
-            minPrecision = None
             resultingNetworks: dict = {}
             for j in range(0, len(networks)):
-                network = networks[j]
-                # TODO: transform chain id to human readable name
-                networkId = self.safe_string(network, 'chain_id')
-                precision = self.parse_precision(self.safe_string(network, 'decimals'))
-                if precision is not None:
-                    minPrecision = precision if (minPrecision is None) else Precise.string_min(precision, minPrecision)
-                resultingNetworks[networkId] = {
+                networkEntry = networks[j]
+                networkId = self.safe_string(networkEntry, 'chain_id')
+                networkRow = self.safe_dict(indexedChains, networkId)
+                networkName = self.safe_string(networkRow, 'name')
+                networkCode = self.network_id_to_code(networkName, code)
+                resultingNetworks[networkCode] = {
                     'id': networkId,
-                    'network': networkId,
+                    'network': networkCode,
                     'limits': {
                         'withdraw': {
                             'min': None,
@@ -694,15 +699,15 @@ class woofipro(Exchange, ImplicitAPI):
                     'active': None,
                     'deposit': None,
                     'withdraw': None,
-                    'fee': self.safe_number(network, 'withdrawal_fee'),
-                    'precision': self.parse_number(precision),
-                    'info': network,
+                    'fee': self.safe_number(networkEntry, 'withdrawal_fee'),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(networkEntry, 'decimals'))),
+                    'info': [networkEntry, networkRow],
                 }
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': currencyId,
-                'name': currencyId,
+                'name': None,
                 'code': code,
-                'precision': self.parse_number(minPrecision),
+                'precision': None,
                 'active': None,
                 'fee': None,
                 'networks': resultingNetworks,
@@ -719,7 +724,7 @@ class woofipro(Exchange, ImplicitAPI):
                     },
                 },
                 'info': token,
-            }
+            })
         return result
 
     def parse_token_and_fee_temp(self, item, feeTokenKey, feeAmountKey):

ccxt/async_support/xt.py

@@ -912,48 +912,30 @@ class xt(Exchange, ImplicitAPI):
             entry = currenciesData[i]
             currencyId = self.safe_string(entry, 'currency')
             code = self.safe_currency_code(currencyId)
-            minPrecision = self.parse_number(self.parse_precision(self.safe_string(entry, 'maxPrecision')))
             networkEntry = self.safe_value(chainsDataIndexed, currencyId, {})
             rawNetworks = self.safe_value(networkEntry, 'supportChains', [])
             networks = {}
-            minWithdrawString = None
-            minWithdrawFeeString = None
-            active = False
-            deposit = False
-            withdraw = False
             for j in range(0, len(rawNetworks)):
                 rawNetwork = rawNetworks[j]
                 networkId = self.safe_string(rawNetwork, 'chain')
-                network = self.network_id_to_code(networkId)
-                depositEnabled = self.safe_value(rawNetwork, 'depositEnabled')
-                deposit = depositEnabled if (depositEnabled) else deposit
-                withdrawEnabled = self.safe_value(rawNetwork, 'withdrawEnabled')
-                withdraw = withdrawEnabled if (withdrawEnabled) else withdraw
-                networkActive = depositEnabled and withdrawEnabled
-                active = networkActive if (networkActive) else active
-                withdrawFeeString = self.safe_string(rawNetwork, 'withdrawFeeAmount')
-                if withdrawFeeString is not None:
-                    minWithdrawFeeString = withdrawFeeString if (minWithdrawFeeString is None) else Precise.string_min(withdrawFeeString, minWithdrawFeeString)
-                minNetworkWithdrawString = self.safe_string(rawNetwork, 'withdrawMinAmount')
-                if minNetworkWithdrawString is not None:
-                    minWithdrawString = minNetworkWithdrawString if (minWithdrawString is None) else Precise.string_min(minNetworkWithdrawString, minWithdrawString)
-                networks[network] = {
+                networkCode = self.network_id_to_code(networkId, code)
+                networks[networkCode] = {
                     'info': rawNetwork,
                     'id': networkId,
-                    'network': network,
+                    'network': networkCode,
                     'name': None,
-                    'active': networkActive,
-                    'fee': self.parse_number(withdrawFeeString),
-                    'precision': minPrecision,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
+                    'active': None,
+                    'fee': self.safe_number(rawNetwork, 'withdrawFeeAmount'),
+                    'precision': None,
+                    'deposit': self.safe_bool(rawNetwork, 'depositEnabled'),
+                    'withdraw': self.safe_bool(rawNetwork, 'withdrawEnabled'),
                     'limits': {
                         'amount': {
                             'min': None,
                             'max': None,
                         },
                         'withdraw': {
-                            'min': self.parse_number(minNetworkWithdrawString),
+                            'min': self.safe_number(rawNetwork, 'withdrawMinAmount'),
                             'max': None,
                         },
                         'deposit': {
@@ -968,16 +950,16 @@ class xt(Exchange, ImplicitAPI):
                 type = 'crypto'
             else:
                 type = 'other'
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': entry,
                 'id': currencyId,
                 'code': code,
                 'name': self.safe_string(entry, 'fullName'),
-                'active': active,
-                'fee': self.parse_number(minWithdrawFeeString),
-                'precision': minPrecision,
-                'deposit': deposit,
-                'withdraw': withdraw,
+                'active': None,
+                'fee': None,
+                'precision': self.parse_number(self.parse_precision(self.safe_string(entry, 'maxPrecision'))),
+                'deposit': self.safe_string(entry, 'depositStatus') == '1',
+                'withdraw': self.safe_string(entry, 'withdrawStatus') == '1',
                 'networks': networks,
                 'type': type,
                 'limits': {
@@ -986,7 +968,7 @@ class xt(Exchange, ImplicitAPI):
                         'max': None,
                     },
                     'withdraw': {
-                        'min': self.parse_number(minWithdrawString),
+                        'min': None,
                         'max': None,
                     },
                     'deposit': {
@@ -994,7 +976,7 @@ class xt(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:
@@ -2850,17 +2832,21 @@ class xt(Exchange, ImplicitAPI):
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
+        if limit is not None:
+            request['size'] = limit
+        if since is not None:
+            request['startTime'] = since
         type = None
         subType = None
         response = None
         type, params = self.handle_market_type_and_params('fetchOrdersByStatus', market, params)
         subType, params = self.handle_sub_type_and_params('fetchOrdersByStatus', market, params)
-        trigger = self.safe_value(params, 'stop')
+        trigger = self.safe_bool_2(params, 'stop', 'trigger')
         stopLossTakeProfit = self.safe_value(params, 'stopLossTakeProfit')
         if status == 'open':
             if trigger or stopLossTakeProfit:
                 request['state'] = 'NOT_TRIGGERED'
-            elif subType is not None:
+            elif type == 'swap':
                 request['state'] = 'NEW'
         elif status == 'closed':
             if trigger or stopLossTakeProfit:
@@ -2880,7 +2866,7 @@ class xt(Exchange, ImplicitAPI):
             if limit is not None:
                 request['size'] = limit
         if trigger:
-            params = self.omit(params, 'stop')
+            params = self.omit(params, ['stop', 'trigger'])
             if subType == 'inverse':
                 response = await self.privateInverseGetFutureTradeV1EntrustPlanList(self.extend(request, params))
             else:
@@ -2905,6 +2891,7 @@ class xt(Exchange, ImplicitAPI):
                 if since is not None:
                     request['startTime'] = since
                 if limit is not None:
+                    request = self.omit(request, 'size')
                     request['limit'] = limit
                 response = await self.privateSpotGetHistoryOrder(self.extend(request, params))
             else:
@@ -3087,9 +3074,12 @@ class xt(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        isSpotOpenOrders = ((status == 'open') and (subType is None))
-        data = self.safe_value(response, 'result', {})
-        orders = self.safe_value(response, 'result', []) if isSpotOpenOrders else self.safe_value(data, 'items', [])
+        orders = []
+        resultDict = self.safe_dict(response, 'result')
+        if resultDict is not None:
+            orders = self.safe_list(resultDict, 'items', [])
+        else:
+            orders = self.safe_list(response, 'result')
         return self.parse_orders(orders, market, since, limit)
 
     async def fetch_open_orders(self, symbol: str = None, since: Int = None, limit: Int = None, params={}):