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

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)

ccxt/async_support/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/async_support/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/async_support/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: