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

ccxt/async_support/ndax.py

@@ -454,44 +454,44 @@ class ndax(Exchange, ImplicitAPI):
         }
         response = await self.publicGetGetProducts(self.extend(request, params))
         #
-        #     [
-        #         {
-        #             "OMSId":1,
-        #             "ProductId":1,
-        #             "Product":"BTC",
-        #             "ProductFullName":"Bitcoin",
-        #             "ProductType":"CryptoCurrency",
-        #             "DecimalPlaces":8,
-        #             "TickSize":0.0000000100000000000000000000,
-        #             "NoFees":false,
-        #             "IsDisabled":false,
-        #             "MarginEnabled":false
-        #         },
-        #     ]
+        #    [
+        #        {
+        #            "OMSId": "1",
+        #            "ProductId": "1",
+        #            "Product": "BTC",
+        #            "ProductFullName": "Bitcoin",
+        #            "MasterDataUniqueProductSymbol": "",
+        #            "ProductType": "CryptoCurrency",
+        #            "DecimalPlaces": "8",
+        #            "TickSize": "0.0000000100000000000000000000",
+        #            "DepositEnabled": True,
+        #            "WithdrawEnabled": True,
+        #            "NoFees": False,
+        #            "IsDisabled": False,
+        #            "MarginEnabled": False
+        #        },
+        #        ...
         #
         result: dict = {}
         for i in range(0, len(response)):
             currency = response[i]
             id = self.safe_string(currency, 'ProductId')
-            name = self.safe_string(currency, 'ProductFullName')
+            code = self.safe_currency_code(self.safe_string(currency, 'Product'))
             ProductType = self.safe_string(currency, 'ProductType')
             type = 'fiat' if (ProductType == 'NationalCurrency') else 'crypto'
             if ProductType == 'Unknown':
                 # such currency is just a blanket entry
                 type = 'other'
-            code = self.safe_currency_code(self.safe_string(currency, 'Product'))
-            isDisabled = self.safe_value(currency, 'IsDisabled')
-            active = not isDisabled
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
-                'name': name,
+                'name': self.safe_string(currency, 'ProductFullName'),
                 'code': code,
                 'type': type,
                 'precision': self.safe_number(currency, 'TickSize'),
                 'info': currency,
-                'active': active,
-                'deposit': None,
-                'withdraw': None,
+                'active': not self.safe_bool(currency, 'IsDisabled'),
+                'deposit': self.safe_bool(currency, 'DepositEnabled'),
+                'withdraw': self.safe_bool(currency, 'WithdrawEnabled'),
                 'fee': None,
                 'limits': {
                     'amount': {
@@ -504,7 +504,8 @@ class ndax(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': {},
-            }
+                'margin': self.safe_bool(currency, 'MarginEnabled'),
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/okcoin.py

@@ -840,47 +840,30 @@ class okcoin(Exchange, ImplicitAPI):
             return None
         else:
             response = await self.privateGetAssetCurrencies(params)
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
             result: dict = {}
             dataByCurrencyId = self.group_by(data, 'ccy')
             currencyIds = list(dataByCurrencyId.keys())
             for i in range(0, len(currencyIds)):
                 currencyId = currencyIds[i]
-                currency = self.safe_currency(currencyId)
-                code = currency['code']
+                code = self.safe_currency_code(currencyId)
                 chains = dataByCurrencyId[currencyId]
                 networks: dict = {}
-                currencyActive = False
-                depositEnabled = False
-                withdrawEnabled = False
-                maxPrecision = None
                 for j in range(0, len(chains)):
                     chain = chains[j]
-                    canDeposit = self.safe_value(chain, 'canDep')
-                    depositEnabled = canDeposit if (canDeposit) else depositEnabled
-                    canWithdraw = self.safe_value(chain, 'canWd')
-                    withdrawEnabled = canWithdraw if (canWithdraw) else withdrawEnabled
-                    canInternal = self.safe_value(chain, 'canInternal')
-                    active = True if (canDeposit and canWithdraw and canInternal) else False
-                    currencyActive = active if (active) else currencyActive
                     networkId = self.safe_string(chain, 'chain')
                     if (networkId is not None) and (networkId.find('-') >= 0):
                         parts = networkId.split('-')
                         chainPart = self.safe_string(parts, 1, networkId)
                         networkCode = self.network_id_to_code(chainPart)
-                        precision = self.parse_precision(self.safe_string(chain, 'wdTickSz'))
-                        if maxPrecision is None:
-                            maxPrecision = precision
-                        else:
-                            maxPrecision = Precise.string_min(maxPrecision, precision)
                         networks[networkCode] = {
                             'id': networkId,
                             'network': networkCode,
-                            'active': active,
-                            'deposit': canDeposit,
-                            'withdraw': canWithdraw,
+                            'active': None,
+                            'deposit': self.safe_bool(chain, 'canDep'),
+                            'withdraw': self.safe_bool(chain, 'canWd'),
                             'fee': self.safe_number(chain, 'minFee'),
-                            'precision': self.parse_number(precision),
+                            'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'wdTickSz'))),
                             'limits': {
                                 'withdraw': {
                                     'min': self.safe_number(chain, 'minWd'),
@@ -890,16 +873,16 @@ class okcoin(Exchange, ImplicitAPI):
                             'info': chain,
                         }
                 firstChain = self.safe_value(chains, 0)
-                result[code] = {
+                result[code] = self.safe_currency_structure({
                     'info': chains,
                     'code': code,
                     'id': currencyId,
                     'name': self.safe_string(firstChain, 'name'),
-                    'active': currencyActive,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
                     'fee': None,
-                    'precision': self.parse_number(maxPrecision),
+                    'precision': None,
                     'limits': {
                         'amount': {
                             'min': None,
@@ -907,7 +890,7 @@ class okcoin(Exchange, ImplicitAPI):
                         },
                     },
                     'networks': networks,
-                }
+                })
             return result
 
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:

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,
@@ -389,6 +390,7 @@ class okx(Exchange, ImplicitAPI):
                         'account/spot-manual-borrow-repay': 10,
                         'account/set-auto-repay': 4,
                         'account/spot-borrow-repay-history': 4,
+                        'account/move-positions-history': 10,
                         # subaccount
                         'users/subaccount/list': 10,
                         'account/subaccount/balances': 10 / 3,
@@ -526,6 +528,7 @@ class okx(Exchange, ImplicitAPI):
                         'account/fixed-loan/manual-reborrow': 5,
                         'account/fixed-loan/repay-borrowing-order': 5,
                         'account/bills-history-archive': 72000,  # 12 req/day
+                        'account/move-positions': 10,
                         # subaccount
                         'users/subaccount/modify-apikey': 10,
                         'asset/subaccount/transfer': 10,
@@ -992,6 +995,13 @@ class okx(Exchange, ImplicitAPI):
                     '70010': BadRequest,  # Timestamp parameters need to be in Unix timestamp format in milliseconds.
                     '70013': BadRequest,  # endTs needs to be bigger than or equal to beginTs.
                     '70016': BadRequest,  # Please specify your instrument settings for at least one instType.
+                    '70060': BadRequest,  # The account doesn’t exist or the position side is incorrect. To and from accounts must be under the same main account.
+                    '70061': BadRequest,  # To move position, please enter a position that’s opposite to your current side and is smaller than or equal to your current size.
+                    '70062': BadRequest,  # account has reached the maximum number of position transfers allowed per day.
+                    '70064': BadRequest,  # Position does not exist.
+                    '70065': BadRequest,  # Couldn’t move position. Execution price cannot be determined
+                    '70066': BadRequest,  # Moving positions isn't supported in spot mode. Switch to any other account mode and try again.
+                    '70067': BadRequest,  # Moving positions isn't supported in margin trading.
                     '1009': BadRequest,  # Request message exceeds the maximum frame length
                     '4001': AuthenticationError,  # Login Failed
                     '4002': BadRequest,  # Invalid Request
@@ -5976,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.
@@ -6061,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
@@ -7018,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/onetrading.py

@@ -405,9 +405,12 @@ class onetrading(Exchange, ImplicitAPI):
         #
         #     [
         #         {
-        #             "code":"BEST",
-        #             "precision":8
-        #         }
+        #             "code": "USDT",
+        #             "precision": 6,
+        #             "unified_cryptoasset_id": 825,
+        #             "name": "Tether USDt",
+        #             "collateral_percentage": 0
+        #         },
         #     ]
         #
         result: dict = {}
@@ -415,11 +418,11 @@ class onetrading(Exchange, ImplicitAPI):
             currency = response[i]
             id = self.safe_string(currency, 'code')
             code = self.safe_currency_code(id)
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
-                'name': None,
-                'info': currency,  # the original payload
+                'name': self.safe_string(currency, 'name'),
+                'info': currency,
                 'active': None,
                 'fee': None,
                 'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'precision'))),
@@ -430,7 +433,7 @@ class onetrading(Exchange, ImplicitAPI):
                     'withdraw': {'min': None, 'max': None},
                 },
                 'networks': {},
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/oxfun.py

@@ -25,7 +25,6 @@ from ccxt.base.errors import NetworkError
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import RequestTimeout
 from ccxt.base.decimal_to_precision import TICK_SIZE
-from ccxt.base.precise import Precise
 
 
 class oxfun(Exchange, ImplicitAPI):
@@ -613,66 +612,7 @@ class oxfun(Exchange, ImplicitAPI):
         #                         "minDeposit": "0.00010",
         #                         "minWithdrawal": "0.00010"
         #                     },
-        #                     {
-        #                         "network": "Arbitrum",
-        #                         "tokenId": "0xba0Dda8762C24dA9487f5FA026a9B64b695A07Ea",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Ethereum",
-        #                         "tokenId": "0xba0Dda8762C24dA9487f5FA026a9B64b695A07Ea",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Arbitrum",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Avalanche",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Solana",
-        #                         "tokenId": "DV3845GEAVXfwpyVGGgWbqBVCtzHdCXNCGfcdboSEuZz",
-        #                         "transactionPrecision": "8",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Ethereum",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     }
+        #                     ...
         #                 ]
         #             },
         #             {
@@ -722,74 +662,64 @@ class oxfun(Exchange, ImplicitAPI):
             parts = fullId.split('.')
             id = parts[0]
             code = self.safe_currency_code(id)
-            networks: dict = {}
+            if not (code in result):
+                result[code] = {
+                    'id': id,
+                    'code': code,
+                    'precision': None,
+                    'type': None,
+                    'name': None,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
+                    'fee': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                    'networks': {},
+                    'info': [],
+                }
             chains = self.safe_list(currency, 'networkList', [])
-            currencyMaxPrecision: Str = None
-            currencyDepositEnabled: Bool = None
-            currencyWithdrawEnabled: Bool = None
             for j in range(0, len(chains)):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'network')
                 networkCode = self.network_id_to_code(networkId)
-                deposit = self.safe_bool(chain, 'canDeposit')
-                withdraw = self.safe_bool(chain, 'canWithdraw')
-                active = (deposit and withdraw)
-                minDeposit = self.safe_string(chain, 'minDeposit')
-                minWithdrawal = self.safe_string(chain, 'minWithdrawal')
-                precision = self.parse_precision(self.safe_string(chain, 'transactionPrecision'))
-                networks[networkCode] = {
+                result[code]['networks'][networkCode] = {
                     'id': networkId,
                     'network': networkCode,
                     'margin': None,
-                    'deposit': deposit,
-                    'withdraw': withdraw,
-                    'active': active,
+                    'deposit': self.safe_bool(chain, 'canDeposit'),
+                    'withdraw': self.safe_bool(chain, 'canWithdraw'),
+                    'active': None,
                     'fee': None,
-                    'precision': self.parse_number(precision),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'transactionPrecision'))),
                     'limits': {
                         'deposit': {
-                            'min': minDeposit,
+                            'min': self.safe_number(chain, 'minDeposit'),
                             'max': None,
                         },
                         'withdraw': {
-                            'min': minWithdrawal,
+                            'min': self.safe_number(chain, 'minWithdrawal'),
                             'max': None,
                         },
                     },
                     'info': chain,
                 }
