ccxt 4.4.64__py2.py3-none-any.whl → 4.4.67__py2.py3-none-any.whl

ccxt/gate.py

@@ -1946,7 +1946,11 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         symbols = self.market_symbols(symbols)
-        request, query = self.prepare_request(None, 'swap', params)
+        market = None
+        if symbols is not None:
+            firstSymbol = self.safe_string(symbols, 0)
+            market = self.market(firstSymbol)
+        request, query = self.prepare_request(market, 'swap', params)
         response = self.publicFuturesGetSettleContracts(self.extend(request, query))
         #
         #    [

ccxt/htx.py

@@ -909,6 +909,7 @@ class htx(Exchange, ImplicitAPI):
                     '1041': InvalidOrder,  # {"status":"error","err_code":1041,"err_msg":"The order amount exceeds the limit(170000Cont), please modify and order again.","ts":1643802784940}
                     '1047': InsufficientFunds,  # {"status":"error","err_code":1047,"err_msg":"Insufficient margin available.","ts":1643802672652}
                     '1048': InsufficientFunds,  # {"status":"error","err_code":1048,"err_msg":"Insufficient close amount available.","ts":1652772408864}
+                    '1061': OrderNotFound,  # {"status":"ok","data":{"errors":[{"order_id":"1349442392365359104","err_code":1061,"err_msg":"The order does not exist."}],"successes":""},"ts":1741773744526}
                     '1051': InvalidOrder,  # {"status":"error","err_code":1051,"err_msg":"No orders to cancel.","ts":1652552125876}
                     '1066': BadSymbol,  # {"status":"error","err_code":1066,"err_msg":"The symbol field cannot be empty. Please re-enter.","ts":1640550819147}
                     '1067': InvalidOrder,  # {"status":"error","err_code":1067,"err_msg":"The client_order_id field is invalid. Please re-enter.","ts":1643802119413}
