ccxt 4.3.46__py2.py3-none-any.whl → 4.3.48__py2.py3-none-any.whl

ccxt/gate.py

@@ -797,6 +797,7 @@ class gate(Exchange, ImplicitAPI):
                     'NOT_ACCEPTABLE': BadRequest,
                     'METHOD_NOT_ALLOWED': BadRequest,
                     'NOT_FOUND': ExchangeError,
+                    'AUTHENTICATION_FAILED': AuthenticationError,
                     'INVALID_CREDENTIALS': AuthenticationError,
                     'INVALID_KEY': AuthenticationError,
                     'IP_FORBIDDEN': AuthenticationError,
@@ -3668,17 +3669,14 @@ class gate(Exchange, ImplicitAPI):
         #
         return self.parse_order(response, market)
 
-    def create_orders(self, orders: List[OrderRequest], params={}):
-        """
-        create a list of trade orders
-        :see: https://www.gate.io/docs/developers/apiv4/en/#get-a-single-order-2
-        :see: https://www.gate.io/docs/developers/apiv4/en/#create-a-batch-of-orders
-        :param Array orders: list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
-        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
-        """
-        self.load_markets()
+    def create_orders_request(self, orders: List[OrderRequest], params={}):
         ordersRequests = []
         orderSymbols = []
+        ordersLength = len(orders)
+        if ordersLength == 0:
+            raise BadRequest(self.id + ' createOrders() requires at least one order')
+        if ordersLength > 10:
+            raise BadRequest(self.id + ' createOrders() accepts a maximum of 10 orders at a time')
         for i in range(0, len(orders)):
             rawOrder = orders[i]
             marketId = self.safe_string(rawOrder, 'symbol')
@@ -3699,6 +3697,21 @@ class gate(Exchange, ImplicitAPI):
         market = self.market(symbols[0])
         if market['future'] or market['option']:
             raise NotSupported(self.id + ' createOrders() does not support futures or options markets')
+        return ordersRequests
+
+    def create_orders(self, orders: List[OrderRequest], params={}):
+        """
+        create a list of trade orders
+        :see: https://www.gate.io/docs/developers/apiv4/en/#get-a-single-order-2
+        :see: https://www.gate.io/docs/developers/apiv4/en/#create-a-batch-of-orders
+        :see: https://www.gate.io/docs/developers/apiv4/en/#create-a-batch-of-futures-orders
+        :param Array orders: list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        ordersRequests = self.create_orders_request(orders, params)
+        firstOrder = orders[0]
+        market = self.market(firstOrder['symbol'])
         response = None
         if market['spot']:
             response = self.privateSpotPostBatchOrders(ordersRequests)
@@ -3929,21 +3942,7 @@ class gate(Exchange, ImplicitAPI):
         params['createMarketBuyOrderRequiresPrice'] = False
         return self.create_order(symbol, 'market', 'buy', cost, None, params)
 
-    def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
-        """
-        edit a trade order, gate currently only supports the modification of the price or amount fields
-        :see: https://www.gate.io/docs/developers/apiv4/en/#amend-an-order
-        :see: https://www.gate.io/docs/developers/apiv4/en/#amend-an-order-2
-        :param str id: order id
-        :param str symbol: unified symbol of the market to create an order in
-        :param str type: 'market' or 'limit'
-        :param str side: 'buy' or 'sell'
-        :param float amount: how much of the currency you want to trade in units of the base currency
-        :param float [price]: the price at which the order is to be fullfilled, in units of the base currency, ignored in market orders
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
-        """
-        self.load_markets()
+    def edit_order_request(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
         market = self.market(symbol)
         marketType, query = self.handle_market_type_and_params('editOrder', market, params)
         account = self.convert_type_to_account(marketType)
@@ -3953,7 +3952,7 @@ class gate(Exchange, ImplicitAPI):
                 # exchange doesn't have market orders for spot
                 raise InvalidOrder(self.id + ' editOrder() does not support ' + type + ' orders for ' + marketType + ' markets')
         request: dict = {
-            'order_id': id,
+            'order_id': str(id),
             'currency_pair': market['id'],
             'account': account,
         }
@@ -3967,12 +3966,32 @@ class gate(Exchange, ImplicitAPI):
                     request['size'] = self.amount_to_precision(symbol, amount)
         if price is not None:
             request['price'] = self.price_to_precision(symbol, price)
+        if not market['spot']:
+            request['settle'] = market['settleId']
+        return self.extend(request, query)
+
+    def edit_order(self, id: str, symbol: str, type: OrderType, side: OrderSide, amount: Num = None, price: Num = None, params={}):
+        """
+        edit a trade order, gate currently only supports the modification of the price or amount fields
+        :see: https://www.gate.io/docs/developers/apiv4/en/#amend-an-order
+        :see: https://www.gate.io/docs/developers/apiv4/en/#amend-an-order-2
+        :param str id: order id
+        :param str symbol: unified symbol of the market to create an order in
+        :param str type: 'market' or 'limit'
+        :param str side: 'buy' or 'sell'
+        :param float amount: how much of the currency you want to trade in units of the base currency
+        :param float [price]: the price at which the order is to be fullfilled, in units of the base currency, ignored in market orders
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        extendedRequest = self.edit_order_request(id, symbol, type, side, amount, price, params)
         response = None
         if market['spot']:
-            response = self.privateSpotPatchOrdersOrderId(self.extend(request, query))
+            response = self.privateSpotPatchOrdersOrderId(extendedRequest)
         else:
-            request['settle'] = market['settleId']
-            response = self.privateFuturesPutSettleOrdersOrderId(self.extend(request, query))
+            response = self.privateFuturesPutSettleOrdersOrderId(extendedRequest)
         #
         #     {
         #         "id": "243233276443",
@@ -4273,6 +4292,23 @@ class gate(Exchange, ImplicitAPI):
             'info': order,
         }, market)
 
+    def fetch_order_request(self, id: str, symbol: Str = None, params={}):
+        market = None if (symbol is None) else self.market(symbol)
+        stop = self.safe_bool_n(params, ['trigger', 'is_stop_order', 'stop'], False)
+        params = self.omit(params, ['is_stop_order', 'stop', 'trigger'])
+        clientOrderId = self.safe_string_2(params, 'text', 'clientOrderId')
+        orderId = id
+        if clientOrderId is not None:
+            params = self.omit(params, ['text', 'clientOrderId'])
+            if clientOrderId[0] != 't':
+                clientOrderId = 't-' + clientOrderId
+            orderId = clientOrderId
+        type, query = self.handle_market_type_and_params('fetchOrder', market, params)
+        contract = (type == 'swap') or (type == 'future') or (type == 'option')
+        request, requestParams = self.prepare_request(market, type, query) if contract else self.spot_order_prepare_request(market, stop, query)
+        request['order_id'] = str(orderId)
+        return [request, requestParams]
+
     def fetch_order(self, id: str, symbol: Str = None, params={}):
         """
         Retrieves information on an order
@@ -4283,27 +4319,18 @@ class gate(Exchange, ImplicitAPI):
         :param str id: Order id
         :param str symbol: Unified market symbol, *required for spot and margin*
         :param dict [params]: Parameters specified by the exchange api
-        :param bool [params.stop]: True if the order being fetched is a trigger order
+        :param bool [params.trigger]: True if the order being fetched is a trigger order
         :param str [params.marginMode]: 'cross' or 'isolated' - marginMode for margin trading if not provided self.options['defaultMarginMode'] is used
         :param str [params.type]: 'spot', 'swap', or 'future', if not provided self.options['defaultMarginMode'] is used
         :param str [params.settle]: 'btc' or 'usdt' - settle currency for perpetual swap and future - market settle currency is used if symbol is not None, default="usdt" for swap and "btc" for future
         :returns: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        stop = self.safe_value_2(params, 'is_stop_order', 'stop', False)
-        params = self.omit(params, ['is_stop_order', 'stop'])
-        clientOrderId = self.safe_string_2(params, 'text', 'clientOrderId')
-        orderId = id
-        if clientOrderId is not None:
-            params = self.omit(params, ['text', 'clientOrderId'])
-            if clientOrderId[0] != 't':
-                clientOrderId = 't-' + clientOrderId
-            orderId = clientOrderId
         market = None if (symbol is None) else self.market(symbol)
-        type, query = self.handle_market_type_and_params('fetchOrder', market, params)
-        contract = (type == 'swap') or (type == 'future') or (type == 'option')
-        request, requestParams = self.prepare_request(market, type, query) if contract else self.spot_order_prepare_request(market, stop, query)
-        request['order_id'] = orderId
+        result = self.handle_market_type_and_params('fetchOrder', market, params)
+        type = self.safe_string(result, 0)
+        stop = self.safe_bool_n(params, ['trigger', 'is_stop_order', 'stop'], False)
+        request, requestParams = self.fetch_order_request(id, symbol, params)
         response = None
         if type == 'spot' or type == 'margin':
             if stop:
@@ -4362,14 +4389,13 @@ class gate(Exchange, ImplicitAPI):
         """
         return self.fetch_orders_by_status('finished', symbol, since, limit, params)
 