-                if (currencyDepositEnabled is None) or deposit:
-                    currencyDepositEnabled = deposit
-                if (currencyWithdrawEnabled is None) or withdraw:
-                    currencyWithdrawEnabled = withdraw
-                if (currencyMaxPrecision is None) or Precise.string_gt(currencyMaxPrecision, precision):
-                    currencyMaxPrecision = precision
-            if code in result:
-                # checking for specific ids.ARB
-                networks = self.extend(result[code]['networks'], networks)
-            result[code] = {
-                'id': id,
-                'code': code,
-                'name': None,
-                'type': None,
-                'active': None,
-                'deposit': currencyDepositEnabled,
-                'withdraw': currencyWithdrawEnabled,
-                'fee': None,
-                'precision': self.parse_number(currencyMaxPrecision),
-                'limits': {
-                    'amount': {
-                        'min': None,
-                        'max': None,
-                    },
-                    'withdraw': {
-                        'min': None,
-                        'max': None,
-                    },
-                },
-                'networks': networks,
-                'info': currency,
-            }
+            infos = self.safe_list(result[code], 'info', [])
+            infos.append(currency)
+            result[code]['info'] = infos
+        # only after all entries are formed in currencies, restructure each entry
+        allKeys = list(result.keys())
+        for i in range(0, len(allKeys)):
+            code = allKeys[i]
+            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
         return result
 
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:

ccxt/async_support/paradex.py

@@ -1245,7 +1245,13 @@ class paradex(Exchange, ImplicitAPI):
         price = self.safe_string(order, 'price')
         amount = self.safe_string(order, 'size')
         orderType = self.safe_string(order, 'type')
+        cancelReason = self.safe_string(order, 'cancel_reason')
         status = self.safe_string(order, 'status')
+        if cancelReason is not None:
+            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'))