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

ccxt/pro/okxus.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+
+from ccxt.pro.okx import okx
+from ccxt.base.types import Any
+
+
+class okxus(okx):
+
+    def describe(self) -> Any:
+        return self.deep_extend(super(okxus, self).describe(), {
+            'id': 'okxus',
+            'name': 'OKX(US)',
+            'hostname': 'us.okx.com',
+            'urls': {
+                'api': {
+                    'rest': 'https://{hostname}',
+                    'ws': 'wss://wsus.okx.com:8443/ws/v5',
+                },
+                'www': 'https://app.okx.com',
+                'doc': 'https://app.okx.com/docs-v5/en/#overview',
+                'fees': 'https://app.okx.com/pages/products/fees.html',
+                'referral': {
+                    'url': 'https://www.app.okx.com/join/CCXT2023',
+                    'discount': 0.2,
+                },
+                'test': {
+                    'ws': 'wss://wsuspap.okx.com:8443/ws/v5',
+                },
+            },
+            'has': {
+                'swap': False,
+                'future': False,
+                'option': False,
+            },
+        })

ccxt/probit.py

@@ -483,32 +483,23 @@ class probit(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        currencies = self.safe_value(response, 'data', [])
+        currencies = self.safe_list(response, 'data', [])
         result: dict = {}
         for i in range(0, len(currencies)):
             currency = currencies[i]
             id = self.safe_string(currency, 'id')
             code = self.safe_currency_code(id)
-            displayName = self.safe_value(currency, 'display_name')
+            displayName = self.safe_dict(currency, 'display_name')
             name = self.safe_string(displayName, 'en-us')
-            platforms = self.safe_value(currency, 'platform', [])
+            platforms = self.safe_list(currency, 'platform', [])
             platformsByPriority = self.sort_by(platforms, 'priority')
-            platform = None
             networkList: dict = {}
             for j in range(0, len(platformsByPriority)):
                 network = platformsByPriority[j]
                 idInner = self.safe_string(network, 'id')
                 networkCode = self.network_id_to_code(idInner)
-                currentDepositSuspended = self.safe_value(network, 'deposit_suspended')
-                currentWithdrawalSuspended = self.safe_value(network, 'withdrawal_suspended')
-                currentDeposit = not currentDepositSuspended
-                currentWithdraw = not currentWithdrawalSuspended
-                currentActive = currentDeposit and currentWithdraw
-                if currentActive:
-                    platform = network
-                precision = self.parse_precision(self.safe_string(network, 'precision'))
-                withdrawFee = self.safe_value(network, 'withdrawal_fee', [])
-                networkFee = self.safe_value(withdrawFee, 0, {})
+                withdrawFee = self.safe_list(network, 'withdrawal_fee', [])
+                networkFee = self.safe_dict(withdrawFee, 0, {})
                 for k in range(0, len(withdrawFee)):
                     withdrawPlatform = withdrawFee[k]
                     feeCurrencyId = self.safe_string(withdrawPlatform, 'currency_id')
@@ -518,11 +509,11 @@ class probit(Exchange, ImplicitAPI):
                 networkList[networkCode] = {
                     'id': idInner,
                     'network': networkCode,
-                    'active': currentActive,
-                    'deposit': currentDeposit,
-                    'withdraw': currentWithdraw,
+                    'active': None,
+                    'deposit': not self.safe_bool(network, 'deposit_suspended'),
+                    'withdraw': not self.safe_bool(network, 'withdrawal_suspended'),
                     'fee': self.safe_number(networkFee, 'amount'),
-                    'precision': self.parse_number(precision),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(network, 'precision'))),
                     'limits': {
                         'withdraw': {
                             'min': self.safe_number(network, 'min_withdrawal_amount'),
@@ -535,53 +526,33 @@ class probit(Exchange, ImplicitAPI):
                     },
                     'info': network,
                 }
