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

ccxt/async_support/okx.py

@@ -7,7 +7,7 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.okx import ImplicitAPI
 import asyncio
 import hashlib
-from ccxt.base.types import Account, Any, Balances, BorrowInterest, Conversion, CrossBorrowRate, CrossBorrowRates, Currencies, Currency, DepositAddress, Greeks, Int, LedgerEntry, Leverage, LeverageTier, LongShortRatio, MarginModification, Market, Num, Option, OptionChain, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, Trade, TradingFeeInterface, Transaction, MarketInterface, TransferEntry
+from ccxt.base.types import Account, Any, Balances, BorrowInterest, Conversion, CrossBorrowRate, CrossBorrowRates, Currencies, Currency, DepositAddress, Greeks, Int, LedgerEntry, Leverage, LeverageTier, LongShortRatio, MarginModification, Market, Num, Option, OptionChain, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, OpenInterests, Trade, TradingFeeInterface, Transaction, MarketInterface, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -109,7 +109,7 @@ class okx(Exchange, ImplicitAPI):
                 'fetchFundingIntervals': False,
                 'fetchFundingRate': True,
                 'fetchFundingRateHistory': True,
-                'fetchFundingRates': False,
+                'fetchFundingRates': True,
                 'fetchGreeks': True,
                 'fetchIndexOHLCV': True,
                 'fetchIsolatedBorrowRate': False,
@@ -132,6 +132,7 @@ class okx(Exchange, ImplicitAPI):
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,
                 'fetchOpenInterestHistory': True,
+                'fetchOpenInterests': True,
                 'fetchOpenOrder': None,
                 'fetchOpenOrders': True,
                 'fetchOption': True,
@@ -5985,7 +5986,7 @@ class okx(Exchange, ImplicitAPI):
         nextFundingRate = self.safe_number(contract, 'nextFundingRate')
         fundingTime = self.safe_integer(contract, 'fundingTime')
         fundingTimeString = self.safe_string(contract, 'fundingTime')
-        nextFundingTimeString = self.safe_string(contract, 'nextFundingRate')
+        nextFundingTimeString = self.safe_string(contract, 'nextFundingTime')
         millisecondsInterval = Precise.string_sub(nextFundingTimeString, fundingTimeString)
         # https://www.okx.com/support/hc/en-us/articles/360053909272-Ⅸ-Introduction-to-perpetual-swap-funding-fee
         # > The current interest is 0.
@@ -6070,6 +6071,39 @@ class okx(Exchange, ImplicitAPI):
         entry = self.safe_dict(data, 0, {})
         return self.parse_funding_rate(entry, market)
 
