ccxt 4.1.91__py2.py3-none-any.whl → 4.1.95__py2.py3-none-any.whl

ccxt/async_support/hitbtc.py

@@ -48,6 +48,7 @@ class hitbtc(Exchange, ImplicitAPI):
                 'addMargin': True,
                 'cancelAllOrders': True,
                 'cancelOrder': True,
+                'closePosition': False,
                 'createDepositAddress': True,
                 'createOrder': True,
                 'createPostOnlyOrder': True,
@@ -2660,6 +2661,8 @@ class hitbtc(Exchange, ImplicitAPI):
         marketType = None
         marginMode = None
         marketType, params = self.handle_market_type_and_params('fetchPositions', None, params)
+        if marketType == 'spot':
+            marketType = 'swap'
         marginMode, params = self.handle_margin_mode_and_params('fetchPositions', params)
         params = self.omit(params, ['marginMode', 'margin'])
         response = None
@@ -3264,6 +3267,41 @@ class hitbtc(Exchange, ImplicitAPI):
             }
         return result
 
+    async def close_position(self, symbol: str, side: OrderSide = None, params={}) -> Order:
+        """
+        closes open positions for a market
+        :see: https://api.hitbtc.com/#close-all-futures-margin-positions
+        :param dict [params]: extra parameters specific to the okx api endpoint
+        :param str [params.symbol]: *required* unified market symbol
+        :param str [params.marginMode]: 'cross' or 'isolated', default is 'cross'
+        :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        """
+        await self.load_markets()
+        marginMode = None
+        marginMode, params = self.handle_margin_mode_and_params('closePosition', params, 'cross')
+        market = self.market(symbol)
+        request = {
+            'symbol': market['id'],
+            'margin_mode': marginMode,
+        }
+        response = await self.privateDeleteFuturesPositionMarginModeSymbol(self.extend(request, params))
+        #
+        # {
+        #     "id":"202471640",
+        #     "symbol":"TRXUSDT_PERP",
+        #     "margin_mode":"Cross",
+        #     "leverage":"1.00",
+        #     "quantity":"0",
+        #     "price_entry":"0",
+        #     "price_margin_call":"0",
+        #     "price_liquidation":"0",
+        #     "pnl":"0.001234100000",
+        #     "created_at":"2023-10-29T14:46:13.235Z",
+        #     "updated_at":"2023-12-19T09:34:40.014Z"
+        # }
+        #
+        return self.parse_order(response, market)
+
     def handle_margin_mode_and_params(self, methodName, params={}, defaultValue=None):
         """
          * @ignore

ccxt/async_support/kucoinfutures.py

@@ -168,6 +168,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
                         'positions': 4.44,
                         'funding-history': 4.44,
                         'sub/api-key': 1,
+                        'trade-statistics': 1,
                     },
                     'post': {
                         'withdrawals': 1,
@@ -189,6 +190,7 @@ class kucoinfutures(kucoin, ImplicitAPI):
                         'orders': 4.44,
                         'stopOrders': 1,
                         'sub/api-key': 1,
+                        'orders/client-order/{clientOid}': 1,
                     },
                 },
                 'webExchange': {
@@ -1189,13 +1191,24 @@ class kucoinfutures(kucoin, 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 exchange API endpoint
+        :param str [params.clientOrderId]: cancel order by client order id
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        request = {
-            'orderId': id,
-        }
-        response = await self.futuresPrivateDeleteOrdersOrderId(self.extend(request, params))
+        clientOrderId = self.safe_string_2(params, 'clientOid', 'clientOrderId')
+        params = self.omit(params, ['clientOrderId'])
+        request = {}
+        response = None
+        if clientOrderId is not None:
+            if symbol is None:
+                raise ArgumentsRequired(self.id + ' cancelOrder() requires a symbol argument when cancelling by clientOrderId')
+            market = self.market(symbol)
+            request['symbol'] = market['id']
+            request['clientOid'] = clientOrderId
+            response = await self.futuresPrivateDeleteOrdersClientOrderClientOid(self.extend(request, params))
+        else:
+            request['orderId'] = id
+            response = await self.futuresPrivateDeleteOrdersOrderId(self.extend(request, params))
         #
         #   {
         #       "code": "200000",

ccxt/async_support/okx.py

@@ -273,6 +273,7 @@ class okx(Exchange, ImplicitAPI):
                         # rfq
                         'rfq/counterparties': 4,
                         'rfq/maker-instrument-settings': 4,
+                        'rfq/mmp-config': 4,
                         'rfq/rfqs': 10,
                         'rfq/quotes': 10,
                         'rfq/trades': 4,
@@ -412,6 +413,7 @@ class okx(Exchange, ImplicitAPI):
                         'rfq/execute-quote': 15,
                         'rfq/maker-instrument-settings': 4,
                         'rfq/mmp-reset': 4,
+                        'rfq/mmp-config': 100,
                         'rfq/create-quote': 0.4,
                         'rfq/cancel-quote': 0.4,
                         'rfq/cancel-batch-quotes': 10,

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.1.91'
+__version__ = '4.1.95'
 
 # -----------------------------------------------------------------------------
 
@@ -115,6 +115,7 @@ class Exchange(object):
     aiohttp_trust_env = False
     requests_trust_env = False
     session = None  # Session () by default
+    socks_proxy_session = None
     verify = True  # SSL verification
     validateServerSsl = True
     validateClientSsl = False

ccxt/binance.py

@@ -3035,7 +3035,7 @@ class binance(Exchange, ImplicitAPI):
         :see: https://binance-docs.github.io/apidocs/futures/en/#24hr-ticker-price-change-statistics      # swap
         :see: https://binance-docs.github.io/apidocs/delivery/en/#24hr-ticker-price-change-statistics     # future
         :see: https://binance-docs.github.io/apidocs/voptions/en/#24hr-ticker-price-change-statistics     # option
-        :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+        :param str[] [symbols]: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
@@ -3049,18 +3049,19 @@ class binance(Exchange, ImplicitAPI):
         type, params = self.handle_market_type_and_params('fetchTickers', market, params)
         subType = None
         subType, params = self.handle_sub_type_and_params('fetchTickers', market, params)
-        query = self.omit(params, 'type')
-        defaultMethod = None
+        response = None
         if type == 'option':
-            defaultMethod = 'eapiPublicGetTicker'
+            response = self.eapiPublicGetTicker(params)
         elif self.is_linear(type, subType):
-            defaultMethod = 'fapiPublicGetTicker24hr'
+            response = self.fapiPublicGetTicker24hr(params)
         elif self.is_inverse(type, subType):
-            defaultMethod = 'dapiPublicGetTicker24hr'
+            response = self.dapiPublicGetTicker24hr(params)
         else:
-            defaultMethod = 'publicGetTicker24hr'
-        method = self.safe_string(self.options, 'fetchTickersMethod', defaultMethod)
-        response = getattr(self, method)(query)
+            request = {}
+            if symbols is not None:
+                marketIds = self.market_ids(symbols)
+                request['symbols'] = self.json(marketIds)
+            response = self.publicGetTicker24hr(self.extend(request, params))
         return self.parse_tickers(response, symbols)
 
     def parse_ohlcv(self, ohlcv, market: Market = None) -> list:

ccxt/bingx.py

@@ -876,14 +876,17 @@ class bingx(Exchange, ImplicitAPI):
         type = 'spot' if (cost is None) else 'swap'
         currencyId = self.safe_string_2(trade, 'currency', 'N')
         currencyCode = self.safe_currency_code(currencyId)
-        m = self.safe_value(trade, 'm', False)
+        m = self.safe_value(trade, 'm')
         marketId = self.safe_string(trade, 's')
         isBuyerMaker = self.safe_value_2(trade, 'buyerMaker', 'isBuyerMaker')
-        takeOrMaker = 'maker' if (isBuyerMaker or m) else 'taker'
+        takeOrMaker = None
+        if (isBuyerMaker is not None) or (m is not None):
+            takeOrMaker = 'maker' if (isBuyerMaker or m) else 'taker'
         side = self.safe_string_lower_2(trade, 'side', 'S')
         if side is None:
-            side = 'sell' if (isBuyerMaker or m) else 'buy'
-            takeOrMaker = 'taker'
+            if (isBuyerMaker is not None) or (m is not None):
+                side = 'sell' if (isBuyerMaker or m) else 'buy'
+                takeOrMaker = 'taker'
         return self.safe_trade({
             'id': self.safe_string_n(trade, ['id', 't']),
             'info': trade,
@@ -895,7 +898,7 @@ class bingx(Exchange, ImplicitAPI):
             'side': self.parse_order_side(side),
             'takerOrMaker': takeOrMaker,
             'price': self.safe_string_2(trade, 'price', 'p'),
-            'amount': self.safe_string_n(trade, ['qty', 'amount', 'q']),
+            'amount': self.safe_string_n(trade, ['qty', 'volume', 'amount', 'q']),
             'cost': cost,
             'fee': {
                 'cost': self.parse_number(Precise.string_abs(self.safe_string_2(trade, 'commission', 'n'))),

ccxt/bitget.py

@@ -57,7 +57,7 @@ class bitget(Exchange, ImplicitAPI):
                 'cancelOrder': True,
                 'cancelOrders': True,
                 'closeAllPositions': True,
-                'closePosition': False,
+                'closePosition': True,
                 'createMarketBuyOrderWithCost': True,
                 'createMarketOrderWithCost': False,
                 'createMarketSellOrderWithCost': False,
@@ -3431,7 +3431,7 @@ class bitget(Exchange, ImplicitAPI):
 
     def parse_order(self, order, market: Market = None) -> Order:
         #
-        # createOrder, editOrder
+        # createOrder, editOrder, closePosition
         #
         #     {
         #         "clientOid": "abe95dbe-6081-4a6f-a2d3-ae49601cd479",
@@ -3708,8 +3708,12 @@ class bitget(Exchange, ImplicitAPI):
                 'clientOrderId': self.safe_string_2(order, 'clientOrderId', 'clientOid'),
                 'status': 'rejected',
             }, market)
+        isContractOrder = ('posSide' in order)
+        marketType = 'contract' if isContractOrder else 'spot'
+        if market is not None:
+            marketType = market['type']
         marketId = self.safe_string(order, 'symbol')
-        market = self.safe_market(marketId, market)
+        market = self.safe_market(marketId, market, None, marketType)
         timestamp = self.safe_integer_2(order, 'cTime', 'ctime')
         updateTimestamp = self.safe_integer(order, 'uTime')
         rawStatus = self.safe_string_2(order, 'status', 'state')
@@ -4690,31 +4694,36 @@ class bitget(Exchange, ImplicitAPI):
         :param str [params.isPlan]: *swap only* 'plan' for stop orders and 'profit_loss' for tp/sl orders, default is 'plan'
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' fetchOpenOrders() requires a symbol argument')
         self.load_markets()
         sandboxMode = self.safe_value(self.options, 'sandboxMode', False)
         market = None
-        if sandboxMode:
-            sandboxSymbol = self.convert_symbol_for_sandbox(symbol)
-            market = self.market(sandboxSymbol)
-        else:
-            market = self.market(symbol)
+        type = None
+        request = {}
         marginMode = None
         marginMode, params = self.handle_margin_mode_and_params('fetchOpenOrders', params)
+        if symbol is not None:
+            if sandboxMode:
+                sandboxSymbol = self.convert_symbol_for_sandbox(symbol)
+                market = self.market(sandboxSymbol)
+            else:
+                market = self.market(symbol)
+            request['symbol'] = market['id']
+            defaultType = self.safe_string_2(self.options, 'fetchOpenOrders', 'defaultType', 'spot')
+            marketType = market['type'] if ('type' in market) else defaultType
+            type = self.safe_string(params, 'type', marketType)
+        else:
+            defaultType = self.safe_string_2(self.options, 'fetchOpenOrders', 'defaultType', 'spot')
+            type = self.safe_string(params, 'type', defaultType)
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchOpenOrders', 'paginate')
         if paginate:
             cursorReceived = None
-            if market['spot']:
+            if type == 'spot':
                 if marginMode is not None:
                     cursorReceived = 'minId'
             else:
                 cursorReceived = 'endId'
             return self.fetch_paginated_call_cursor('fetchOpenOrders', symbol, since, limit, params, cursorReceived, 'idLessThan')
-        request = {
-            'symbol': market['id'],
-        }
         response = None
         stop = self.safe_value_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
@@ -4723,35 +4732,37 @@ class bitget(Exchange, ImplicitAPI):
             request['startTime'] = since
         if limit is not None:
             request['limit'] = limit
-        if (market['swap']) or (market['future']) or (marginMode is not None):
+        if (type == 'swap') or (type == 'future') or (marginMode is not None):
             clientOrderId = self.safe_string_2(params, 'clientOid', 'clientOrderId')
             params = self.omit(params, 'clientOrderId')
             if clientOrderId is not None:
                 request['clientOid'] = clientOrderId
-        if market['spot']:
+        query = None
+        query = self.omit(params, ['type'])
+        if type == 'spot':
             if marginMode is not None:
                 if since is None:
                     since = self.milliseconds() - 7776000000
                     request['startTime'] = since
                 if marginMode == 'isolated':
-                    response = self.privateMarginGetV2MarginIsolatedOpenOrders(self.extend(request, params))
+                    response = self.privateMarginGetV2MarginIsolatedOpenOrders(self.extend(request, query))
                 elif marginMode == 'cross':
-                    response = self.privateMarginGetV2MarginCrossedOpenOrders(self.extend(request, params))
+                    response = self.privateMarginGetV2MarginCrossedOpenOrders(self.extend(request, query))
             else:
                 if stop:
-                    response = self.privateSpotGetV2SpotTradeCurrentPlanOrder(self.extend(request, params))
+                    response = self.privateSpotGetV2SpotTradeCurrentPlanOrder(self.extend(request, query))
                 else:
-                    response = self.privateSpotGetV2SpotTradeUnfilledOrders(self.extend(request, params))
+                    response = self.privateSpotGetV2SpotTradeUnfilledOrders(self.extend(request, query))
         else:
             productType = None
-            productType, params = self.handle_product_type_and_params(market, params)
+            productType, query = self.handle_product_type_and_params(market, query)
             request['productType'] = productType
             if stop:
-                planType = self.safe_string(params, 'planType', 'normal_plan')
+                planType = self.safe_string(query, 'planType', 'normal_plan')
                 request['planType'] = planType
-                response = self.privateMixGetV2MixOrderOrdersPlanPending(self.extend(request, params))
+                response = self.privateMixGetV2MixOrderOrdersPlanPending(self.extend(request, query))
             else:
-                response = self.privateMixGetV2MixOrderOrdersPending(self.extend(request, params))
+                response = self.privateMixGetV2MixOrderOrdersPending(self.extend(request, query))
         #
         # spot
         #
@@ -4928,7 +4939,7 @@ class bitget(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data')
-        if market['spot']:
+        if type == 'spot':
             if (marginMode is not None) or stop:
                 resultList = self.safe_value(data, 'orderList', [])
                 return self.parse_orders(resultList, market, since, limit)
@@ -4953,12 +4964,13 @@ class bitget(Exchange, ImplicitAPI):
         :param int [params.until]: the latest time in ms to fetch entries for
         :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
         :param str [params.isPlan]: *swap only* 'plan' for stop orders and 'profit_loss' for tp/sl orders, default is 'plan'
+        :param str [params.productType]: *contract only* 'USDT-FUTURES', 'USDC-FUTURES', 'COIN-FUTURES', 'SUSDT-FUTURES', 'SUSDC-FUTURES' or 'SCOIN-FUTURES'
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' fetchClosedOrders() requires a symbol argument')
         self.load_markets()
-        market = self.market(symbol)
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
         response = self.fetch_canceled_and_closed_orders(symbol, since, limit, params)
         result = []
         for i in range(0, len(response)):
@@ -4984,12 +4996,13 @@ class bitget(Exchange, ImplicitAPI):
         :param int [params.until]: the latest time in ms to fetch entries for
         :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
         :param str [params.isPlan]: *swap only* 'plan' for stop orders and 'profit_loss' for tp/sl orders, default is 'plan'
+        :param str [params.productType]: *contract only* 'USDT-FUTURES', 'USDC-FUTURES', 'COIN-FUTURES', 'SUSDT-FUTURES', 'SUSDC-FUTURES' or 'SCOIN-FUTURES'
         :returns dict: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        if symbol is None:
-            raise ArgumentsRequired(self.id + ' fetchCanceledOrders() requires a symbol argument')
         self.load_markets()
-        market = self.market(symbol)
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
         response = self.fetch_canceled_and_closed_orders(symbol, since, limit, params)
         result = []
         for i in range(0, len(response)):
@@ -5004,25 +5017,27 @@ class bitget(Exchange, ImplicitAPI):
         sandboxMode = self.safe_value(self.options, 'sandboxMode', False)
         market = None
         if sandboxMode:
-            sandboxSymbol = self.convert_symbol_for_sandbox(symbol)
-            market = self.market(sandboxSymbol)
-        else:
+            if symbol is not None:
+                sandboxSymbol = self.convert_symbol_for_sandbox(symbol)
+                symbol = sandboxSymbol
+        request = {}
+        if symbol is not None:
             market = self.market(symbol)
+            request['symbol'] = market['id']
+        marketType = None
+        marketType, params = self.handle_market_type_and_params('fetchCanceledAndClosedOrders', market, params)
         marginMode = None
         marginMode, params = self.handle_margin_mode_and_params('fetchCanceledAndClosedOrders', params)
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchCanceledAndClosedOrders', 'paginate')
         if paginate:
             cursorReceived = None
-            if market['spot']:
+            if marketType == 'spot':
                 if marginMode is not None:
                     cursorReceived = 'minId'
             else:
                 cursorReceived = 'endId'
             return self.fetch_paginated_call_cursor('fetchCanceledAndClosedOrders', symbol, since, limit, params, cursorReceived, 'idLessThan')
-        request = {
-            'symbol': market['id'],
-        }
         response = None
         stop = self.safe_value_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
@@ -5031,13 +5046,13 @@ class bitget(Exchange, ImplicitAPI):
             request['startTime'] = since
         if limit is not None:
             request['limit'] = limit
-        if (market['swap']) or (market['future']) or (marginMode is not None):
+        if (marketType == 'swap') or (marketType == 'future') or (marginMode is not None):
             clientOrderId = self.safe_string_2(params, 'clientOid', 'clientOrderId')
             params = self.omit(params, 'clientOrderId')
             if clientOrderId is not None:
                 request['clientOid'] = clientOrderId
         now = self.milliseconds()
-        if market['spot']:
+        if marketType == 'spot':
             if marginMode is not None:
                 if since is None:
                     since = now - 7776000000
@@ -5048,6 +5063,8 @@ class bitget(Exchange, ImplicitAPI):
                     response = self.privateMarginGetV2MarginCrossedHistoryOrders(self.extend(request, params))
             else:
                 if stop:
+                    if symbol is None:
+                        raise ArgumentsRequired(self.id + ' fetchCanceledAndClosedOrders() requires a symbol argument')
                     endTime = self.safe_integer_n(params, ['endTime', 'until', 'till'])
                     params = self.omit(params, ['until', 'till'])
                     if since is None:
@@ -5247,7 +5264,7 @@ class bitget(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data', {})
-        if market['spot']:
+        if marketType == 'spot':
             if (marginMode is not None) or stop:
                 return self.safe_value(data, 'orderList', [])
         else:
@@ -5879,11 +5896,10 @@ class bitget(Exchange, ImplicitAPI):
         #
         # closeAllPositions
         #
-        #    {
-        #        "symbol": "XRPUSDT_UMCBL",
-        #        "orderId": "1111861847410757635",
-        #        "clientOid": "1111861847410757637"
-        #    }
+        #     {
+        #         "orderId": "1120923953904893955",
+        #         "clientOid": "1120923953904893956"
+        #     }
         #
         marketId = self.safe_string(position, 'symbol')
         market = self.safe_market(marketId, market, None, 'contract')
@@ -5942,7 +5958,7 @@ class bitget(Exchange, ImplicitAPI):
         percentage = Precise.string_mul(Precise.string_div(unrealizedPnl, initialMargin, 4), '100')
         return self.safe_position({
             'info': position,
-            'id': None,
+            'id': self.safe_string(position, 'orderId'),
             'symbol': symbol,
             'notional': self.parse_number(notional),
             'marginMode': marginMode,
@@ -7456,57 +7472,87 @@ class bitget(Exchange, ImplicitAPI):
             'info': info,
         }
 
+    def close_position(self, symbol: str, side: OrderSide = None, params={}) -> Order:
+        """
+        closes an open position for a market
+        :see: https://www.bitget.com/api-doc/contract/trade/Flash-Close-Position
+        :param str symbol: unified CCXT market symbol
+        :param str [side]: one-way mode: 'buy' or 'sell', hedge-mode: 'long' or 'short'
+        :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()
+        sandboxMode = self.safe_value(self.options, 'sandboxMode', False)
+        market = None
+        if sandboxMode:
+            sandboxSymbol = self.convert_symbol_for_sandbox(symbol)
+            market = self.market(sandboxSymbol)
+        else:
+            market = self.market(symbol)
+        productType = None
+        productType, params = self.handle_product_type_and_params(market, params)
+        request = {
+            'symbol': market['id'],
+            'productType': productType,
+        }
+        if side is not None:
+            request['holdSide'] = side
+        response = self.privateMixPostV2MixOrderClosePositions(self.extend(request, params))
+        #
+        #     {
+        #         "code": "00000",
+        #         "msg": "success",
+        #         "requestTime": 1702975017017,
+        #         "data": {
+        #             "successList": [
+        #                 {
+        #                     "orderId": "1120923953904893955",
+        #                     "clientOid": "1120923953904893956"
+        #                 }
+        #             ],
+        #             "failureList": [],
+        #             "result": False
+        #         }
+        #     }
+        #
+        data = self.safe_value(response, 'data', {})
+        order = self.safe_value(data, 'successList', [])
+        return self.parse_order(order[0], market)
+
     def close_all_positions(self, params={}) -> List[Position]:
         """
-        closes open positions for a market
-        :see: https://bitgetlimited.github.io/apidoc/en/mix/#close-all-position
-        :param dict [params]: extra parameters specific to the okx api endpoint
-        :param str [params.subType]: 'linear' or 'inverse'
-        :param str [params.settle]: *required and only valid when params.subType == "linear"* 'USDT' or 'USDC'
-        :returns dict[]: `A list of position structures <https://docs.ccxt.com/#/?id=position-structure>`
+        closes all open positions for a market type
+        :see: https://www.bitget.com/api-doc/contract/trade/Flash-Close-Position
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.productType]: 'USDT-FUTURES', 'USDC-FUTURES', 'COIN-FUTURES', 'SUSDT-FUTURES', 'SUSDC-FUTURES' or 'SCOIN-FUTURES'
+        :returns dict[]: A list of `position structures <https://docs.ccxt.com/#/?id=position-structure>`
         """
         self.load_markets()
-        subType = None
-        settle = None
-        subType, params = self.handle_sub_type_and_params('closeAllPositions', None, params)
-        settle = self.safe_string(params, 'settle', 'USDT')
-        params = self.omit(params, ['settle'])
-        productType = self.safe_string(params, 'productType')
-        request = {}
-        if productType is None:
-            sandboxMode = self.safe_value(self.options, 'sandboxMode', False)
-            localProductType = None
-            if subType == 'inverse':
-                localProductType = 'dmcbl'
-            else:
-                if settle == 'USDT':
-                    localProductType = 'umcbl'
-                elif settle == 'USDC':
-                    localProductType = 'cmcbl'
-            if sandboxMode:
-                localProductType = 's' + localProductType
-            request['productType'] = localProductType
-        response = self.privateMixPostMixV1OrderCloseAllPositions(self.extend(request, params))
-        #
-        #    {
-        #        "code": "00000",
-        #        "msg": "success",
-        #        "requestTime": 1700814442466,
-        #        "data": {
-        #            "orderInfo": [
-        #                {
-        #                    "symbol": "XRPUSDT_UMCBL",
-        #                    "orderId": "1111861847410757635",
-        #                    "clientOid": "1111861847410757637"
-        #                },
-        #            ],
-        #            "failure": [],
-        #            "result": True
-        #        }
-        #    }
+        productType = None
+        productType, params = self.handle_product_type_and_params(None, params)
+        request = {
+            'productType': productType,
+        }
+        response = self.privateMixPostV2MixOrderClosePositions(self.extend(request, params))
+        #
+        #     {
+        #         "code": "00000",
+        #         "msg": "success",
+        #         "requestTime": 1702975017017,
+        #         "data": {
+        #             "successList": [
+        #                 {
+        #                     "orderId": "1120923953904893955",
+        #                     "clientOid": "1120923953904893956"
+        #                 }
+        #             ],
+        #             "failureList": [],
+        #             "result": False
+        #         }
+        #     }
         #
         data = self.safe_value(response, 'data', {})
-        orderInfo = self.safe_value(data, 'orderInfo', [])
+        orderInfo = self.safe_value(data, 'successList', [])
         return self.parse_positions(orderInfo, None, params)
 
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):

ccxt/bitrue.py

@@ -1483,15 +1483,8 @@ class bitrue(Exchange, ImplicitAPI):
             first = self.safe_string(symbols, 0)
             market = self.market(first)
             if market['swap']:
-                request['contractName'] = market['id']
-                if market['linear']:
-                    response = self.fapiV1PublicGetTicker(self.extend(request, params))
-                elif market['inverse']:
-                    response = self.dapiV1PublicGetTicker(self.extend(request, params))
-                response['symbol'] = market['id']
-                data = [response]
+                raise NotSupported(self.id + ' fetchTickers does not support swap markets, please use fetchTicker instead')
             elif market['spot']:
-                request['symbol'] = market['id']
                 response = self.spotV1PublicGetTicker24hr(self.extend(request, params))
                 data = response
             else:
@@ -1499,7 +1492,7 @@ class bitrue(Exchange, ImplicitAPI):
         else:
             type, params = self.handle_market_type_and_params('fetchTickers', None, params)
             if type != 'spot':
-                raise NotSupported(self.id + ' fetchTickers only support spot when symbols is not set')
+                raise NotSupported(self.id + ' fetchTickers only support spot when symbols are not proved')
             response = self.spotV1PublicGetTicker24hr(self.extend(request, params))
             data = response
         #

ccxt/bybit.py

@@ -311,6 +311,7 @@ class bybit(Exchange, ImplicitAPI):
                         'v5/account/fee-rate': 10,  # 5/s = 1000 / (20 * 10)
                         'v5/account/info': 5,
                         'v5/account/transaction-log': 1,
+                        'v5/account/smp-group': 1,
                         'v5/account/mmp-state': 5,
                         # asset
                         'v5/asset/exchange/order-record': 5,  # 10/s => cost = 50 / 10 = 5