@@ -6756,14 +6757,17 @@ class htx(Exchange, ImplicitAPI):
         """
         self.load_markets()
         symbols = self.market_symbols(symbols)
-        options = self.safe_value(self.options, 'fetchFundingRates', {})
-        defaultSubType = self.safe_string(self.options, 'defaultSubType', 'inverse')
-        subType = self.safe_string(options, 'subType', defaultSubType)
-        subType = self.safe_string(params, 'subType', subType)
+        defaultSubType = self.safe_string(self.options, 'defaultSubType', 'linear')
+        subType = None
+        subType, params = self.handle_option_and_params(params, 'fetchFundingRates', 'subType', defaultSubType)
+        if symbols is not None:
+            firstSymbol = self.safe_string(symbols, 0)
+            market = self.market(firstSymbol)
+            isLinear = market['linear']
+            subType = 'linear' if isLinear else 'inverse'
         request: dict = {
             # 'contract_code': market['id'],
         }
-        params = self.omit(params, 'subType')
         response = None
         if subType == 'linear':
             response = self.contractPublicGetLinearSwapApiV1SwapBatchFundingRate(self.extend(request, params))
@@ -7031,6 +7035,7 @@ class htx(Exchange, ImplicitAPI):
         if 'status' in response:
             #
             #     {"status":"error","err-code":"order-limitorder-amount-min-error","err-msg":"limit order amount error, min: `0.001`","data":null}
+            #     {"status":"ok","data":{"errors":[{"order_id":"1349442392365359104","err_code":1061,"err_msg":"The order does not exist."}],"successes":""},"ts":1741773744526}
             #
             status = self.safe_string(response, 'status')
             if status == 'error':
@@ -7046,6 +7051,15 @@ class htx(Exchange, ImplicitAPI):
             feedback = self.id + ' ' + body
             code = self.safe_string(response, 'code')
             self.throw_exactly_matched_exception(self.exceptions['exact'], code, feedback)
+        data = self.safe_dict(response, 'data')
+        errorsList = self.safe_list(data, 'errors')
+        if errorsList is not None:
+            first = self.safe_dict(errorsList, 0)
+            errcode = self.safe_string(first, 'err_code')
+            errmessage = self.safe_string(first, 'err_msg')
+            feedBack = self.id + ' ' + body
+            self.throw_exactly_matched_exception(self.exceptions['exact'], errcode, feedBack)
+            self.throw_exactly_matched_exception(self.exceptions['exact'], errmessage, feedBack)
         return None
 
     def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):

ccxt/hyperliquid.py

@@ -60,6 +60,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 'createStopOrder': True,
                 'createTriggerOrder': True,
                 'editOrder': True,
+                'editOrders': True,
                 'fetchAccounts': False,
                 'fetchBalance': True,
                 'fetchBorrowInterest': False,
@@ -1355,7 +1356,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        order, globalParams = self.parse_create_order_args(symbol, type, side, amount, price, params)
+        order, globalParams = self.parse_create_edit_order_args(None, symbol, type, side, amount, price, params)
         orders = self.create_orders([order], globalParams)
         return orders[0]
 
@@ -1709,74 +1710,97 @@ class hyperliquid(Exchange, ImplicitAPI):
         #
         return response
 
-    def edit_order_request(self, id: str, symbol: str, type: str, side: str, amount: Num = None, price: Num = None, params={}):
+    def edit_orders_request(self, orders, params={}):
         self.check_required_credentials()
-        if id is None:
-            raise ArgumentsRequired(self.id + ' editOrder() requires an id argument')
-        market = self.market(symbol)
-        type = type.upper()
-        isMarket = (type == 'MARKET')
-        side = side.upper()
-        isBuy = (side == 'BUY')
-        defaultSlippage = self.safe_string(self.options, 'defaultSlippage')
-        slippage = self.safe_string(params, 'slippage', defaultSlippage)
-        defaultTimeInForce = 'ioc' if (isMarket) else 'gtc'
-        postOnly = self.safe_bool(params, 'postOnly', False)
-        if postOnly:
-            defaultTimeInForce = 'alo'
-        timeInForce = self.safe_string_lower(params, 'timeInForce', defaultTimeInForce)
-        timeInForce = self.capitalize(timeInForce)
-        clientOrderId = self.safe_string_2(params, 'clientOrderId', 'client_id')
-        triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
-        stopLossPrice = self.safe_string(params, 'stopLossPrice', triggerPrice)
-        takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
-        isTrigger = (stopLossPrice or takeProfitPrice)
-        params = self.omit(params, ['slippage', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'clientOrderId', 'client_id'])
-        px = str(price)
-        if isMarket:
-            px = str(Precise.string_mul(price), Precise.string_add('1', slippage)) if (isBuy) else str(Precise.string_mul(price), Precise.string_sub('1', slippage))
-        else:
-            px = self.price_to_precision(symbol, str(price))
-        sz = self.amount_to_precision(symbol, amount)
-        reduceOnly = self.safe_bool(params, 'reduceOnly', False)
-        orderType: dict = {}
-        if isTrigger:
-            isTp = False
-            if takeProfitPrice is not None:
-                triggerPrice = self.price_to_precision(symbol, takeProfitPrice)
-                isTp = True
+        hasClientOrderId = False
+        for i in range(0, len(orders)):
+            rawOrder = orders[i]
+            orderParams = self.safe_dict(rawOrder, 'params', {})
+            clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
+            if clientOrderId is not None:
+                hasClientOrderId = True
+        if hasClientOrderId:
+            for i in range(0, len(orders)):
+                rawOrder = orders[i]
+                orderParams = self.safe_dict(rawOrder, 'params', {})
+                clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
+                if clientOrderId is None:
+                    raise ArgumentsRequired(self.id + ' editOrders() all orders must have clientOrderId if at least one has a clientOrderId')
+        params = self.omit(params, ['slippage', 'clientOrderId', 'client_id', 'slippage', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'timeInForce'])
+        modifies = []
+        for i in range(0, len(orders)):
+            rawOrder = orders[i]
+            id = self.safe_string(rawOrder, 'id')
+            marketId = self.safe_string(rawOrder, 'symbol')
+            market = self.market(marketId)
+            symbol = market['symbol']
+            type = self.safe_string_upper(rawOrder, 'type')
+            isMarket = (type == 'MARKET')
+            side = self.safe_string_upper(rawOrder, 'side')
+            isBuy = (side == 'BUY')
+            amount = self.safe_string(rawOrder, 'amount')
+            price = self.safe_string(rawOrder, 'price')
+            orderParams = self.safe_dict(rawOrder, 'params', {})
+            defaultSlippage = self.safe_string(self.options, 'defaultSlippage')
+            slippage = self.safe_string(orderParams, 'slippage', defaultSlippage)
+            defaultTimeInForce = 'ioc' if (isMarket) else 'gtc'
+            postOnly = self.safe_bool(orderParams, 'postOnly', False)
+            if postOnly:
+                defaultTimeInForce = 'alo'
+            timeInForce = self.safe_string_lower(orderParams, 'timeInForce', defaultTimeInForce)
+            timeInForce = self.capitalize(timeInForce)
+            clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
+            triggerPrice = self.safe_string_2(orderParams, 'triggerPrice', 'stopPrice')
+            stopLossPrice = self.safe_string(orderParams, 'stopLossPrice', triggerPrice)
+            takeProfitPrice = self.safe_string(orderParams, 'takeProfitPrice')
+            isTrigger = (stopLossPrice or takeProfitPrice)
+            reduceOnly = self.safe_bool(orderParams, 'reduceOnly', False)
+            orderParams = self.omit(orderParams, ['slippage', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'clientOrderId', 'client_id', 'postOnly', 'reduceOnly'])
+            px = str(price)
+            if isMarket:
+                px = str(Precise.string_mul(price), Precise.string_add('1', slippage)) if (isBuy) else str(Precise.string_mul(price), Precise.string_sub('1', slippage))
             else:
-                triggerPrice = self.price_to_precision(symbol, stopLossPrice)
-            orderType['trigger'] = {
-                'isMarket': isMarket,
-                'triggerPx': triggerPrice,
-                'tpsl': 'tp' if (isTp) else 'sl',
+                px = self.price_to_precision(symbol, str(price))
+            sz = self.amount_to_precision(symbol, amount)
+            orderType: dict = {}
+            if isTrigger:
+                isTp = False
+                if takeProfitPrice is not None:
+                    triggerPrice = self.price_to_precision(symbol, takeProfitPrice)
+                    isTp = True
+                else:
+                    triggerPrice = self.price_to_precision(symbol, stopLossPrice)
+                orderType['trigger'] = {
+                    'isMarket': isMarket,
+                    'triggerPx': triggerPrice,
+                    'tpsl': 'tp' if (isTp) else 'sl',
+                }
+            else:
+                orderType['limit'] = {
+                    'tif': timeInForce,
+                }
+            if triggerPrice is None:
+                triggerPrice = '0'
+            orderReq: dict = {
+                'a': self.parse_to_int(market['baseId']),
+                'b': isBuy,
+                'p': px,
+                's': sz,
+                'r': reduceOnly,
+                't': orderType,
+                # 'c': clientOrderId,
             }
-        else:
-            orderType['limit'] = {
-                'tif': timeInForce,
+            if clientOrderId is not None:
+                orderReq['c'] = clientOrderId
+            modifyReq: dict = {
+                'oid': self.parse_to_int(id),
+                'order': orderReq,
             }
-        if triggerPrice is None:
-            triggerPrice = '0'
+            modifies.append(modifyReq)
         nonce = self.milliseconds()
-        orderReq: dict = {
-            'a': self.parse_to_int(market['baseId']),
-            'b': isBuy,
-            'p': px,
-            's': sz,
-            'r': reduceOnly,
-            't': orderType,
-            # 'c': clientOrderId,
-        }
-        if clientOrderId is not None:
-            orderReq['c'] = clientOrderId
-        modifyReq: dict = {
-            'oid': self.parse_to_int(id),
-            'order': orderReq,
-        }
         modifyAction: dict = {
             'type': 'batchModify',
-            'modifies': [modifyReq],
+            'modifies': modifies,
         }
         vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(modifyAction, nonce, vaultAddress)
@@ -1795,7 +1819,6 @@ class hyperliquid(Exchange, ImplicitAPI):
         """
         edit a trade order
 