+    async def fetch_funding_rates(self, symbols: Strings = None, params={}) -> FundingRates:
+        """
+        fetches the current funding rates for multiple symbols
+
+        https://www.okx.com/docs-v5/en/#public-data-rest-api-get-funding-rate
+
+        :param str[] symbols: unified market symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a dictionary of `funding rates structure <https://docs.ccxt.com/#/?id=funding-rates-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, 'swap', True)
+        request: dict = {'instId': 'ANY'}
+        response = await self.publicGetPublicFundingRate(self.extend(request, params))
+        #
+        #    {
+        #        "code": "0",
+        #        "data": [
+        #            {
+        #                "fundingRate": "0.00027815",
+        #                "fundingTime": "1634256000000",
+        #                "instId": "BTC-USD-SWAP",
+        #                "instType": "SWAP",
+        #                "nextFundingRate": "0.00017",
+        #                "nextFundingTime": "1634284800000"
+        #            }
+        #        ],
+        #        "msg": ""
+        #    }
+        #
+        data = self.safe_list(response, 'data', [])
+        return self.parse_funding_rates(data, symbols)
+
     async def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch the history of funding payments paid and received on self account
@@ -7027,6 +7061,59 @@ class okx(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_open_interest(data[0], market)
 
+    async def fetch_open_interests(self, symbols: Strings = None, params={}) -> OpenInterests:
+        """
+        Retrieves the open interests of some currencies
+
+        https://www.okx.com/docs-v5/en/#rest-api-public-data-get-open-interest
+
+        :param str[] symbols: Unified CCXT market symbols
+        :param dict [params]: exchange specific parameters
+        :param str params['instType']: Instrument type, options: 'SWAP', 'FUTURES', 'OPTION', default to 'SWAP'
+        :param str params['uly']: Underlying, Applicable to FUTURES/SWAP/OPTION, if instType is 'OPTION', either uly or instFamily is required
+        :param str params['instFamily']: Instrument family, Applicable to FUTURES/SWAP/OPTION, if instType is 'OPTION', either uly or instFamily is required
+        :returns dict: an dictionary of `open interest structures <https://docs.ccxt.com/#/?id=open-interest-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, True, True)
+        market = None
+        if symbols is not None:
+            market = self.market(symbols[0])
+        marketType = None
+        marketType, params = self.handle_sub_type_and_params('fetchOpenInterests', market, params, 'swap')
+        instType = 'SWAP'
+        if marketType == 'future':
+            instType = 'FUTURES'
+        elif instType == 'option':
+            instType = 'OPTION'
+        request: dict = {'instType': instType}
+        uly = self.safe_string(params, 'uly')
+        if uly is not None:
+            request['uly'] = uly
+        instFamily = self.safe_string(params, 'instFamily')
+        if instFamily is not None:
+            request['instFamily'] = instFamily
+        if instType == 'OPTION' and uly is None and instFamily is None:
+            raise BadRequest(self.id + ' fetchOpenInterests() requires either uly or instFamily parameter for OPTION markets')
+        response = await self.publicGetPublicOpenInterest(self.extend(request, params))
+        #
+        #     {
+        #         "code": "0",
+        #         "data": [
+        #             {
+        #                 "instId": "BTC-USDT-SWAP",
+        #                 "instType": "SWAP",
+        #                 "oi": "2125419",
+        #                 "oiCcy": "21254.19",
+        #                 "ts": "1664005108969"
+        #             }
+        #         ],
+        #         "msg": ""
+        #     }
+        #
+        data = self.safe_list(response, 'data', [])
+        return self.parse_open_interests(data, symbols)
+
     async def fetch_open_interest_history(self, symbol: str, timeframe='1d', since: Int = None, limit: Int = None, params={}):
         """
         Retrieves the open interest history of a currency

ccxt/async_support/okxus.py

@@ -0,0 +1,54 @@
+# -*- 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.async_support.okx import okx
+from ccxt.abstract.okxus import ImplicitAPI
+from ccxt.base.types import Any
+
+
+class okxus(okx, ImplicitAPI):
+
+    def describe(self) -> Any:
+        return self.deep_extend(super(okxus, self).describe(), {
+            'id': 'okxus',
+            'name': 'OKX(US)',
+            'certified': False,
+            'pro': True,
+            'hostname': 'us.okx.com',
+            'urls': {
+                'logo': 'https://user-images.githubusercontent.com/1294454/152485636-38b19e4a-bece-4dec-979a-5982859ffc04.jpg',
+                'api': {
+                    'rest': 'https://{hostname}',
+                },
+                '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': {
+                    'rest': 'https://{hostname}',
+                },
+            },
+            'has': {
+                'CORS': None,
+                'spot': True,
+                'margin': None,
+                'swap': False,
+                'future': False,
+                'option': False,
+            },
+            'features': {
+                'swap': {
+                    'linear': None,
+                    'inverse': None,
+                },
+                'future': {
+                    'linear': None,
+                    'inverse': None,
+                },
+            },
+        })

ccxt/async_support/paradex.py

@@ -1248,7 +1248,10 @@ class paradex(Exchange, ImplicitAPI):
         cancelReason = self.safe_string(order, 'cancel_reason')
         status = self.safe_string(order, 'status')
         if cancelReason is not None:
-            status = 'canceled'
+            if cancelReason == 'NOT_ENOUGH_MARGIN':
+                status = 'rejected'
+            else:
+                status = 'canceled'
         side = self.safe_string_lower(order, 'side')
         average = self.omit_zero(self.safe_string(order, 'avg_fill_price'))
         remaining = self.omit_zero(self.safe_string(order, 'remaining_size'))

ccxt/async_support/phemex.py

@@ -1131,9 +1131,7 @@ class phemex(Exchange, ImplicitAPI):
         for i in range(0, len(currencies)):
             currency = currencies[i]
             id = self.safe_string(currency, 'currency')
-            name = self.safe_string(currency, 'name')
             code = self.safe_currency_code(id)
-            status = self.safe_string(currency, 'status')
             valueScaleString = self.safe_string(currency, 'valueScale')
             valueScale = int(valueScaleString)
             minValueEv = self.safe_string(currency, 'minValueEv')
@@ -1146,12 +1144,12 @@ class phemex(Exchange, ImplicitAPI):
                 precision = self.parse_number(precisionString)
                 minAmount = self.parse_number(Precise.string_mul(minValueEv, precisionString))
                 maxAmount = self.parse_number(Precise.string_mul(maxValueEv, precisionString))
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'info': currency,
                 'code': code,
-                'name': name,
-                'active': status == 'Listed',
+                'name': self.safe_string(currency, 'name'),
+                'active': self.safe_string(currency, 'status') == 'Listed',
                 'deposit': None,
                 'withdraw': None,
                 'fee': None,
@@ -1169,7 +1167,7 @@ class phemex(Exchange, ImplicitAPI):
                 'valueScale': valueScale,
                 'networks': None,
                 'type': 'crypto',
-            }
+            })
         return result
 
     def custom_parse_bid_ask(self, bidask, priceKey=0, amountKey=1, market: Market = None):

ccxt/async_support/poloniex.py

@@ -322,6 +322,11 @@ class poloniex(Exchange, ImplicitAPI):
                     'BEP20': 'BSC',
                     'ERC20': 'ETH',
                     'TRC20': 'TRON',
+                    'TRX': 'TRON',
+                },
+                'networksById': {
+                    'TRX': 'TRC20',
+                    'TRON': 'TRC20',
                 },
                 'limits': {
                     'cost': {
@@ -1149,102 +1154,103 @@ class poloniex(Exchange, ImplicitAPI):
         response = await self.publicGetCurrencies(self.extend(params, {'includeMultiChainCurrencies': True}))
         #
         #     [
-        #         {
-        #             "1CR": {
-        #                 "id": 1,
-        #                 "name": "1CRedit",
-        #                 "description": "BTC Clone",
-        #                 "type": "address",
-        #                 "withdrawalFee": "0.01000000",
-        #                 "minConf": 10000,
-        #                 "depositAddress": null,
-        #                 "blockchain": "1CR",
-        #                 "delisted": False,
-        #                 "tradingState": "NORMAL",
-        #                 "walletState": "DISABLED",
-        #                 "walletDepositState": "DISABLED",
-        #                 "walletWithdrawalState": "DISABLED",
-        #                 "parentChain": null,
-        #                 "isMultiChain": False,
-        #                 "isChildChain": False,
-        #                 "childChains": []
-        #             }
-        #         }
+        #      {
+        #        "USDT": {
+        #           "id": 214,
+        #           "name": "Tether USD",
+        #           "description": "Sweep to Main Account",
+        #           "type": "address",
+        #           "withdrawalFee": "0.00000000",
+        #           "minConf": 2,
+        #           "depositAddress": null,
+        #           "blockchain": "OMNI",
+        #           "delisted": False,
+        #           "tradingState": "NORMAL",
+        #           "walletState": "DISABLED",
+        #           "walletDepositState": "DISABLED",
+        #           "walletWithdrawalState": "DISABLED",
+        #           "supportCollateral": True,
+        #           "supportBorrow": True,
+        #           "parentChain": null,
+        #           "isMultiChain": True,
+        #           "isChildChain": False,
+        #           "childChains": [
+        #             "USDTBSC",
+        #             "USDTETH",
+        #             "USDTSOL",
+        #             "USDTTRON"
+        #           ]
+        #        }
+        #      },
+        #      ...
+        #      {
+        #        "USDTBSC": {
+        #              "id": 582,
+        #              "name": "Binance-Peg BSC-USD",
+        #              "description": "Sweep to Main Account",
+        #              "type": "address",
+        #              "withdrawalFee": "0.00000000",
+        #              "minConf": 15,
+        #              "depositAddress": null,
+        #              "blockchain": "BSC",
+        #              "delisted": False,
+        #              "tradingState": "OFFLINE",
+        #              "walletState": "ENABLED",
+        #              "walletDepositState": "ENABLED",
+        #              "walletWithdrawalState": "DISABLED",
+        #              "supportCollateral": False,
+        #              "supportBorrow": False,
+        #              "parentChain": "USDT",
+        #              "isMultiChain": True,
+        #              "isChildChain": True,
+        #              "childChains": []
+        #        }
+        #      },
+        #      ...
         #     ]
         #
         result: dict = {}
+        # poloniex has a complicated structure of currencies, so we handle them differently
+        # at first, turn the response into a normal dictionary
+        currenciesDict = {}
         for i in range(0, len(response)):
-            item = self.safe_value(response, i)
+            item = self.safe_dict(response, i)
             ids = list(item.keys())
-            id = self.safe_value(ids, 0)
-            currency = self.safe_value(item, id)
+            id = self.safe_string(ids, 0)
+            currenciesDict[id] = item[id]
+        keys = list(currenciesDict.keys())
+        for i in range(0, len(keys)):
+            id = keys[i]
+            entry = currenciesDict[id]
             code = self.safe_currency_code(id)
-            name = self.safe_string(currency, 'name')
-            networkId = self.safe_string(currency, 'blockchain')
-            networkCode = None
-            if networkId is not None:
-                networkCode = self.network_id_to_code(networkId, code)
-            delisted = self.safe_value(currency, 'delisted')
-            walletEnabled = self.safe_string(currency, 'walletState') == 'ENABLED'
-            depositEnabled = self.safe_string(currency, 'walletDepositState') == 'ENABLED'
-            withdrawEnabled = self.safe_string(currency, 'walletWithdrawalState') == 'ENABLED'
-            active = not delisted and walletEnabled and depositEnabled and withdrawEnabled
-            numericId = self.safe_integer(currency, 'id')
-            feeString = self.safe_string(currency, 'withdrawalFee')
-            parentChain = self.safe_value(currency, 'parentChain')
-            noParentChain = parentChain is None
-            if self.safe_value(result, code) is None:
-                result[code] = {
-                    'id': id,
-                    'code': code,
-                    'info': None,
-                    'name': name,
-                    'active': active,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'fee': self.parse_number(feeString),
-                    'precision': None,
-                    'type': 'crypto',
-                    'limits': {
-                        'amount': {
-                            'min': None,
-                            'max': None,
-                        },
-                        'deposit': {
-                            'min': None,
-                            'max': None,
-                        },
-                        'withdraw': {
-                            'min': None,
-                            'max': None,
-                        },
-                    },
-                }
-            minFeeString = self.safe_string(result[code], 'fee')
-            if feeString is not None:
-                minFeeString = feeString if (minFeeString is None) else Precise.string_min(feeString, minFeeString)
-            depositAvailable = self.safe_value(result[code], 'deposit')
-            depositAvailable = depositEnabled if (depositEnabled) else depositAvailable
-            withdrawAvailable = self.safe_value(result[code], 'withdraw')
-            withdrawAvailable = withdrawEnabled if (withdrawEnabled) else withdrawAvailable
-            networks = self.safe_value(result[code], 'networks', {})
-            if networkCode is not None:
+            # skip childChains, are collected in parentChain loop
+            if self.safe_bool(entry, 'isChildChain'):
+                continue
+            allChainEntries = []
+            childChains = self.safe_list(entry, 'childChains', [])
+            if childChains is not None:
+                for j in range(0, len(childChains)):
+                    childChainId = childChains[j]
+                    childNetworkEntry = self.safe_dict(currenciesDict, childChainId)
+                    allChainEntries.append(childNetworkEntry)
+            allChainEntries.append(entry)
+            networks: dict = {}
+            for j in range(0, len(allChainEntries)):
+                chainEntry = allChainEntries[j]
+                networkName = self.safe_string(chainEntry, 'blockchain')
+                networkCode = self.network_id_to_code(networkName, code)
+                specialNetworkId = self.safe_string(childChains, j, id)  # in case it's primary chain, defeault to ID
                 networks[networkCode] = {
-                    'info': currency,
-                    'id': networkId,
+                    'info': chainEntry,
+                    'id': specialNetworkId,  # we need self for deposit/withdrawal, instead of friendly name
+                    'numericId': self.safe_integer(chainEntry, 'id'),
                     'network': networkCode,
-                    'currencyId': id,
-                    'numericId': numericId,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'active': active,
-                    'fee': self.parse_number(feeString),
+                    'active': self.safe_bool(chainEntry, 'walletState'),
+                    'deposit': self.safe_string(chainEntry, 'walletDepositState') == 'ENABLED',
+                    'withdraw': self.safe_string(chainEntry, 'walletWithdrawalState') == 'ENABLED',
+                    'fee': self.safe_number(chainEntry, 'withdrawalFee'),
                     'precision': None,
                     'limits': {
-                        'amount': {
-                            'min': None,
-                            'max': None,
-                        },
                         'withdraw': {
                             'min': None,
                             'max': None,
@@ -1255,19 +1261,34 @@ class poloniex(Exchange, ImplicitAPI):
                         },
                     },
                 }
-            result[code]['networks'] = networks
-            info = self.safe_value(result[code], 'info', [])
-            rawInfo: dict = {}
-            rawInfo[id] = currency
-            info.append(rawInfo)
-            result[code]['info'] = info
-            if noParentChain:
-                result[code]['id'] = id
-                result[code]['name'] = name
-            result[code]['active'] = depositAvailable and withdrawAvailable
-            result[code]['deposit'] = depositAvailable
-            result[code]['withdraw'] = withdrawAvailable
-            result[code]['fee'] = self.parse_number(minFeeString)
+            result[code] = self.safe_currency_structure({
+                'info': entry,
+                'code': code,
+                'id': id,
+                'numericId': self.safe_integer(entry, 'id'),
+                'type': 'crypto',
+                'name': self.safe_string(entry, 'name'),
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
+                'precision': None,
+                'limits': {
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'deposit': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'networks': networks,
+            })
         return result
 
     async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
@@ -2585,40 +2606,15 @@ class poloniex(Exchange, ImplicitAPI):
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
         await self.load_markets()
-        currency = self.currency(code)
-        request: dict = {
-            'currency': currency['id'],
-        }
-        networks = self.safe_value(self.options, 'networks', {})
-        network = self.safe_string_upper(params, 'network')  # self line allows the user to specify either ERC20 or ETH
-        network = self.safe_string(networks, network, network)  # handle ERC20>ETH alias
-        if network is not None:
-            request['currency'] = request['currency'] + network  # when network the currency need to be changed to currency+network https://docs.poloniex.com/#withdraw on MultiChain Currencies section
-            params = self.omit(params, 'network')
-        else:
-            if currency['id'] == 'USDT':
-                raise ArgumentsRequired(self.id + ' createDepositAddress requires a network parameter for ' + code + '.')
+        request, extraParams, currency, networkEntry = self.prepare_request_for_deposit_address(code, params)
+        params = extraParams
         response = await self.privatePostWalletsAddress(self.extend(request, params))
         #
         #     {
         #         "address" : "0xfxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxf"
         #     }
         #
-        address = self.safe_string(response, 'address')
-        tag: Str = None
-        self.check_address(address)
-        if currency is not None:
-            depositAddress = self.safe_string(currency['info'], 'depositAddress')
-            if depositAddress is not None:
-                tag = address
-                address = depositAddress
-        return {
-            'currency': code,
-            'address': address,
-            'tag': tag,
-            'network': network,
-            'info': response,
-        }
+        return self.parse_deposit_address_special(response, currency, networkEntry)
 
     async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
@@ -2631,37 +2627,56 @@ class poloniex(Exchange, ImplicitAPI):
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
         await self.load_markets()
-        currency = self.currency(code)
-        request: dict = {
-            'currency': currency['id'],
-        }
-        networks = self.safe_value(self.options, 'networks', {})
-        network = self.safe_string_upper(params, 'network')  # self line allows the user to specify either ERC20 or ETH
-        network = self.safe_string(networks, network, network)  # handle ERC20>ETH alias
-        if network is not None:
-            request['currency'] = request['currency'] + network  # when network the currency need to be changed to currency+network https://docs.poloniex.com/#withdraw on MultiChain Currencies section
-            params = self.omit(params, 'network')
-        else:
-            if currency['id'] == 'USDT':
-                raise ArgumentsRequired(self.id + ' fetchDepositAddress requires a network parameter for ' + code + '.')
+        request, extraParams, currency, networkEntry = self.prepare_request_for_deposit_address(code, params)
+        params = extraParams
         response = await self.privateGetWalletsAddresses(self.extend(request, params))
         #
         #     {
         #         "USDTTRON" : "Txxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxp"
         #     }
         #
-        address = self.safe_string(response, request['currency'])
+        keys = list(response.keys())
+        length = len(keys)
+        if length < 1:
+            raise ExchangeError(self.id + ' fetchDepositAddress() returned an empty response, you might need to try "createDepositAddress" at first and then use "fetchDepositAddress"')
+        return self.parse_deposit_address_special(response, currency, networkEntry)
+
+    def prepare_request_for_deposit_address(self, code: str, params: dict = {}) -> Any:
+        if not (code in self.currencies):
+            raise BadSymbol(self.id + ' fetchDepositAddress(): can not recognize ' + code + ' currency, you might try using unified currency-code and add provide specific "network" parameter, like: fetchDepositAddress("USDT", {"network": "TRC20"})')
+        currency = self.currency(code)
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
+        if networkCode is None:
+            # we need to know the network to find out the currency-junction
+            raise ArgumentsRequired(self.id + ' fetchDepositAddress requires a network parameter for ' + code + '.')
+        exchangeNetworkId = None
+        networkCode = self.network_id_to_code(networkCode, code)
+        networkEntry = self.safe_dict(currency['networks'], networkCode)
+        if networkEntry is not None:
+            exchangeNetworkId = networkEntry['id']
+        else:
+            exchangeNetworkId = networkCode
+        request = {
+            'currency': exchangeNetworkId,
+        }
+        return [request, params, currency, networkEntry]
+
+    def parse_deposit_address_special(self, response, currency, networkEntry) -> DepositAddress:
+        address = self.safe_string(response, 'address')
+        if address is None:
+            address = self.safe_string(response, networkEntry['id'])
         tag: Str = None
         self.check_address(address)
-        if currency is not None:
-            depositAddress = self.safe_string(currency['info'], 'depositAddress')
+        if networkEntry is not None:
+            depositAddress = self.safe_string(networkEntry['info'], 'depositAddress')
             if depositAddress is not None:
                 tag = address
                 address = depositAddress
         return {
             'info': response,
-            'currency': code,
-            'network': network,
+            'currency': currency['code'],
+            'network': self.safe_string(networkEntry, 'network'),
             'address': address,
             'tag': tag,
         }
@@ -2731,21 +2746,12 @@ class poloniex(Exchange, ImplicitAPI):
         """
         tag, params = self.handle_withdraw_tag_and_params(tag, params)
         self.check_address(address)
-        await self.load_markets()
-        currency = self.currency(code)
-        request: dict = {
-            'currency': currency['id'],
-            'amount': amount,
-            'address': address,
-        }
+        request, extraParams, currency, networkEntry = self.prepare_request_for_deposit_address(code, params)
+        params = extraParams
+        request['amount'] = self.currency_to_precision(code, amount)
+        request['address'] = address
         if tag is not None:
             request['paymentId'] = tag
-        networks = self.safe_value(self.options, 'networks', {})
-        network = self.safe_string_upper(params, 'network')  # self line allows the user to specify either ERC20 or ETH
-        network = self.safe_string(networks, network, network)  # handle ERC20>ETH alias
-        if network is not None:
-            request['currency'] = request['currency'] + network  # when network the currency need to be changed to currency+network https://docs.poloniex.com/#withdraw on MultiChain Currencies section
-            params = self.omit(params, 'network')
         response = await self.privatePostWalletsWithdraw(self.extend(request, params))
         #
         #     {
@@ -2754,7 +2760,11 @@ class poloniex(Exchange, ImplicitAPI):
         #         "withdrawalNumber": 13449869
         #     }
         #
-        return self.parse_transaction(response, currency)
+        withdrawResponse = {
+            'response': response,
+            'withdrawNetworkEntry': networkEntry,
+        }
+        return self.parse_transaction(withdrawResponse, currency)
 
     async def fetch_transactions_helper(self, code: Str = None, since: Int = None, limit: Int = None, params={}):
         await self.load_markets()
@@ -3072,6 +3082,9 @@ class poloniex(Exchange, ImplicitAPI):
         #         "withdrawalRequestsId": 33485231
         #     }
         #
+        # if it's being parsed from "withdraw()" method, get the original response
+        if 'withdrawNetworkEntry' in transaction:
+            transaction = transaction['response']
         timestamp = self.safe_timestamp(transaction, 'timestamp')
         currencyId = self.safe_string(transaction, 'currency')
         code = self.safe_currency_code(currencyId)