ccxt 4.3.41__py2.py3-none-any.whl → 4.3.43__py2.py3-none-any.whl

ccxt/async_support/coinex.py

@@ -32,7 +32,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
@@ -329,6 +329,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': {
@@ -351,7 +353,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,
@@ -545,126 +546,125 @@ class coinex(Exchange, ImplicitAPI):
         })
 
     async def fetch_currencies(self, params={}) -> Currencies:
-        response = await 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 = await 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
 
     async def fetch_markets(self, params={}) -> List[Market]:
@@ -5108,7 +5108,7 @@ class coinex(Exchange, ImplicitAPI):
         request: dict = {
             'ccy': currency['id'],
         }
-        response = await self.v2PrivateGetAssetsDepositWithdrawConfig(self.extend(request, params))
+        response = await self.v2PublicGetAssetsDepositWithdrawConfig(self.extend(request, params))
         #
         #     {
         #         "code": 0,
@@ -5440,7 +5440,7 @@ class coinex(Exchange, ImplicitAPI):
                 preparedString += nonce + self.secret
                 signature = self.hash(self.encode(preparedString), 'sha256')
                 headers = {
-                    'Content-Type': 'application/json; charset=utf-8',
+                    'Content-Type': 'application/json',
                     'Accept': 'application/json',
                     'X-COINEX-KEY': self.apiKey,
                     'X-COINEX-SIGN': signature,

ccxt/async_support/kraken.py

@@ -2008,12 +2008,22 @@ class kraken(Exchange, ImplicitAPI):
         params = self.omit(params, ['userref', 'clientOrderId'])
         try:
             response = await self.privatePostCancelOrder(self.extend(request, params))
+            #
+            #    {
+            #        error: [],
+            #        result: {
+            #            count: '1'
+            #        }
+            #    }
+            #
         except Exception as e:
             if self.last_http_response:
                 if self.last_http_response.find('EOrder:Unknown order') >= 0:
                     raise OrderNotFound(self.id + ' cancelOrder() error ' + self.last_http_response)
             raise e
-        return response
+        return self.safe_order({
+            'info': response,
+        })
 
     async def cancel_orders(self, ids, symbol: Str = None, params={}):
         """
@@ -2036,7 +2046,11 @@ class kraken(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        return response
+        return [
+            self.safe_order({
+                'info': response,
+            }),
+        ]
 
     async def cancel_all_orders(self, symbol: Str = None, params={}):
         """
@@ -2047,7 +2061,20 @@ class kraken(Exchange, ImplicitAPI):
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        return await self.privatePostCancelAll(params)
+        response = await self.privatePostCancelAll(params)
+        #
+        #    {
+        #        error: [],
+        #        result: {
+        #            count: '1'
+        #        }
+        #    }
+        #
+        return [
+            self.safe_order({
+                'info': response,
+            }),
+        ]
 
     async def cancel_all_orders_after(self, timeout: Int, params={}):
         """

ccxt/async_support/krakenfutures.py

@@ -1207,7 +1207,45 @@ class krakenfutures(Exchange, ImplicitAPI):
         if symbol is not None:
             request['symbol'] = self.market_id(symbol)
         response = await self.privatePostCancelallorders(self.extend(request, params))
-        return response
+        #
+        #    {
+        #        result: 'success',
+        #        cancelStatus: {
+        #          receivedTime: '2024-06-06T01:12:44.814Z',
+        #          cancelOnly: 'PF_XRPUSD',
+        #          status: 'cancelled',
+        #          cancelledOrders: [{order_id: '272fd0ac-45c0-4003-b84d-d39b9e86bd36'}],
+        #          orderEvents: [
+        #            {
+        #              uid: '272fd0ac-45c0-4003-b84d-d39b9e86bd36',
+        #              order: {
+        #                orderId: '272fd0ac-45c0-4003-b84d-d39b9e86bd36',
+        #                cliOrdId: null,
+        #                type: 'lmt',
+        #                symbol: 'PF_XRPUSD',
+        #                side: 'buy',
+        #                quantity: '10',
+        #                filled: '0',
+        #                limitPrice: '0.4',
+        #                reduceOnly: False,
+        #                timestamp: '2024-06-06T01:11:16.045Z',
+        #                lastUpdateTimestamp: '2024-06-06T01:11:16.045Z'
+        #              },
+        #              type: 'CANCEL'
+        #            }
+        #          ]
+        #        },
+        #        serverTime: '2024-06-06T01:12:44.814Z'
+        #    }
+        #
+        cancelStatus = self.safe_dict(response, 'cancelStatus')
+        orderEvents = self.safe_list(cancelStatus, 'orderEvents', [])
+        orders = []
+        for i in range(0, len(orderEvents)):
+            orderEvent = self.safe_dict(orderEvents, 0)
+            order = self.safe_dict(orderEvent, 'order', {})
+            orders.append(order)
+        return self.parse_orders(orders)
 
     async def cancel_all_orders_after(self, timeout: Int, params={}):
         """
@@ -1551,6 +1589,22 @@ class krakenfutures(Exchange, ImplicitAPI):
         #        ]
         #    }
         #
+        # cancelAllOrders
+        #
+        #    {
+        #        "orderId": "85c40002-3f20-4e87-9302-262626c3531b",
+        #        "cliOrdId": null,
+        #        "type": "lmt",
+        #        "symbol": "pi_xbtusd",
+        #        "side": "buy",
+        #        "quantity": 1000,
+        #        "filled": 0,
+        #        "limitPrice": 10144,
+        #        "stopPrice": null,
+        #        "reduceOnly": False,
+        #        "timestamp": "2019-08-01T15:26:27.790Z"
+        #    }
+        #
         # FETCH OPEN ORDERS
         #
         #    {

ccxt/async_support/kucoin.py

@@ -2238,19 +2238,76 @@ class kucoin(Exchange, ImplicitAPI):
             request['clientOid'] = clientOrderId
             if stop:
                 response = await self.privateDeleteStopOrderCancelOrderByClientOid(self.extend(request, params))
+                #
+                #    {
+                #        code: '200000',
+                #        data: {
+                #          cancelledOrderId: 'vs8lgpiuao41iaft003khbbk',
+                #          clientOid: '123456'
+                #        }
+                #    }
+                #
             elif hf:
                 response = await self.privateDeleteHfOrdersClientOrderClientOid(self.extend(request, params))
+                #
+                #    {
+                #        "code": "200000",
+                #        "data": {
+                #          "clientOid": "6d539dc614db3"
+                #        }
+                #    }
+                #
             else:
                 response = await self.privateDeleteOrderClientOrderClientOid(self.extend(request, params))
+                #
+                #    {
+                #        code: '200000',
+                #        data: {
+                #          cancelledOrderId: '665e580f6660500007aba341',
+                #          clientOid: '1234567',
+                #          cancelledOcoOrderIds: null
+                #        }
+                #    }
+                #
+            response = self.safe_dict(response, 'data')
+            return self.parse_order(response)
         else:
             request['orderId'] = id
             if stop:
                 response = await self.privateDeleteStopOrderOrderId(self.extend(request, params))
+                #
+                #    {
+                #        code: '200000',
+                #        data: {cancelledOrderIds: ['vs8lgpiuaco91qk8003vebu9']}
+                #    }
+                #
             elif hf:
                 response = await self.privateDeleteHfOrdersOrderId(self.extend(request, params))
+                #
+                #    {
+                #        "code": "200000",
+                #        "data": {
+                #          "orderId": "630625dbd9180300014c8d52"
+                #        }
+                #    }
+                #
+                response = self.safe_dict(response, 'data')
+                return self.parse_order(response)
             else:
                 response = await self.privateDeleteOrdersOrderId(self.extend(request, params))
-        return response
+                #
+                #    {
+                #        code: '200000',
+                #        data: {cancelledOrderIds: ['665e4fbe28051a0007245c41']}
+                #    }
+                #
+            data = self.safe_dict(response, 'data')
+            orderIds = self.safe_list(data, 'cancelledOrderIds', [])
+            orderId = self.safe_string(orderIds, 0)
+            return self.safe_order({
+                'info': data,
+                'id': orderId,
+            })
 
     async def cancel_all_orders(self, symbol: Str = None, params={}):
         """
@@ -2664,7 +2721,7 @@ class kucoin(Exchange, ImplicitAPI):
         stopPrice = self.safe_number(order, 'stopPrice')
         return self.safe_order({
             'info': order,
-            'id': self.safe_string_n(order, ['id', 'orderId', 'newOrderId']),
+            'id': self.safe_string_n(order, ['id', 'orderId', 'newOrderId', 'cancelledOrderId']),
             'clientOrderId': self.safe_string(order, 'clientOid'),
             'symbol': self.safe_symbol(marketId, market, '-'),
             'type': self.safe_string(order, 'type'),

ccxt/async_support/phemex.py

@@ -21,7 +21,6 @@ from ccxt.base.errors import InvalidOrder
 from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import CancelPending
 from ccxt.base.errors import DuplicateOrderId
-from ccxt.base.errors import NotSupported
 from ccxt.base.errors import DDoSProtection
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.decimal_to_precision import TICK_SIZE
@@ -2772,6 +2771,7 @@ class phemex(Exchange, ImplicitAPI):
 
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
+        :see: https://phemex-docs.github.io/#query-orders-by-ids
         fetches information on an order made by the user
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -2781,8 +2781,6 @@ class phemex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchOrder() requires a symbol argument')
         await self.load_markets()
         market = self.market(symbol)
-        if market['settle'] == 'USDT':
-            raise NotSupported(self.id + 'fetchOrder() is not supported yet for USDT settled swap markets')  # https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#query-user-order-by-orderid-or-query-user-order-by-client-order-id
         request: dict = {
             'symbol': market['id'],
         }
@@ -2793,7 +2791,9 @@ class phemex(Exchange, ImplicitAPI):
         else:
             request['orderID'] = id
         response = None
-        if market['spot']:
+        if market['settle'] == 'USDT':
+            response = await self.privateGetApiDataGFuturesOrdersByOrderId(self.extend(request, params))
+        elif market['spot']:
             response = await self.privateGetSpotOrdersActive(self.extend(request, params))
         else:
             response = await self.privateGetExchangeOrder(self.extend(request, params))

ccxt/async_support/tradeogre.py

@@ -9,6 +9,7 @@ from ccxt.base.types import IndexType, Int, Market, Num, Order, OrderSide, Order
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
+from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InsufficientFunds
 from ccxt.base.decimal_to_precision import TICK_SIZE
@@ -441,7 +442,7 @@ class tradeogre(Exchange, ImplicitAPI):
         """
         create a trade order
         :param str symbol: unified symbol of the market to create an order in
-        :param str type: not used by tradeogre
+        :param str type: must be 'limit'
         :param str side: 'buy' or 'sell'
         :param float amount: how much of currency you want to trade in units of base currency
         :param float price: the price at which the order is to be fullfilled, in units of the quote currency
@@ -450,13 +451,15 @@ class tradeogre(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
+        if type == 'market':
+            raise BadRequest(self.id + ' createOrder does not support market orders')
+        if price is None:
+            raise ArgumentsRequired(self.id + ' createOrder requires a limit parameter')
         request: dict = {
             'market': market['id'],
             'quantity': self.parse_to_numeric(self.amount_to_precision(symbol, amount)),
             'price': self.parse_to_numeric(self.price_to_precision(symbol, price)),
         }
-        if type == 'market':
-            raise BadRequest(self.id + ' createOrder does not support market orders')
         response = None
         if side == 'buy':
             response = await self.privatePostOrderBuy(self.extend(request, params))
@@ -487,7 +490,10 @@ class tradeogre(Exchange, ImplicitAPI):
         :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        return await self.cancel_order('all', symbol, params)
+        response = await self.cancel_order('all', symbol, params)
+        return [
+            response,
+        ]
 
     async def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """

ccxt/async_support/wavesexchange.py

@@ -1422,7 +1422,7 @@ class wavesexchange(Exchange, ImplicitAPI):
         firstMessage = self.safe_value(message, 0)
         firstOrder = self.safe_value(firstMessage, 0)
         returnedId = self.safe_string(firstOrder, 'orderId')
-        return {
+        return self.safe_order({
             'info': response,
             'id': returnedId,
             'clientOrderId': None,
@@ -1441,7 +1441,7 @@ class wavesexchange(Exchange, ImplicitAPI):
             'status': None,
             'fee': None,
             'trades': None,
-        }
+        })
 
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
         """