-            if platform is None:
-                platform = self.safe_value(platformsByPriority, 0, {})
-            depositSuspended = self.safe_value(platform, 'deposit_suspended')
-            withdrawalSuspended = self.safe_value(platform, 'withdrawal_suspended')
-            deposit = not depositSuspended
-            withdraw = not withdrawalSuspended
-            active = deposit and withdraw
-            withdrawalFees = self.safe_value(platform, 'withdrawal_fee', {})
-            fees = []
-            # sometimes the withdrawal fee is an empty object
-            # [{'amount': '0.015', 'priority': 1, 'currency_id': 'ETH'}, {}]
-            for j in range(0, len(withdrawalFees)):
-                withdrawalFeeInner = withdrawalFees[j]
-                amount = self.safe_number(withdrawalFeeInner, 'amount')
-                priority = self.safe_integer(withdrawalFeeInner, 'priority')
-                if (amount is not None) and (priority is not None):
-                    fees.append(withdrawalFeeInner)
-            withdrawalFeesByPriority = self.sort_by(fees, 'priority')
-            withdrawalFee = self.safe_value(withdrawalFeesByPriority, 0, {})
-            fee = self.safe_number(withdrawalFee, 'amount')
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'name': name,
-                'active': active,
-                'deposit': deposit,
-                'withdraw': withdraw,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
                 'type': 'crypto',
-                'fee': fee,
-                'precision': self.parse_number(self.parse_precision(self.safe_string(platform, 'precision'))),
+                'fee': None,
+                'precision': None,
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                     'deposit': {
-                        'min': self.safe_number(platform, 'min_deposit_amount'),
+                        'min': None,
                         'max': None,
                     },
                     'withdraw': {
-                        'min': self.safe_number(platform, 'min_withdrawal_amount'),
+                        'min': None,
                         'max': None,
                     },
                 },
                 'networks': networkList,
-            }
+            })
         return result
 
     def parse_balance(self, response) -> Balances:

ccxt/test/tests_async.py

@@ -1173,7 +1173,7 @@ class testMainClass:
         #  -----------------------------------------------------------------------------
         #  --- Init of brokerId tests functions-----------------------------------------
         #  -----------------------------------------------------------------------------
-        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro(), self.test_oxfun(), self.test_xt(), self.test_vertex(), self.test_paradex(), self.test_hashkey(), self.test_coincatch(), self.test_defx(), self.test_cryptomus(), self.test_derive()]
+        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro(), self.test_oxfun(), self.test_xt(), self.test_vertex(), self.test_paradex(), self.test_hashkey(), self.test_coincatch(), self.test_defx(), self.test_cryptomus(), self.test_derive(), self.test_mode_trade()]
         await asyncio.gather(*promises)
         success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
         dump('[INFO]' + success_message)
@@ -1727,3 +1727,19 @@ class testMainClass:
         if not is_sync():
             await close(exchange)
         return True
+
+    async def test_mode_trade(self):
+        exchange = self.init_offline_exchange('modetrade')
+        exchange.secret = 'secretsecretsecretsecretsecretsecretsecrets'
+        id = 'CCXT'
+        await exchange.load_markets()
+        request = None
+        try:
+            await exchange.create_order('BTC/USDC:USDC', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            request = json_parse(exchange.last_request_body)
+        broker_id = request['order_tag']
+        assert broker_id == id, 'modetrade - id: ' + id + ' different from  broker_id: ' + broker_id
+        if not is_sync():
+            await close(exchange)
+        return True

ccxt/test/tests_sync.py

@@ -1170,7 +1170,7 @@ class testMainClass:
         #  -----------------------------------------------------------------------------
         #  --- Init of brokerId tests functions-----------------------------------------
         #  -----------------------------------------------------------------------------
-        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro(), self.test_oxfun(), self.test_xt(), self.test_vertex(), self.test_paradex(), self.test_hashkey(), self.test_coincatch(), self.test_defx(), self.test_cryptomus(), self.test_derive()]
+        promises = [self.test_binance(), self.test_okx(), self.test_cryptocom(), self.test_bybit(), self.test_kucoin(), self.test_kucoinfutures(), self.test_bitget(), self.test_mexc(), self.test_htx(), self.test_woo(), self.test_bitmart(), self.test_coinex(), self.test_bingx(), self.test_phemex(), self.test_blofin(), self.test_hyperliquid(), self.test_coinbaseinternational(), self.test_coinbase_advanced(), self.test_woofi_pro(), self.test_oxfun(), self.test_xt(), self.test_vertex(), self.test_paradex(), self.test_hashkey(), self.test_coincatch(), self.test_defx(), self.test_cryptomus(), self.test_derive(), self.test_mode_trade()]
         (promises)
         success_message = '[' + self.lang + '][TEST_SUCCESS] brokerId tests passed.'
         dump('[INFO]' + success_message)