-        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-an-order
         https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-multiple-orders
 
         :param str id: cancel order id
@@ -1814,8 +1837,24 @@ class hyperliquid(Exchange, ImplicitAPI):
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        market = self.market(symbol)
-        request = self.edit_order_request(id, symbol, type, side, amount, price, params)
+        if id is None:
+            raise ArgumentsRequired(self.id + ' editOrder() requires an id argument')
+        order, globalParams = self.parse_create_edit_order_args(id, symbol, type, side, amount, price, params)
+        orders = self.edit_orders([order], globalParams)
+        return orders[0]
+
+    def edit_orders(self, orders: List[OrderRequest], params={}):
+        """
+        edit a list of trade orders
+
+        https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-multiple-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
+        :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()
+        request = self.edit_orders_request(orders, params)
         response = self.privatePostExchange(request)
         #
         #     {
@@ -1855,8 +1894,7 @@ class hyperliquid(Exchange, ImplicitAPI):
         responseObject = self.safe_dict(response, 'response', {})
         dataObject = self.safe_dict(responseObject, 'data', {})
         statuses = self.safe_list(dataObject, 'statuses', [])
-        first = self.safe_dict(statuses, 0, {})
-        return self.parse_order(first, market)
+        return self.parse_orders(statuses)
 
     def fetch_funding_rate_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
@@ -3386,7 +3424,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 return byType[type]
         return self.safe_value(config, 'cost', 1)
 
-    def parse_create_order_args(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
+    def parse_create_edit_order_args(self, id: Str, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         market = self.market(symbol)
         vaultAddress = self.safe_string(params, 'vaultAddress')
         params = self.omit(params, 'vaultAddress')
@@ -3402,4 +3440,6 @@ class hyperliquid(Exchange, ImplicitAPI):
         globalParams = {}
         if vaultAddress is not None:
             globalParams['vaultAddress'] = vaultAddress
+        if id is not None:
+            order['id'] = id
         return [order, globalParams]

ccxt/paradex.py

@@ -1170,6 +1170,10 @@ class paradex(Exchange, ImplicitAPI):
         average = self.omit_zero(self.safe_string(order, 'avg_fill_price'))
         remaining = self.omit_zero(self.safe_string(order, 'remaining_size'))
         lastUpdateTimestamp = self.safe_integer(order, 'last_updated_at')
+        flags = self.safe_list(order, 'flags', [])
+        reduceOnly = None
+        if 'REDUCE_ONLY' in flags:
+            reduceOnly = True
         return self.safe_order({
             'id': orderId,
             'clientOrderId': clientOrderId,
@@ -1182,7 +1186,7 @@ class paradex(Exchange, ImplicitAPI):
             'type': self.parse_order_type(orderType),
             'timeInForce': self.parse_time_in_force(self.safe_string(order, 'instrunction')),
             'postOnly': None,
-            'reduceOnly': None,
+            'reduceOnly': reduceOnly,
             'side': side,
             'price': price,
             'triggerPrice': self.safe_string(order, 'trigger_price'),
@@ -1250,6 +1254,8 @@ class paradex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param float [params.stopPrice]: alias for triggerPrice
         :param float [params.triggerPrice]: The price a trigger order is triggered at
+        :param float [params.stopLossPrice]: the price that a stop loss order is triggered at
+        :param float [params.takeProfitPrice]: the price that a take profit order is triggered at
         :param str [params.timeInForce]: "GTC", "IOC", or "POST_ONLY"
         :param bool [params.postOnly]: True or False
         :param bool [params.reduceOnly]: Ensures that the executed order does not flip the opened position.
@@ -1265,11 +1271,15 @@ class paradex(Exchange, ImplicitAPI):
         request: dict = {
             'market': market['id'],
             'side': orderSide,
-            'type': orderType,  # LIMIT/MARKET/STOP_LIMIT/STOP_MARKET
-            'size': self.amount_to_precision(symbol, amount),
+            'type': orderType,  # LIMIT/MARKET/STOP_LIMIT/STOP_MARKET,STOP_LOSS_MARKET,STOP_LOSS_LIMIT,TAKE_PROFIT_MARKET,TAKE_PROFIT_LIMIT
         }
         triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
+        stopLossPrice = self.safe_string(params, 'stopLossPrice')
+        takeProfitPrice = self.safe_string(params, 'takeProfitPrice')
         isMarket = orderType == 'MARKET'
+        isTakeProfitOrder = (takeProfitPrice is not None)
+        isStopLossOrder = (stopLossPrice is not None)
+        isStopOrder = (triggerPrice is not None) or isTakeProfitOrder or isStopLossOrder
         timeInForce = self.safe_string_upper(params, 'timeInForce')
         postOnly = self.is_post_only(isMarket, None, params)
         if not isMarket:
@@ -1277,22 +1287,51 @@ class paradex(Exchange, ImplicitAPI):
                 request['instruction'] = 'POST_ONLY'
             elif timeInForce == 'ioc':
                 request['instruction'] = 'IOC'
-        if reduceOnly:
-            request['flags'] = [
-                'REDUCE_ONLY',
-            ]
         if price is not None:
             request['price'] = self.price_to_precision(symbol, price)
         clientOrderId = self.safe_string_n(params, ['clOrdID', 'clientOrderId', 'client_order_id'])
         if clientOrderId is not None:
             request['client_id'] = clientOrderId
-        if triggerPrice is not None:
+        sizeString = '0'
+        stopPrice = None
+        if isStopOrder:
+            # flags: Reduce_Only must be provided for TPSL orders.
             if isMarket:
-                request['type'] = 'STOP_MARKET'
+                if isStopLossOrder:
+                    stopPrice = self.price_to_precision(symbol, stopLossPrice)
+                    reduceOnly = True
+                    request['type'] = 'STOP_LOSS_MARKET'
+                elif isTakeProfitOrder:
+                    stopPrice = self.price_to_precision(symbol, takeProfitPrice)
+                    reduceOnly = True
+                    request['type'] = 'TAKE_PROFIT_MARKET'
+                else:
+                    stopPrice = self.price_to_precision(symbol, triggerPrice)
+                    sizeString = self.amount_to_precision(symbol, amount)
+                    request['type'] = 'STOP_MARKET'
             else:
-                request['type'] = 'STOP_LIMIT'
-            request['trigger_price'] = self.price_to_precision(symbol, triggerPrice)
-        params = self.omit(params, ['reduceOnly', 'reduce_only', 'clOrdID', 'clientOrderId', 'client_order_id', 'postOnly', 'timeInForce', 'stopPrice', 'triggerPrice'])
+                if isStopLossOrder:
+                    stopPrice = self.price_to_precision(symbol, stopLossPrice)
+                    reduceOnly = True
+                    request['type'] = 'STOP_LOSS_LIMIT'
+                elif isTakeProfitOrder:
+                    stopPrice = self.price_to_precision(symbol, takeProfitPrice)
+                    reduceOnly = True
+                    request['type'] = 'TAKE_PROFIT_LIMIT'
+                else:
+                    stopPrice = self.price_to_precision(symbol, triggerPrice)
+                    sizeString = self.amount_to_precision(symbol, amount)
+                    request['type'] = 'STOP_LIMIT'
+        else:
+            sizeString = self.amount_to_precision(symbol, amount)
+        if stopPrice is not None:
+            request['trigger_price'] = stopPrice
+        request['size'] = sizeString
+        if reduceOnly:
+            request['flags'] = [
+                'REDUCE_ONLY',
+            ]
+        params = self.omit(params, ['reduceOnly', 'reduce_only', 'clOrdID', 'clientOrderId', 'client_order_id', 'postOnly', 'timeInForce', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice'])
         account = self.retrieve_account()
         now = self.nonce()
         orderReq = {

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.64'
+__version__ = '4.4.67'
 
 # ----------------------------------------------------------------------------
 
@@ -45,9 +45,9 @@ from ccxt.pro.coincheck import coincheck                                  # noqa
 from ccxt.pro.coinex import coinex                                        # noqa: F401
 from ccxt.pro.coinone import coinone                                      # noqa: F401
 from ccxt.pro.cryptocom import cryptocom                                  # noqa: F401
-from ccxt.pro.currencycom import currencycom                              # noqa: F401
 from ccxt.pro.defx import defx                                            # noqa: F401
 from ccxt.pro.deribit import deribit                                      # noqa: F401
+from ccxt.pro.derive import derive                                        # noqa: F401
 from ccxt.pro.exmo import exmo                                            # noqa: F401
 from ccxt.pro.gate import gate                                            # noqa: F401
 from ccxt.pro.gateio import gateio                                        # noqa: F401
@@ -121,9 +121,9 @@ exchanges = [
     'coinex',
     'coinone',
     'cryptocom',
-    'currencycom',
     'defx',
     'deribit',
+    'derive',
     'exmo',
     'gate',
     'gateio',

ccxt/pro/bybit.py

@@ -767,7 +767,7 @@ class bybit(ccxt.async_support.bybit):
             self.ohlcvs[symbol][timeframe] = ArrayCacheByTimestamp(limit)
         stored = self.ohlcvs[symbol][timeframe]
         for i in range(0, len(data)):
-            parsed = self.parse_ws_ohlcv(data[i])
+            parsed = self.parse_ws_ohlcv(data[i], market)
             stored.append(parsed)
         messageHash = 'ohlcv::' + symbol + '::' + timeframe
         resolveData = [symbol, timeframe, stored]
@@ -789,13 +789,14 @@ class bybit(ccxt.async_support.bybit):
         #         "timestamp": 1670363219614
         #     }
         #
+        volumeIndex = 'turnover' if (market['inverse']) else 'volume'
         return [
             self.safe_integer(ohlcv, 'start'),
             self.safe_number(ohlcv, 'open'),
             self.safe_number(ohlcv, 'high'),
             self.safe_number(ohlcv, 'low'),
             self.safe_number(ohlcv, 'close'),
-            self.safe_number_2(ohlcv, 'volume', 'turnover'),
+            self.safe_number(ohlcv, volumeIndex),
         ]
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook: