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

ccxt/async_support/bitget.py

@@ -58,7 +58,7 @@ class bitget(Exchange, ImplicitAPI):
                 'cancelOrder': True,
                 'cancelOrders': True,
                 'closeAllPositions': True,
-                'closePosition': False,
+                'closePosition': True,
                 'createMarketBuyOrderWithCost': True,
                 'createMarketOrderWithCost': False,
                 'createMarketSellOrderWithCost': False,
@@ -3432,7 +3432,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",
@@ -3709,8 +3709,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')
@@ -4691,31 +4695,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')
         await 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 await 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'])
@@ -4724,35 +4733,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 = await self.privateMarginGetV2MarginIsolatedOpenOrders(self.extend(request, params))
+                    response = await self.privateMarginGetV2MarginIsolatedOpenOrders(self.extend(request, query))
                 elif marginMode == 'cross':
-                    response = await self.privateMarginGetV2MarginCrossedOpenOrders(self.extend(request, params))
+                    response = await self.privateMarginGetV2MarginCrossedOpenOrders(self.extend(request, query))
             else:
                 if stop:
-                    response = await self.privateSpotGetV2SpotTradeCurrentPlanOrder(self.extend(request, params))
+                    response = await self.privateSpotGetV2SpotTradeCurrentPlanOrder(self.extend(request, query))
                 else:
-                    response = await self.privateSpotGetV2SpotTradeUnfilledOrders(self.extend(request, params))
+                    response = await 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 = await self.privateMixGetV2MixOrderOrdersPlanPending(self.extend(request, params))
+                response = await self.privateMixGetV2MixOrderOrdersPlanPending(self.extend(request, query))
             else:
-                response = await self.privateMixGetV2MixOrderOrdersPending(self.extend(request, params))
+                response = await self.privateMixGetV2MixOrderOrdersPending(self.extend(request, query))
         #
         # spot
         #
@@ -4929,7 +4940,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)
@@ -4954,12 +4965,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')
         await self.load_markets()
-        market = self.market(symbol)
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
         response = await self.fetch_canceled_and_closed_orders(symbol, since, limit, params)
         result = []
         for i in range(0, len(response)):
@@ -4985,12 +4997,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')
         await self.load_markets()
-        market = self.market(symbol)
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
         response = await self.fetch_canceled_and_closed_orders(symbol, since, limit, params)
         result = []
         for i in range(0, len(response)):
@@ -5005,25 +5018,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 await 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'])
@@ -5032,13 +5047,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
@@ -5049,6 +5064,8 @@ class bitget(Exchange, ImplicitAPI):
                     response = await 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:
@@ -5248,7 +5265,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:
@@ -5880,11 +5897,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')
@@ -5943,7 +5959,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,
@@ -7457,57 +7473,87 @@ class bitget(Exchange, ImplicitAPI):
             'info': info,
         }
 
+    async 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>`
+        """
+        await 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 = await 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)
+
     async 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>`
         """
         await 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 = await 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 = await 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/async_support/bitrue.py

@@ -1484,15 +1484,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 = await self.fapiV1PublicGetTicker(self.extend(request, params))
-                elif market['inverse']:
-                    response = await 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 = await self.spotV1PublicGetTicker24hr(self.extend(request, params))
                 data = response
             else:
@@ -1500,7 +1493,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 = await self.spotV1PublicGetTicker24hr(self.extend(request, params))
             data = response
         #

ccxt/async_support/bybit.py

@@ -312,6 +312,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

ccxt/async_support/coinbase.py

@@ -207,6 +207,8 @@ class coinbase(Exchange, ImplicitAPI):
                             'brokerage/products/{product_id}',
                             'brokerage/products/{product_id}/candles',
                             'brokerage/products/{product_id}/ticker',
+                            'brokerage/portfolios',
+                            'brokerage/portfolios/{portfolio_uuid}',
                             'brokerage/transaction_summary',
                             'brokerage/product_book',
                             'brokerage/best_bid_ask',
@@ -218,9 +220,17 @@ class coinbase(Exchange, ImplicitAPI):
                             'brokerage/orders/batch_cancel',
                             'brokerage/orders/edit',
                             'brokerage/orders/edit_preview',
+                            'brokerage/portfolios',
+                            'brokerage/portfolios/move_funds',
                             'brokerage/convert/quote',
                             'brokerage/convert/trade/{trade_id}',
                         ],
+                        'put': [
+                            'brokerage/portfolios/{portfolio_uuid}',
+                        ],
+                        'delete': [
+                            'brokerage/portfolios/{portfolio_uuid}',
+                        ],
                     },
                 },
             },
@@ -277,6 +287,8 @@ class coinbase(Exchange, ImplicitAPI):
                     'not_found': ExchangeError,  # 404 Resource not found
                     'rate_limit_exceeded': RateLimitExceeded,  # 429 Rate limit exceeded
                     'internal_server_error': ExchangeError,  # 500 Internal server error
+                    'UNSUPPORTED_ORDER_CONFIGURATION': BadRequest,
+                    'INSUFFICIENT_FUND': BadRequest,
                 },
                 'broad': {
                     'request timestamp expired': InvalidNonce,  # {"errors":[{"id":"authentication_error","message":"request timestamp expired"}]}
@@ -2171,6 +2183,8 @@ class coinbase(Exchange, ImplicitAPI):
         params = self.omit(params, ['timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'stopPrice', 'stop_price', 'stopDirection', 'stop_direction', 'clientOrderId', 'postOnly', 'post_only', 'end_time'])
         response = await self.v3PrivatePostBrokerageOrders(self.extend(request, params))
         #
+        # successful order
+        #
         #     {
         #         "success": True,
         #         "failure_reason": "UNKNOWN_FAILURE_REASON",
@@ -2184,9 +2198,36 @@ class coinbase(Exchange, ImplicitAPI):
         #         "order_configuration": null
         #     }
         #
+        # failed order
+        #
+        #     {
+        #         "success": False,
+        #         "failure_reason": "UNKNOWN_FAILURE_REASON",
+        #         "order_id": "",
+        #         "error_response": {
+        #             "error": "UNSUPPORTED_ORDER_CONFIGURATION",
+        #             "message": "source is not enabled for trading",
+        #             "error_details": "",
+        #             "new_order_failure_reason": "UNSUPPORTED_ORDER_CONFIGURATION"
+        #         },
+        #         "order_configuration": {
+        #             "limit_limit_gtc": {
+        #                 "base_size": "100",
+        #                 "limit_price": "40000",
+        #                 "post_only": False
+        #             }
+        #         }
+        #     }
+        #
         success = self.safe_value(response, 'success')
         if success is not True:
-            raise BadRequest(self.id + ' createOrder() has failed, check your arguments and parameters')
+            errorResponse = self.safe_value(response, 'error_response')
+            errorTitle = self.safe_string(errorResponse, 'error')
+            errorMessage = self.safe_string(errorResponse, 'message')
+            if errorResponse is not None:
+                self.throw_exactly_matched_exception(self.exceptions['exact'], errorTitle, errorMessage)
+                self.throw_broadly_matched_exception(self.exceptions['broad'], errorTitle, errorMessage)
+                raise ExchangeError(errorMessage)
         data = self.safe_value(response, 'success_response', {})
         return self.parse_order(data, market)