@@ -1724,3 +1724,19 @@ class testMainClass:
         if not is_sync():
             close(exchange)
         return True
+
+    def test_mode_trade(self):
+        exchange = self.init_offline_exchange('modetrade')
+        exchange.secret = 'secretsecretsecretsecretsecretsecretsecrets'
+        id = 'CCXT'
+        exchange.load_markets()
+        request = None
+        try:
+            exchange.create_order('BTC/USDC:USDC', 'limit', 'buy', 1, 20000)
+        except Exception as e:
+            request = json_parse(exchange.last_request_body)
+        broker_id = request['order_tag']
+        assert broker_id == id, 'modetrade - id: ' + id + ' different from  broker_id: ' + broker_id
+        if not is_sync():
+            close(exchange)
+        return True

ccxt/timex.py

@@ -1393,11 +1393,6 @@ class timex(Exchange, ImplicitAPI):
         #
         id = self.safe_string(currency, 'symbol')
         code = self.safe_currency_code(id)
-        name = self.safe_string(currency, 'name')
-        depositEnabled = self.safe_value(currency, 'depositEnabled')
-        withdrawEnabled = self.safe_value(currency, 'withdrawalEnabled')
-        isActive = self.safe_value(currency, 'active')
-        active = depositEnabled and withdrawEnabled and isActive
         # fee = self.safe_number(currency, 'withdrawalFee')
         feeString = self.safe_string(currency, 'withdrawalFee')
         tradeDecimals = self.safe_integer(currency, 'tradeDecimals')
@@ -1419,14 +1414,14 @@ class timex(Exchange, ImplicitAPI):
             'code': code,
             'info': currency,
             'type': None,
-            'name': name,
-            'active': active,
-            'deposit': depositEnabled,
-            'withdraw': withdrawEnabled,
+            'name': self.safe_string(currency, 'name'),
+            'active': self.safe_bool(currency, 'active'),
+            'deposit': self.safe_bool(currency, 'depositEnabled'),
+            'withdraw': self.safe_bool(currency, 'withdrawalEnabled'),
             'fee': fee,
             'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'decimals'))),
             'limits': {
-                'withdraw': {'min': fee, 'max': None},
+                'withdraw': {'min': None, 'max': None},
                 'amount': {'min': None, 'max': None},
             },
             'networks': {},

ccxt/vertex.py

@@ -457,11 +457,10 @@ class vertex(Exchange, ImplicitAPI):
             tickerId = self.safe_string(data, 'ticker_id')
             if (tickerId is not None) and (tickerId.find('PERP') > 0):
                 continue
-            id = self.safe_string(data, 'product_id')
             name = self.safe_string(data, 'symbol')
             code = self.safe_currency_code(name)
-            result[code] = {
-                'id': id,
+            result[code] = self.safe_currency_structure({
+                'id': self.safe_string(data, 'product_id'),
                 'name': name,
                 'code': code,
                 'precision': None,
@@ -481,7 +480,7 @@ class vertex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-            }
+            })
         return result
 
     def parse_market(self, market) -> Market:

ccxt/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
 
     def fetch_transaction_fees(self, codes: Strings = None, params={}):

ccxt/woo.py

@@ -311,6 +311,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 +822,45 @@ class woo(Exchange, ImplicitAPI):
         :returns dict: an associative dictionary of currencies
         """
         result: dict = {}
-        tokenResponse = 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 +868,66 @@ class woo(Exchange, ImplicitAPI):
         # }
         #
         # only make one request for currrencies...
-        # tokenNetworkResponse = 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 = [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 +935,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 +958,8 @@ class woo(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'info': networks,
-            }
+                'info': [tokensByNetworkId, chainsByNetworkId],
+            })
         return result
 
     def create_market_buy_order_with_cost(self, symbol: str, cost: float, params={}):
@@ -1511,7 +1531,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 +2091,10 @@ class woo(Exchange, ImplicitAPI):
         # self method is TODO because of networks unification
         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 = self.v1PrivateGetAssetDeposit(self.extend(request, params))
         # {
@@ -2084,15 +2102,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'),
         }
 
     def get_asset_history_rows(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> Any:
@@ -2484,15 +2515,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 = self.v1PrivatePostAssetWithdraw(self.extend(request, params))
         #
         #     {