ccxt 4.3.42__py2.py3-none-any.whl → 4.3.44__py2.py3-none-any.whl

ccxt/async_support/zonda.py

@@ -449,6 +449,13 @@ class zonda(Exchange, ImplicitAPI):
         #         "secondBalanceId": "ab43023b-4079-414c-b340-056e3430a3af"
         #     }
         #
+        # cancelOrder
+        #
+        #    {
+        #        status: "Ok",
+        #        errors: []
+        #    }
+        #
         marketId = self.safe_string(order, 'market')
         symbol = self.safe_symbol(marketId, market, '-')
         timestamp = self.safe_integer(order, 'time')
@@ -1455,9 +1462,10 @@ class zonda(Exchange, ImplicitAPI):
             'side': side,
             'price': price,
         }
+        response = await self.v1_01PrivateDeleteTradingOfferSymbolIdSidePrice(self.extend(request, params))
         # {status: "Fail", errors: ["NOT_RECOGNIZED_OFFER_TYPE"]}  -- if required params are missing
         # {status: "Ok", errors: []}
-        return await self.v1_01PrivateDeleteTradingOfferSymbolIdSidePrice(self.extend(request, params))
+        return self.parse_order(response)
 
     def is_fiat(self, currency):
         fiatCurrencies: dict = {

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.42'
+__version__ = '4.3.44'
 
 # -----------------------------------------------------------------------------
 

ccxt/binance.py

@@ -7556,8 +7556,56 @@ class binance(Exchange, ImplicitAPI):
         #         "tranId": 43000126248
         #     }
         #
-        id = self.safe_string(transfer, 'tranId')
-        currencyId = self.safe_string(transfer, 'asset')
+        #     {
+        #             "orderType": "C2C",  # Enum：PAY(C2B Merchant Acquiring Payment), PAY_REFUND(C2B Merchant Acquiring Payment,refund), C2C(C2C Transfer Payment),CRYPTO_BOX(Crypto box), CRYPTO_BOX_RF(Crypto Box, refund), C2C_HOLDING(Transfer to new Binance user), C2C_HOLDING_RF(Transfer to new Binance user,refund), PAYOUT(B2C Disbursement Payment), REMITTANCE（Send cash)
+        #             "transactionId": "M_P_71505104267788288",
+        #             "transactionTime": 1610090460133,  #trade timestamp
+        #             "amount": "23.72469206",  #order amount(up to 8 decimal places), positive is income, negative is expenditure
+        #             "currency": "BNB",
+        #             "walletType": 1,  #main wallet type, 1 for funding wallet, 2 for spot wallet, 3 for fiat wallet, 4 or 6 for card payment, 5 for earn wallet
+        #             "walletTypes": [1,2],  #array format，there are multiple values when using combination payment
+        #             "fundsDetail": [ # details
+        #                     {
+        #                         "currency": "USDT",  #asset
+        #                         "amount": "1.2",
+        #                         "walletAssetCost":[ #details of asset cost per wallet
+        #                             {"1":"0.6"},
+        #                             {"2":"0.6"}
+        #                         ]
+        #                     },
+        #                     {
+        #                         "currency": "ETH",
+        #                         "amount": "0.0001",
+        #                         "walletAssetCost":[
+        #                             {"1":"0.00005"},
+        #                             {"2":"0.00005"}
+        #                         ]
+        #                     }
+        #                 ],
+        #             "payerInfo":{
+        #                     "name":"Jack",  #nickname or merchant name
+        #                     "type":"USER",  #account type，USER for personal，MERCHANT for merchant
+        #                     "binanceId":"12345678",  #binance uid
+        #                     "accountId":"67736251"  #binance pay id
+        #                 },
+        #             "receiverInfo":{
+        #                     "name":"Alan",  #nickname or merchant name
+        #                     "type":"MERCHANT",  #account type，USER for personal，MERCHANT for merchant
+        #                     "email":"alan@binance.com",  #email
+        #                     "binanceId":"34355667",  #binance uid
+        #                     "accountId":"21326891",  #binance pay id
+        #                     "countryCode":"1",  #International area code
+        #                     "phoneNumber":"8057651210",
+        #                     "mobileCode":"US",  #country code
+        #                     "extend":[ #extension field
+        #                             "institutionName": "",
+        #                             "cardNumber": "",
+        #                             "digitalWalletId": ""
+        #                     ]
+        #                 }
+        #             }
+        id = self.safe_string_2(transfer, 'tranId', 'transactionId')
+        currencyId = self.safe_string_2(transfer, 'asset', 'currency')
         code = self.safe_currency_code(currencyId, currency)
         amount = self.safe_number(transfer, 'amount')
         type = self.safe_string(transfer, 'type')
@@ -7570,7 +7618,13 @@ class binance(Exchange, ImplicitAPI):
             toAccount = self.safe_value(parts, 1)
             fromAccount = self.safe_string(accountsById, fromAccount, fromAccount)
             toAccount = self.safe_string(accountsById, toAccount, toAccount)
-        timestamp = self.safe_integer(transfer, 'timestamp')
+        walletType = self.safe_integer(transfer, 'walletType')
+        if walletType is not None:
+            payer = self.safe_dict(transfer, 'payerInfo', {})
+            receiver = self.safe_dict(transfer, 'receiverInfo', {})
+            fromAccount = self.safe_string(payer, 'accountId')
+            toAccount = self.safe_string(receiver, 'accountId')
+        timestamp = self.safe_integer_2(transfer, 'timestamp', 'transactionTime')
         status = self.parse_transfer_status(self.safe_string(transfer, 'status'))
         return {
             'info': transfer,
@@ -7699,66 +7753,133 @@ class binance(Exchange, ImplicitAPI):
         """
         fetch a history of internal transfers made on an account
         :see: https://binance-docs.github.io/apidocs/spot/en/#query-user-universal-transfer-history-user_data
+        :see: https://binance-docs.github.io/apidocs/spot/en/#pay-endpoints
         :param str code: unified currency code of the currency transferred
         :param int [since]: the earliest time in ms to fetch transfers for
         :param int [limit]: the maximum number of transfers structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param int [params.until]: the latest time in ms to fetch transfers for
         :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+        :param boolean [params.internal]: default False, when True will fetch pay trade history
         :returns dict[]: a list of `transfer structures <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
         self.load_markets()
+        internal = self.safe_bool(params, 'internal')
+        params = self.omit(params, 'internal')
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchTransfers', 'paginate')
-        if paginate:
+        if paginate and not internal:
             return self.fetch_paginated_call_dynamic('fetchTransfers', code, since, limit, params)
         currency = None
         if code is not None:
             currency = self.currency(code)
-        defaultType = self.safe_string_2(self.options, 'fetchTransfers', 'defaultType', 'spot')
-        fromAccount = self.safe_string(params, 'fromAccount', defaultType)
-        defaultTo = 'spot' if (fromAccount == 'future') else 'future'
-        toAccount = self.safe_string(params, 'toAccount', defaultTo)
-        type = self.safe_string(params, 'type')
-        accountsByType = self.safe_dict(self.options, 'accountsByType', {})
-        fromId = self.safe_string(accountsByType, fromAccount)
-        toId = self.safe_string(accountsByType, toAccount)
-        if type is None:
-            if fromId is None:
-                keys = list(accountsByType.keys())
-                raise ExchangeError(self.id + ' fromAccount parameter must be one of ' + ', '.join(keys))
-            if toId is None:
-                keys = list(accountsByType.keys())
-                raise ExchangeError(self.id + ' toAccount parameter must be one of ' + ', '.join(keys))
-            type = fromId + '_' + toId
-        request: dict = {
-            'type': type,
-        }
+        request: dict = {}
+        limitKey = 'limit'
+        if not internal:
+            defaultType = self.safe_string_2(self.options, 'fetchTransfers', 'defaultType', 'spot')
+            fromAccount = self.safe_string(params, 'fromAccount', defaultType)
+            defaultTo = 'spot' if (fromAccount == 'future') else 'future'
+            toAccount = self.safe_string(params, 'toAccount', defaultTo)
+            type = self.safe_string(params, 'type')
+            accountsByType = self.safe_dict(self.options, 'accountsByType', {})
+            fromId = self.safe_string(accountsByType, fromAccount)
+            toId = self.safe_string(accountsByType, toAccount)
+            if type is None:
+                if fromId is None:
+                    keys = list(accountsByType.keys())
+                    raise ExchangeError(self.id + ' fromAccount parameter must be one of ' + ', '.join(keys))
+                if toId is None:
+                    keys = list(accountsByType.keys())
+                    raise ExchangeError(self.id + ' toAccount parameter must be one of ' + ', '.join(keys))
+                type = fromId + '_' + toId
+            request['type'] = type
+            limitKey = 'size'
+        if limit is not None:
+            request[limitKey] = limit
         if since is not None:
             request['startTime'] = since
-        if limit is not None:
-            request['size'] = limit
         until = self.safe_integer(params, 'until')
         if until is not None:
             params = self.omit(params, 'until')
             request['endTime'] = until
-        response = self.sapiGetAssetTransfer(self.extend(request, params))
-        #
-        #     {
-        #         "total": 3,
-        #         "rows": [
-        #             {
-        #                 "timestamp": 1614640878000,
-        #                 "asset": "USDT",
-        #                 "amount": "25",
-        #                 "type": "MAIN_UMFUTURE",
-        #                 "status": "CONFIRMED",
-        #                 "tranId": 43000126248
-        #             },
-        #         ]
-        #     }
-        #
-        rows = self.safe_list(response, 'rows', [])
+        response = None
+        if internal:
+            response = self.sapiGetPayTransactions(self.extend(request, params))
+            #
+            # {
+            #     "code": "000000",
+            #     "message": "success",
+            #     "data": [
+            #     {
+            #         "orderType": "C2C",  # Enum：PAY(C2B Merchant Acquiring Payment), PAY_REFUND(C2B Merchant Acquiring Payment,refund), C2C(C2C Transfer Payment),CRYPTO_BOX(Crypto box), CRYPTO_BOX_RF(Crypto Box, refund), C2C_HOLDING(Transfer to new Binance user), C2C_HOLDING_RF(Transfer to new Binance user,refund), PAYOUT(B2C Disbursement Payment), REMITTANCE（Send cash)
+            #         "transactionId": "M_P_71505104267788288",
+            #         "transactionTime": 1610090460133,  #trade timestamp
+            #         "amount": "23.72469206",  #order amount(up to 8 decimal places), positive is income, negative is expenditure
+            #         "currency": "BNB",
+            #         "walletType": 1,  #main wallet type, 1 for funding wallet, 2 for spot wallet, 3 for fiat wallet, 4 or 6 for card payment, 5 for earn wallet
+            #         "walletTypes": [1,2],  #array format，there are multiple values when using combination payment
+            #         "fundsDetail": [ # details
+            #                 {
+            #                  "currency": "USDT",  #asset
+            #                  "amount": "1.2",
+            #                  "walletAssetCost":[ #details of asset cost per wallet
+            #                      {"1":"0.6"},
+            #                      {"2":"0.6"}
+            #                  ]
+            #                 },
+            #                 {
+            #                   "currency": "ETH",
+            #                   "amount": "0.0001",
+            #                   "walletAssetCost":[
+            #                      {"1":"0.00005"},
+            #                      {"2":"0.00005"}
+            #                   ]
+            #                 }
+            #            ],
+            #         "payerInfo":{
+            #                 "name":"Jack",  #nickname or merchant name
+            #                 "type":"USER",  #account type，USER for personal，MERCHANT for merchant
+            #                 "binanceId":"12345678",  #binance uid
+            #                 "accountId":"67736251"  #binance pay id
+            #             },
+            #         "receiverInfo":{
+            #                 "name":"Alan",  #nickname or merchant name
+            #                 "type":"MERCHANT",  #account type，USER for personal，MERCHANT for merchant
+            #                 "email":"alan@binance.com",  #email
+            #                 "binanceId":"34355667",  #binance uid
+            #                 "accountId":"21326891",  #binance pay id
+            #                 "countryCode":"1",  #International area code
+            #                 "phoneNumber":"8057651210",
+            #                 "mobileCode":"US",  #country code
+            #                 "extend":[ #extension field
+            #                      "institutionName": "",
+            #                      "cardNumber": "",
+            #                      "digitalWalletId": ""
+            #                 ]
+            #             }
+            #       }
+            #    ],
+            #    "success": True
+            # }
+            #
+        else:
+            response = self.sapiGetAssetTransfer(self.extend(request, params))
+            #
+            #     {
+            #         "total": 3,
+            #         "rows": [
+            #             {
+            #                 "timestamp": 1614640878000,
+            #                 "asset": "USDT",
+            #                 "amount": "25",
+            #                 "type": "MAIN_UMFUTURE",
+            #                 "status": "CONFIRMED",
+            #                 "tranId": 43000126248
+            #             },
+            #         ]
+            #     }
+            #
+        rows = self.safe_list_2(response, 'rows', 'data', [])
         return self.parse_transfers(rows, currency, since, limit)
 
     def fetch_deposit_address(self, code: str, params={}):

ccxt/btcmarkets.py

@@ -855,7 +855,29 @@ class btcmarkets(Exchange, ImplicitAPI):
         request: dict = {
             'ids': ids,
         }
-        return self.privateDeleteBatchordersIds(self.extend(request, params))
+        response = self.privateDeleteBatchordersIds(self.extend(request, params))
+        #
+        #    {
+        #       "cancelOrders": [
+        #            {
+        #               "orderId": "414186",
+        #               "clientOrderId": "6"
+        #            },
+        #            ...
+        #        ],
+        #        "unprocessedRequests": [
+        #            {
+        #               "code": "OrderAlreadyCancelled",
+        #               "message": "order is already cancelled.",
+        #               "requestId": "1"
+        #            }
+        #        ]
+        #    }
+        #
+        cancelOrders = self.safe_list(response, 'cancelOrders', [])
+        unprocessedRequests = self.safe_list(response, 'unprocessedRequests', [])
+        orders = self.array_concat(cancelOrders, unprocessedRequests)
+        return self.parse_orders(orders)
 
     def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
@@ -870,7 +892,14 @@ class btcmarkets(Exchange, ImplicitAPI):
         request: dict = {
             'id': id,
         }
-        return self.privateDeleteOrdersId(self.extend(request, params))
+        response = self.privateDeleteOrdersId(self.extend(request, params))
+        #
+        #    {
+        #        "orderId": "7524",
+        #        "clientOrderId": "123-456"
+        #    }
+        #
+        return self.parse_order(response)
 
     def calculate_fee(self, symbol, type, side, amount, price, takerOrMaker='taker', params={}):
         """

ccxt/coinex.py

@@ -31,7 +31,7 @@ class coinex(Exchange, ImplicitAPI):
         return self.deep_extend(super(coinex, self).describe(), {
             'id': 'coinex',
             'name': 'CoinEx',
-            'version': 'v1',
+            'version': 'v2',
             'countries': ['CN'],
             # IP ratelimit is 400 requests per second
             # rateLimit = 1000ms / 400 = 2.5
@@ -328,6 +328,8 @@ class coinex(Exchange, ImplicitAPI):
                             'futures/position-level': 1,
                             'futures/liquidation-history': 1,
                             'futures/basis-history': 1,
+                            'assets/deposit-withdraw-config': 1,
+                            'assets/all-deposit-withdraw-config': 1,
                         },
                     },
                     'private': {
@@ -350,7 +352,6 @@ class coinex(Exchange, ImplicitAPI):
                             'assets/deposit-address': 40,
                             'assets/deposit-history': 40,
                             'assets/withdraw': 40,
-                            'assets/deposit-withdraw-config': 1,
                             'assets/transfer-history': 40,
                             'spot/order-status': 8,
                             'spot/batch-order-status': 8,
@@ -544,126 +545,125 @@ class coinex(Exchange, ImplicitAPI):
         })
 
     def fetch_currencies(self, params={}) -> Currencies:
-        response = self.v1PublicGetCommonAssetConfig(params)
+        """
+        fetches all available currencies on an exchange
+        :see: https://docs.coinex.com/api/v2/assets/deposit-withdrawal/http/list-all-deposit-withdrawal-config
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an associative dictionary of currencies
+        """
+        response = self.v2PublicGetAssetsAllDepositWithdrawConfig(params)
+        #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "USDT-ERC20": {
-        #                  "asset": "USDT",
-        #                  "chain": "ERC20",
-        #                  "withdrawal_precision": 6,
-        #                  "can_deposit": True,
-        #                  "can_withdraw": True,
-        #                  "deposit_least_amount": "4.9",
-        #                  "withdraw_least_amount": "4.9",
-        #                  "withdraw_tx_fee": "4.9",
-        #                  "explorer_asset_url": "https://etherscan.io/token/0xdac17f958d2ee523a2206206994597c13d831ec7"
-        #             },
-        #             ...
-        #         },
-        #         "message": "Success",
+        #         "data": [
+        #             {
+        #                 "asset": {
+        #                     "ccy": "CET",
+        #                     "deposit_enabled": True,
+        #                     "withdraw_enabled": True,
+        #                     "inter_transfer_enabled": True,
+        #                     "is_st": False
+        #                 },
+        #                 "chains": [
+        #                     {
+        #                         "chain": "CSC",
+        #                         "min_deposit_amount": "0.8",
+        #                         "min_withdraw_amount": "8",
+        #                         "deposit_enabled": True,
+        #                         "withdraw_enabled": True,
+        #                         "deposit_delay_minutes": 0,
+        #                         "safe_confirmations": 10,
+        #                         "irreversible_confirmations": 20,
+        #                         "deflation_rate": "0",
+        #                         "withdrawal_fee": "0.026",
+        #                         "withdrawal_precision": 8,
+        #                         "memo": "",
+        #                         "is_memo_required_for_deposit": False,
+        #                         "explorer_asset_url": ""
+        #                     },
+        #                 ]
+        #             }
+        #         ],
+        #         "message": "OK"
         #     }
         #
-        data = self.safe_value(response, 'data', [])
-        coins = list(data.keys())
+        data = self.safe_list(response, 'data', [])
         result: dict = {}
-        for i in range(0, len(coins)):
-            coin = coins[i]
-            currency = data[coin]
-            currencyId = self.safe_string(currency, 'asset')
-            networkId = self.safe_string(currency, 'chain')
+        for i in range(0, len(data)):
+            coin = data[i]
+            asset = self.safe_dict(coin, 'asset', {})
+            chains = self.safe_list(coin, 'chains', [])
+            currencyId = self.safe_string(asset, 'ccy')
+            if currencyId is None:
+                continue  # coinex returns empty structures for some reason
             code = self.safe_currency_code(currencyId)
-            precisionString = self.parse_precision(self.safe_string(currency, 'withdrawal_precision'))
-            precision = self.parse_number(precisionString)
-            canDeposit = self.safe_value(currency, 'can_deposit')
-            canWithdraw = self.safe_value(currency, 'can_withdraw')
-            feeString = self.safe_string(currency, 'withdraw_tx_fee')
-            fee = self.parse_number(feeString)
-            minNetworkDepositString = self.safe_string(currency, 'deposit_least_amount')
-            minNetworkDeposit = self.parse_number(minNetworkDepositString)
-            minNetworkWithdrawString = self.safe_string(currency, 'withdraw_least_amount')
-            minNetworkWithdraw = self.parse_number(minNetworkWithdrawString)
-            if self.safe_value(result, code) is None:
-                result[code] = {
-                    'id': currencyId,
-                    'numericId': None,
-                    'code': code,
-                    'info': None,
-                    'name': None,
-                    'active': canDeposit and canWithdraw,
-                    'deposit': canDeposit,
-                    'withdraw': canWithdraw,
-                    'fee': fee,
-                    'precision': precision,
-                    'limits': {
-                        'amount': {
-                            'min': None,
-                            'max': None,
-                        },
-                        'deposit': {
-                            'min': minNetworkDeposit,
-                            'max': None,
-                        },
-                        'withdraw': {
-                            'min': minNetworkWithdraw,
-                            '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 = canDeposit if (canDeposit) else depositAvailable
-            withdrawAvailable = self.safe_value(result[code], 'withdraw')
-            withdrawAvailable = canWithdraw if (canWithdraw) else withdrawAvailable
-            minDepositString = self.safe_string(result[code]['limits']['deposit'], 'min')
-            if minNetworkDepositString is not None:
-                minDepositString = minNetworkDepositString if (minDepositString is None) else Precise.string_min(minNetworkDepositString, minDepositString)
-            minWithdrawString = self.safe_string(result[code]['limits']['withdraw'], 'min')
-            if minNetworkWithdrawString is not None:
-                minWithdrawString = minNetworkWithdrawString if (minWithdrawString is None) else Precise.string_min(minNetworkWithdrawString, minWithdrawString)
-            minPrecisionString = self.safe_string(result[code], 'precision')
-            if precisionString is not None:
-                minPrecisionString = precisionString if (minPrecisionString is None) else Precise.string_min(precisionString, minPrecisionString)
-            networks = self.safe_value(result[code], 'networks', {})
-            network: dict = {
-                'info': currency,
-                'id': networkId,
-                'network': networkId,
+            canDeposit = self.safe_bool(asset, 'deposit_enabled')
+            canWithdraw = self.safe_bool(asset, 'withdraw_enabled')
+            firstChain = self.safe_dict(chains, 0, {})
+            firstPrecisionString = self.parse_precision(self.safe_string(firstChain, 'withdrawal_precision'))
+            result[code] = {
+                'id': currencyId,
+                'code': code,
                 'name': None,
+                'active': canDeposit and canWithdraw,
+                'deposit': canDeposit,
+                'withdraw': canWithdraw,
+                'fee': None,
+                'precision': self.parse_number(firstPrecisionString),
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                     'deposit': {
-                        'min': self.safe_number(currency, 'deposit_least_amount'),
+                        'min': None,
                         'max': None,
                     },
                     'withdraw': {
-                        'min': self.safe_number(currency, 'withdraw_least_amount'),
+                        'min': None,
                         'max': None,
                     },
                 },
-                'active': canDeposit and canWithdraw,
-                'deposit': canDeposit,
-                'withdraw': canWithdraw,
-                'fee': fee,
-                'precision': precision,
+                'networks': {},
+                'info': coin,
             }
-            networks[networkId] = network
-            result[code]['networks'] = networks
-            result[code]['active'] = depositAvailable and withdrawAvailable
-            result[code]['deposit'] = depositAvailable
-            result[code]['withdraw'] = withdrawAvailable
-            info = self.safe_value(result[code], 'info', [])
-            info.append(currency)
-            result[code]['info'] = info
-            result[code]['fee'] = self.parse_number(minFeeString)
-            result[code]['precision'] = self.parse_number(minPrecisionString)
-            result[code]['limits']['deposit']['min'] = self.parse_number(minDepositString)
-            result[code]['limits']['withdraw']['min'] = self.parse_number(minWithdrawString)
+            for j in range(0, len(chains)):
+                chain = chains[j]
+                networkId = self.safe_string(chain, 'chain')
+                precisionString = self.parse_precision(self.safe_string(chain, 'withdrawal_precision'))
+                feeString = self.safe_string(chain, 'withdrawal_fee')
+                minNetworkDepositString = self.safe_string(chain, 'min_deposit_amount')
+                minNetworkWithdrawString = self.safe_string(chain, 'min_withdraw_amount')
+                canDepositChain = self.safe_bool(chain, 'deposit_enabled')
+                canWithdrawChain = self.safe_bool(chain, 'withdraw_enabled')
+                network: dict = {
+                    'id': networkId,
+                    'network': networkId,
+                    'name': None,
+                    'active': canDepositChain and canWithdrawChain,
+                    'deposit': canDepositChain,
+                    'withdraw': canWithdrawChain,
+                    'fee': self.parse_number(feeString),
+                    'precision': self.parse_number(precisionString),
+                    'limits': {
+                        'amount': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': self.parse_number(minNetworkDepositString),
+                            'max': None,
+                        },
+                        'withdraw': {
+                            'min': self.parse_number(minNetworkWithdrawString),
+                            'max': None,
+                        },
+                    },
+                    'info': chain,
+                }
+                networks = self.safe_dict(result[code], 'networks', {})
+                networks[networkId] = network
+                result[code]['networks'] = networks
         return result
 
     def fetch_markets(self, params={}) -> List[Market]:
@@ -5107,7 +5107,7 @@ class coinex(Exchange, ImplicitAPI):
         request: dict = {
             'ccy': currency['id'],
         }
-        response = self.v2PrivateGetAssetsDepositWithdrawConfig(self.extend(request, params))
+        response = self.v2PublicGetAssetsDepositWithdrawConfig(self.extend(request, params))
         #
         #     {
         #         "code": 0,

ccxt/lykke.py

@@ -858,7 +858,10 @@ class lykke(Exchange, ImplicitAPI):
         #         "error":null
         #     }
         #
-        return self.privateDeleteOrdersOrderId(self.extend(request, params))
+        response = self.privateDeleteOrdersOrderId(self.extend(request, params))
+        return self.safe_order({
+            'info': response,
+        })
 
     def cancel_all_orders(self, symbol: Str = None, params={}):
         """
@@ -882,7 +885,12 @@ class lykke(Exchange, ImplicitAPI):
         #         "error":null
         #     }
         #
-        return self.privateDeleteOrders(self.extend(request, params))
+        response = self.privateDeleteOrders(self.extend(request, params))
+        return [
+            self.safe_order({
+                'info': response,
+            }),
+        ]
 
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """

ccxt/ndax.py

@@ -1510,7 +1510,11 @@ class ndax(Exchange, ImplicitAPI):
         #         "detail":null
         #     }
         #
-        return response
+        return [
+            self.safe_order({
+                'info': response,
+            }),
+        ]
 
     def cancel_order(self, id: str, symbol: Str = None, params={}):
         """