ccxt 3.0.96__tar.gz → 3.0.98__tar.gz

{ccxt-3.0.96/ccxt.egg-info → ccxt-3.0.98}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 3.0.96
+Version: 3.0.98
 Summary: A JavaScript / Python / PHP cryptocurrency trading library with support for 130+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -231,13 +231,13 @@ Description: # CCXT – CryptoCurrency eXchange Trading Library
         
         All-in-one browser bundle (dependencies included), served from a CDN of your choice:
         
-        * jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@3.0.96/dist/ccxt.browser.js
-        * unpkg: https://unpkg.com/ccxt@3.0.96/dist/ccxt.browser.js
+        * jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@3.0.98/dist/ccxt.browser.js
+        * unpkg: https://unpkg.com/ccxt@3.0.98/dist/ccxt.browser.js
         
         CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
         
         ```HTML
-        <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@3.0.96/dist/ccxt.browser.js"></script>
+        <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@3.0.98/dist/ccxt.browser.js"></script>
         ```
         
         Creates a global `ccxt` object:

{ccxt-3.0.96 → ccxt-3.0.98}/ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '3.0.96'
+__version__ = '3.0.98'
 
 # ----------------------------------------------------------------------------
 

{ccxt-3.0.96 → ccxt-3.0.98}/ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '3.0.96'
+__version__ = '3.0.98'
 
 # -----------------------------------------------------------------------------
 

{ccxt-3.0.96 → ccxt-3.0.98}/ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '3.0.96'
+__version__ = '3.0.98'
 
 # -----------------------------------------------------------------------------
 

{ccxt-3.0.96 → ccxt-3.0.98}/ccxt/async_support/coinex.py

@@ -1679,6 +1679,12 @@ class coinex(Exchange, ImplicitAPI):
     async def create_order(self, symbol: str, type, side: OrderSide, amount, price=None, params={}):
         """
         create a trade order
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http017_put_limit
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http018_put_market
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http019_put_limit_stop
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http020_put_market_stop
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http031_market_close
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http030_limit_close
         :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'
@@ -1692,6 +1698,7 @@ class coinex(Exchange, ImplicitAPI):
         :param str params['timeInForce']: "GTC", "IOC", "FOK", "PO"
         :param bool params.postOnly:
         :param bool params.reduceOnly:
+        :param bool|None params['position_id']: *required for reduce only orders* the position id to reduce
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
@@ -1706,9 +1713,11 @@ class coinex(Exchange, ImplicitAPI):
         positionId = self.safe_integer_2(params, 'position_id', 'positionId')  # Required for closing swap positions
         timeInForceRaw = self.safe_string(params, 'timeInForce')  # Spot: IOC, FOK, PO, GTC, ... NORMAL(default), MAKER_ONLY
         reduceOnly = self.safe_value(params, 'reduceOnly')
-        if reduceOnly is not None:
+        if reduceOnly:
             if market['type'] != 'swap':
                 raise InvalidOrder(self.id + ' createOrder() does not support reduceOnly for ' + market['type'] + ' orders, reduceOnly orders are supported for swap markets only')
+            if positionId is None:
+                raise ArgumentsRequired(self.id + ' createOrder() requires a position_id/positionId parameter for reduceOnly orders')
         method = None
         request = {
             'market': market['id'],

{ccxt-3.0.96 → ccxt-3.0.98}/ccxt/async_support/huobi.py

@@ -2309,8 +2309,7 @@ class huobi(Exchange, ImplicitAPI):
                 # request['end-time'] = self.sum(since, 172800000)  # 48 hours window
             method = 'spotPrivateGetV1OrderMatchresults'
         else:
-            if symbol is None:
-                raise ArgumentsRequired(self.id + ' fetchMyTrades() requires a symbol for ' + marketType + ' orders')
+            self.check_required_symbol('fetchMyTrades', symbol)
             request['contract'] = market['id']
             request['trade_type'] = 0  # 0 all, 1 open long, 2 open short, 3 close short, 4 close long, 5 liquidate long positions, 6 liquidate short positions
             if since is not None:
@@ -3095,8 +3094,7 @@ class huobi(Exchange, ImplicitAPI):
             else:
                 request['order-id'] = id
         else:
-            if symbol is None:
-                raise ArgumentsRequired(self.id + ' fetchOrder() requires a symbol for ' + marketType + ' orders')
+            self.check_required_symbol('fetchOrder', symbol)
             request['contract_code'] = market['id']
             if market['linear']:
                 marginMode = None
@@ -3266,8 +3264,7 @@ class huobi(Exchange, ImplicitAPI):
     async def fetch_spot_orders_by_states(self, states, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         method = self.safe_string(self.options, 'fetchOrdersByStatesMethod', 'spot_private_get_v1_order_orders')  # spot_private_get_v1_order_history
         if method == 'spot_private_get_v1_order_orders':
-            if symbol is None:
-                raise ArgumentsRequired(self.id + ' fetchOrders() requires a symbol argument')
+            self.check_required_symbol('fetchOrders', symbol)
         await self.load_markets()
         market = None
         request = {
@@ -3332,8 +3329,7 @@ class huobi(Exchange, ImplicitAPI):
         return await self.fetch_spot_orders_by_states('filled,partial-canceled,canceled', symbol, since, limit, params)
 
     async def fetch_contract_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' fetchContractOrders() requires a symbol argument')
+        self.check_required_symbol('fetchContractOrders', symbol)
         await self.load_markets()
         market = self.market(symbol)
         request = {
@@ -3640,8 +3636,7 @@ class huobi(Exchange, ImplicitAPI):
             params = self.omit(params, 'account-id')
             response = await self.spotPrivateGetV1OrderOpenOrders(self.extend(request, params))
         else:
-            if symbol is None:
-                raise ArgumentsRequired(self.id + ' fetchOpenOrders() requires a symbol for ' + marketType + ' orders')
+            self.check_required_symbol('fetchOpenOrders', symbol)
             if limit is not None:
                 request['page_size'] = limit
             request['contract_code'] = market['id']
@@ -4485,6 +4480,8 @@ class huobi(Exchange, ImplicitAPI):
         :param str id: order id
         :param str|None symbol: unified symbol of the market the order was made in
         :param dict params: extra parameters specific to the huobi api endpoint
+        :param bool|None params['stop']: *contract only* if the order is a stop trigger order or not
+        :param bool|None params['stopLossTakeProfit']: *contract only* if the order is a stop-loss or take-profit order
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
@@ -4505,60 +4502,83 @@ class huobi(Exchange, ImplicitAPI):
             # 'pair': 'BTC-USDT',
             # 'contract_type': 'this_week',  # swap, self_week, next_week, quarter, next_ quarter
         }
-        method = None
+        response = None
         if marketType == 'spot':
             clientOrderId = self.safe_string_2(params, 'client-order-id', 'clientOrderId')
-            method = 'spotPrivatePostV1OrderOrdersOrderIdSubmitcancel'
             if clientOrderId is None:
                 request['order-id'] = id
+                response = await self.spotPrivatePostV1OrderOrdersOrderIdSubmitcancel(self.extend(request, params))
             else:
                 request['client-order-id'] = clientOrderId
-                method = 'spotPrivatePostV1OrderOrdersSubmitCancelClientOrder'
                 params = self.omit(params, ['client-order-id', 'clientOrderId'])
+                response = await self.spotPrivatePostV1OrderOrdersSubmitCancelClientOrder(self.extend(request, params))
         else:
-            if symbol is None:
-                raise ArgumentsRequired(self.id + ' cancelOrder() requires a symbol for ' + marketType + ' orders')
-            request['contract_code'] = market['id']
+            self.check_required_symbol('cancelOrder', symbol)
+            clientOrderId = self.safe_string_2(params, 'client_order_id', 'clientOrderId')
+            if clientOrderId is None:
+                request['order_id'] = id
+            else:
+                request['client_order_id'] = clientOrderId
+                params = self.omit(params, ['client_order_id', 'clientOrderId'])
+            if market['future']:
+                request['symbol'] = market['settleId']
+            else:
+                request['contract_code'] = market['id']
+            stop = self.safe_value(params, 'stop')
+            stopLossTakeProfit = self.safe_value(params, 'stopLossTakeProfit')
+            params = self.omit(params, ['stop', 'stopLossTakeProfit'])
             if market['linear']:
                 marginMode = None
                 marginMode, params = self.handle_margin_mode_and_params('cancelOrder', params)
                 marginMode = 'cross' if (marginMode is None) else marginMode
                 if marginMode == 'isolated':
-                    method = 'contractPrivatePostLinearSwapApiV1SwapCancel'
+                    if stop:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapTriggerCancel(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapTpslCancel(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCancel(self.extend(request, params))
                 elif marginMode == 'cross':
-                    method = 'contractPrivatePostLinearSwapApiV1SwapCrossCancel'
+                    if stop:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossTriggerCancel(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossTpslCancel(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossCancel(self.extend(request, params))
             elif market['inverse']:
-                if market['future']:
-                    method = 'contractPrivatePostApiV1ContractCancel'
-                    request['symbol'] = market['settleId']
-                elif market['swap']:
-                    method = 'contractPrivatePostSwapApiV1SwapCancel'
+                if market['swap']:
+                    if stop:
+                        response = await self.contractPrivatePostSwapApiV1SwapTriggerCancel(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostSwapApiV1SwapTpslCancel(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostSwapApiV1SwapCancel(self.extend(request, params))
+                elif market['future']:
+                    if stop:
+                        response = await self.contractPrivatePostApiV1ContractTriggerCancel(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostApiV1ContractTpslCancel(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostApiV1ContractCancel(self.extend(request, params))
             else:
                 raise NotSupported(self.id + ' cancelOrder() does not support ' + marketType + ' markets')
-            clientOrderId = self.safe_string_2(params, 'client_order_id', 'clientOrderId')
-            if clientOrderId is None:
-                request['order_id'] = id
-            else:
-                request['client_order_id'] = clientOrderId
-                params = self.omit(params, ['client_order_id', 'clientOrderId'])
-        response = await getattr(self, method)(self.extend(request, params))
         #
         # spot
         #
         #     {
-        #         'status': 'ok',
-        #         'data': '10138899000',
+        #         "status": "ok",
+        #         "data": "10138899000",
         #     }
         #
-        # linear swap cross margin
+        # future and swap
         #
         #     {
-        #         "status":"ok",
-        #         "data":{
-        #             "errors":[],
-        #             "successes":"924660854912552960"
+        #         "status": "ok",
+        #         "data": {
+        #             "errors": [],
+        #             "successes": "924660854912552960"
         #         },
-        #         "ts":1640504486089
+        #         "ts": 1640504486089
         #     }
         #
         return self.extend(self.parse_order(response, market), {
@@ -4572,6 +4592,8 @@ class huobi(Exchange, ImplicitAPI):
         :param [str] ids: order ids
         :param str|None symbol: unified market symbol, default is None
         :param dict params: extra parameters specific to the huobi api endpoint
+        :param bool|None params['stop']: *contract only* if the orders are stop trigger orders or not
+        :param bool|None params['stopLossTakeProfit']: *contract only* if the orders are stop-loss or take-profit orders
         :returns dict: an list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
@@ -4582,7 +4604,7 @@ class huobi(Exchange, ImplicitAPI):
         marketType, params = self.handle_market_type_and_params('cancelOrders', market, params)
         request = {
             # spot -----------------------------------------------------------
-            # 'order-ids': ids.jsoin(','),  # max 50
+            # 'order-ids': ','.join(ids),  # max 50
             # 'client-order-ids': ','.join(ids),  # max 50
             # contracts ------------------------------------------------------
             # 'order_id': id,  # comma separated, max 10
@@ -4590,43 +4612,24 @@ class huobi(Exchange, ImplicitAPI):
             # 'contract_code': market['id'],
             # 'symbol': market['settleId'],
         }
-        method = None
+        response = None
         if marketType == 'spot':
             clientOrderIds = self.safe_value_2(params, 'client-order-id', 'clientOrderId')
             clientOrderIds = self.safe_value_2(params, 'client-order-ids', 'clientOrderIds', clientOrderIds)
             if clientOrderIds is None:
                 if isinstance(clientOrderIds, str):
-                    request['order-ids'] = ids
+                    request['order-ids'] = [ids]
                 else:
-                    request['order-ids'] = ','.join(ids)
+                    request['order-ids'] = ids
             else:
                 if isinstance(clientOrderIds, str):
-                    request['client-order-ids'] = clientOrderIds
+                    request['client-order-ids'] = [clientOrderIds]
                 else:
-                    request['client-order-ids'] = ','.join(clientOrderIds)
+                    request['client-order-ids'] = clientOrderIds
                 params = self.omit(params, ['client-order-id', 'client-order-ids', 'clientOrderId', 'clientOrderIds'])
-            method = 'spotPrivatePostV1OrderOrdersBatchcancel'
+            response = await self.spotPrivatePostV1OrderOrdersBatchcancel(self.extend(request, params))
         else:
-            if symbol is None:
-                raise ArgumentsRequired(self.id + ' cancelOrders() requires a symbol for ' + marketType + ' orders')
-            marketInner = self.market(symbol)
-            request['contract_code'] = marketInner['id']
-            if marketInner['linear']:
-                marginMode = None
-                marginMode, params = self.handle_margin_mode_and_params('cancelOrders', params)
-                marginMode = 'cross' if (marginMode is None) else marginMode
-                if marginMode == 'isolated':
-                    method = 'contractPrivatePostLinearSwapApiV1SwapCancel'
-                elif marginMode == 'cross':
-                    method = 'contractPrivatePostLinearSwapApiV1SwapCrossCancel'
-            elif marketInner['inverse']:
-                if marketInner['future']:
-                    method = 'contractPrivatePostApiV1ContractCancel'
-                    request['symbol'] = marketInner['settleId']
-                elif marketInner['swap']:
-                    method = 'contractPrivatePostSwapApiV1SwapCancel'
-                else:
-                    raise NotSupported(self.id + ' cancelOrders() does not support ' + marketType + ' markets')
+            self.check_required_symbol('cancelOrders', symbol)
             clientOrderIds = self.safe_string_2(params, 'client_order_id', 'clientOrderId')
             clientOrderIds = self.safe_string_2(params, 'client_order_ids', 'clientOrderIds', clientOrderIds)
             if clientOrderIds is None:
@@ -4634,7 +4637,48 @@ class huobi(Exchange, ImplicitAPI):
             else:
                 request['client_order_id'] = clientOrderIds
                 params = self.omit(params, ['client_order_id', 'client_order_ids', 'clientOrderId', 'clientOrderIds'])
-        response = await getattr(self, method)(self.extend(request, params))
+            if market['future']:
+                request['symbol'] = market['settleId']
+            else:
+                request['contract_code'] = market['id']
+            stop = self.safe_value(params, 'stop')
+            stopLossTakeProfit = self.safe_value(params, 'stopLossTakeProfit')
+            params = self.omit(params, ['stop', 'stopLossTakeProfit'])
+            if market['linear']:
+                marginMode = None
+                marginMode, params = self.handle_margin_mode_and_params('cancelOrders', params)
+                marginMode = 'cross' if (marginMode is None) else marginMode
+                if marginMode == 'isolated':
+                    if stop:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapTriggerCancel(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapTpslCancel(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCancel(self.extend(request, params))
+                elif marginMode == 'cross':
+                    if stop:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossTriggerCancel(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossTpslCancel(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossCancel(self.extend(request, params))
+            elif market['inverse']:
+                if market['swap']:
+                    if stop:
+                        response = await self.contractPrivatePostSwapApiV1SwapTriggerCancel(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostSwapApiV1SwapTpslCancel(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostSwapApiV1SwapCancel(self.extend(request, params))
+                elif market['future']:
+                    if stop:
+                        response = await self.contractPrivatePostApiV1ContractTriggerCancel(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostApiV1ContractTpslCancel(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostApiV1ContractCancel(self.extend(request, params))
+            else:
+                raise NotSupported(self.id + ' cancelOrders() does not support ' + marketType + ' markets')
         #
         # spot
         #
@@ -4669,7 +4713,7 @@ class huobi(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        # contracts
+        # future and swap
         #
         #     {
         #         "status": "ok",
@@ -4693,6 +4737,8 @@ class huobi(Exchange, ImplicitAPI):
         cancel all open orders
         :param str|None symbol: unified market symbol, only orders in the market of self symbol are cancelled when symbol is not None
         :param dict params: extra parameters specific to the huobi api endpoint
+        :param bool|None params['stop']: *contract only* if the orders are stop trigger orders or not
+        :param bool|None params['stopLossTakeProfit']: *contract only* if the orders are stop-loss or take-profit orders
         :returns [dict]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
@@ -4715,34 +4761,56 @@ class huobi(Exchange, ImplicitAPI):
             # 'direction': 'buy':  # buy, sell
             # 'offset': 'open',  # open, close
         }
-        method = None
+        response = None
         if marketType == 'spot':
             if symbol is not None:
-                market = self.market(symbol)
                 request['symbol'] = market['id']
-            method = 'spotPrivatePostV1OrderOrdersBatchCancelOpenOrders'
+            response = await self.spotPrivatePostV1OrderOrdersBatchCancelOpenOrders(self.extend(request, params))
         else:
-            if symbol is None:
-                raise ArgumentsRequired(self.id + ' cancelAllOrders() requires a symbol for ' + marketType + ' orders')
-            marketInner = self.market(symbol)
-            request['contract_code'] = marketInner['id']
-            if marketInner['linear']:
+            self.check_required_symbol('cancelAllOrders', symbol)
+            if market['future']:
+                request['symbol'] = market['settleId']
+            request['contract_code'] = market['id']
+            stop = self.safe_value(params, 'stop')
+            stopLossTakeProfit = self.safe_value(params, 'stopLossTakeProfit')
+            params = self.omit(params, ['stop', 'stopLossTakeProfit'])
+            if market['linear']:
                 marginMode = None
                 marginMode, params = self.handle_margin_mode_and_params('cancelAllOrders', params)
                 marginMode = 'cross' if (marginMode is None) else marginMode
                 if marginMode == 'isolated':
-                    method = 'contractPrivatePostLinearSwapApiV1SwapCancelallall'
+                    if stop:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapTriggerCancelall(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapTpslCancelall(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCancelall(self.extend(request, params))
                 elif marginMode == 'cross':
-                    method = 'contractPrivatePostLinearSwapApiV1SwapCrossCancelall'
-            elif marketInner['inverse']:
-                if marketType == 'future':
-                    method = 'contractPrivatePostApiV1ContractCancelall'
-                    request['symbol'] = marketInner['settleId']
-                elif marketType == 'swap':
-                    method = 'contractPrivatePostSwapApiV1SwapCancelall'
-                else:
-                    raise NotSupported(self.id + ' cancelAllOrders() does not support ' + marketType + ' markets')
-        response = await getattr(self, method)(self.extend(request, params))
+                    if stop:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossTriggerCancelall(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossTpslCancelall(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostLinearSwapApiV1SwapCrossCancelall(self.extend(request, params))
+            elif market['inverse']:
+                if market['swap']:
+                    if stop:
+                        response = await self.contractPrivatePostSwapApiV1SwapTriggerCancelall(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostSwapApiV1SwapTpslCancelall(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostSwapApiV1SwapCancelall(self.extend(request, params))
+                elif market['future']:
+                    if stop:
+                        response = await self.contractPrivatePostApiV1ContractTriggerCancelall(self.extend(request, params))
+                    elif stopLossTakeProfit:
+                        response = await self.contractPrivatePostApiV1ContractTpslCancelall(self.extend(request, params))
+                    else:
+                        response = await self.contractPrivatePostApiV1ContractCancelall(self.extend(request, params))
+            else:
+                raise NotSupported(self.id + ' cancelAllOrders() does not support ' + marketType + ' markets')
+        #
+        # spot
         #
         #     {
         #         code: 200,
@@ -4753,6 +4821,17 @@ class huobi(Exchange, ImplicitAPI):
         #         }
         #     }
         #
+        # future and swap
+        #
+        #     {
+        #         status: "ok",
+        #         data: {
+        #             errors: [],
+        #             successes: "1104754904426696704"
+        #         },
+        #         ts: "1683435723755"
+        #     }
+        #
         return response
 
     def parse_deposit_address(self, depositAddress, currency=None):
@@ -5354,8 +5433,7 @@ class huobi(Exchange, ImplicitAPI):
         :param dict params: extra parameters specific to the huobi api endpoint
         :returns [dict]: a list of `funding rate structures <https://docs.ccxt.com/en/latest/manual.html?#funding-rate-history-structure>`
         """
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' fetchFundingRateHistory() requires a symbol argument')
+        self.check_required_symbol('fetchFundingRateHistory', symbol)
         await self.load_markets()
         market = self.market(symbol)
         request = {
@@ -5859,8 +5937,7 @@ class huobi(Exchange, ImplicitAPI):
         :param dict params: extra parameters specific to the huobi api endpoint
         :returns dict: response from the exchange
         """
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' setLeverage() requires a symbol argument')
+        self.check_required_symbol('setLeverage', symbol)
         await self.load_markets()
         market = self.market(symbol)
         marketType, query = self.handle_market_type_and_params('setLeverage', market, params)
@@ -6939,8 +7016,7 @@ class huobi(Exchange, ImplicitAPI):
         marginMode = 'cross' if (marginMode is None) else marginMode
         method = None
         if marginMode == 'isolated':
-            if symbol is None:
-                raise ArgumentsRequired(self.id + ' borrowMargin() requires a symbol argument for isolated margin')
+            self.check_required_symbol('borrowMargin', symbol)
             market = self.market(symbol)
             request['symbol'] = market['id']
             method = 'privatePostMarginOrders'

{ccxt-3.0.96 → ccxt-3.0.98}/ccxt/async_support/phemex.py

@@ -2399,7 +2399,7 @@ class phemex(Exchange, ImplicitAPI):
         :param float amount: how much of currency you want to trade in units of base currency
         :param float|None 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 phemex api endpoint
-        :param str|None params['posSide']: either 'Hedged' or 'OneWay' or 'Merged'
+        :param str|None params['posSide']: either 'Merged' or 'Long' or 'Short'
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         if symbol is None:
@@ -2457,7 +2457,7 @@ class phemex(Exchange, ImplicitAPI):
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict params: extra parameters specific to the phemex api endpoint
-        :param str|None params['posSide']: either 'Hedged' or 'OneWay' or 'Merged'
+        :param str|None params['posSide']: either 'Merged' or 'Long' or 'Short'
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         if symbol is None:

{ccxt-3.0.96 → ccxt-3.0.98}/ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '3.0.96'
+__version__ = '3.0.98'
 
 # -----------------------------------------------------------------------------
 
@@ -1429,7 +1429,7 @@ class Exchange(object):
         ohlcvs = []
         (timestamp, open, high, low, close, volume, count) = (0, 1, 2, 3, 4, 5, 6)
         num_trades = len(trades)
-        oldest = (num_trades - 1) if limit is None else min(num_trades - 1, limit)
+        oldest = num_trades if limit is None else min(num_trades, limit)
         for i in range(0, oldest):
             trade = trades[i]
             if (since is not None) and (trade['timestamp'] < since):

{ccxt-3.0.96 → ccxt-3.0.98}/ccxt/coinex.py

@@ -1678,6 +1678,12 @@ class coinex(Exchange, ImplicitAPI):
     def create_order(self, symbol: str, type, side: OrderSide, amount, price=None, params={}):
         """
         create a trade order
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http017_put_limit
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http018_put_market
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http019_put_limit_stop
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http020_put_market_stop
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http031_market_close
+        see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http030_limit_close
         :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'
@@ -1691,6 +1697,7 @@ class coinex(Exchange, ImplicitAPI):
         :param str params['timeInForce']: "GTC", "IOC", "FOK", "PO"
         :param bool params.postOnly:
         :param bool params.reduceOnly:
+        :param bool|None params['position_id']: *required for reduce only orders* the position id to reduce
         :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
@@ -1705,9 +1712,11 @@ class coinex(Exchange, ImplicitAPI):
         positionId = self.safe_integer_2(params, 'position_id', 'positionId')  # Required for closing swap positions
         timeInForceRaw = self.safe_string(params, 'timeInForce')  # Spot: IOC, FOK, PO, GTC, ... NORMAL(default), MAKER_ONLY
         reduceOnly = self.safe_value(params, 'reduceOnly')
-        if reduceOnly is not None:
+        if reduceOnly:
             if market['type'] != 'swap':
                 raise InvalidOrder(self.id + ' createOrder() does not support reduceOnly for ' + market['type'] + ' orders, reduceOnly orders are supported for swap markets only')
+            if positionId is None:
+                raise ArgumentsRequired(self.id + ' createOrder() requires a position_id/positionId parameter for reduceOnly orders')
         method = None
         request = {
             'market': market['id'],