-    def fetch_orders_by_status(self, status, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
-        self.load_markets()
+    def fetch_orders_by_status_request(self, status, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         market = None
         if symbol is not None:
             market = self.market(symbol)
             symbol = market['symbol']
-        stop = self.safe_value(params, 'stop')
-        params = self.omit(params, 'stop')
+        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        params = self.omit(params, ['stop', 'trigger'])
         type, query = self.handle_market_type_and_params('fetchOrdersByStatus', market, params)
         spot = (type == 'spot') or (type == 'margin')
         request, requestParams = self.multi_order_spot_prepare_request(market, stop, query) if spot else self.prepare_request(market, type, query)
@@ -4380,6 +4406,24 @@ class gate(Exchange, ImplicitAPI):
             request['limit'] = limit
         if since is not None and spot:
             request['from'] = self.parse_to_int(since / 1000)
+        lastId, finalParams = self.handle_param_string_2(requestParams, 'lastId', 'last_id')
+        if lastId is not None:
+            request['last_id'] = lastId
+        return [request, finalParams]
+
+    def fetch_orders_by_status(self, status, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
+        self.load_markets()
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
+            symbol = market['symbol']
+        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        params = self.omit(params, ['trigger', 'stop'])
+        res = self.handle_market_type_and_params('fetchOrdersByStatus', market, params)
+        type = self.safe_string(res, 0)
+        params['type'] = type
+        request, requestParams = self.fetch_orders_by_status_request(status, symbol, since, limit, params)
+        spot = (type == 'spot') or (type == 'margin')
         openSpotOrders = spot and (status == 'open') and not stop
         response = None
         if type == 'spot' or type == 'margin':
@@ -4573,8 +4617,8 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = None if (symbol is None) else self.market(symbol)
-        stop = self.safe_value_2(params, 'is_stop_order', 'stop', False)
-        params = self.omit(params, ['is_stop_order', 'stop'])
+        stop = self.safe_bool_n(params, ['is_stop_order', 'stop', 'trigger'], False)
+        params = self.omit(params, ['is_stop_order', 'stop', 'trigger'])
         type, query = self.handle_market_type_and_params('cancelOrder', market, params)
         request, requestParams = self.spot_order_prepare_request(market, stop, query) if (type == 'spot' or type == 'margin') else self.prepare_request(market, type, query)
         request['order_id'] = id

ccxt/hyperliquid.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.hyperliquid import ImplicitAPI
-from ccxt.base.types import Balances, Currencies, Int, MarginModification, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Str, Strings, Trade, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currencies, Currency, Int, MarginModification, Market, Num, Order, OrderBook, OrderRequest, CancellationRequest, OrderSide, OrderType, Str, Strings, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -2341,6 +2341,33 @@ class hyperliquid(Exchange, ImplicitAPI):
         response = self.privatePostExchange(self.extend(request, params))
         return self.parse_transaction(response)
 
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
+        #
+        # {status: 'ok', response: {type: 'default'}}
+        #
+        return {
+            'info': transaction,
+            'id': None,
+            'txid': None,
+            'timestamp': None,
+            'datetime': None,
+            'network': None,
+            'address': None,
+            'addressTo': None,
+            'addressFrom': None,
+            'tag': None,
+            'tagTo': None,
+            'tagFrom': None,
+            'type': None,
+            'amount': None,
+            'currency': None,
+            'status': self.safe_string(transaction, 'status'),
+            'updated': None,
+            'comment': None,
+            'internal': None,
+            'fee': None,
+        }
+
     def format_vault_address(self, address: Str = None):
         if address is None:
             return None

ccxt/krakenfutures.py

@@ -136,6 +136,8 @@ class krakenfutures(Exchange, ImplicitAPI):
                         'transfers',
                         'leveragepreferences',
                         'pnlpreferences',
+                        'assignmentprogram/current',
+                        'assignmentprogram/history',
                     ],
                     'post': [
                         'sendorder',
@@ -146,6 +148,8 @@ class krakenfutures(Exchange, ImplicitAPI):
                         'cancelallorders',
                         'cancelallordersafter',
                         'withdrawal',                              # for futures wallet -> kraken spot wallet
+                        'assignmentprogram/add',
+                        'assignmentprogram/delete',
                     ],
                     'put': [
                         'leveragepreferences',

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.46'
+__version__ = '4.3.48'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bingx.py

@@ -693,14 +693,14 @@ class bingx(ccxt.async_support.bingx):
         #        ]
         #    }
         #
-        data = self.safe_list(message, 'data', [])
+        isSwap = client.url.find('swap') >= 0
         candles = None
-        if isinstance(data, list):
-            candles = data
+        if isSwap:
+            candles = self.safe_list(message, 'data', [])
         else:
-            candles = [self.safe_list(data, 'K', [])]
+            data = self.safe_dict(message, 'data', {})
+            candles = [self.safe_dict(data, 'K', {})]
         dataType = self.safe_string(message, 'dataType')
-        isSwap = client.url.find('swap') >= 0
         parts = dataType.split('@')
         firstPart = parts[0]
         isAllEndpoint = (firstPart == 'all')

ccxt/pro/coinex.py

@@ -631,12 +631,13 @@ class coinex(ccxt.async_support.coinex):
         #         "id": null
         #     }
         #
+        isSwap = client.url.find('perpetual') >= 0
+        marketType = 'swap' if isSwap else 'spot'
         params = self.safe_value(message, 'params', [])
         fullOrderBook = self.safe_value(params, 0)
         orderbook = self.safe_value(params, 1)
         marketId = self.safe_string(params, 2)
-        defaultType = self.safe_string(self.options, 'defaultType')
-        market = self.safe_market(marketId, None, None, defaultType)
+        market = self.safe_market(marketId, None, None, marketType)
         symbol = market['symbol']
         name = 'orderbook'
         messageHash = name + ':' + symbol