ccxt 4.3.62__py2.py3-none-any.whl → 4.3.63__py2.py3-none-any.whl

ccxt/async_support/bingx.py

@@ -86,6 +86,7 @@ class bingx(Exchange, ImplicitAPI):
                 'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchOrders': True,
+                'fetchPosition': True,
                 'fetchPositionHistory': False,
                 'fetchPositionMode': True,
                 'fetchPositions': True,
@@ -1699,6 +1700,7 @@ class bingx(Exchange, ImplicitAPI):
         :see: https://bingx-api.github.io/docs/#/spot/trade-api.html#Query%20Assets
         :see: https://bingx-api.github.io/docs/#/swapV2/account-api.html#Get%20Perpetual%20Swap%20Account%20Asset%20Information
         :see: https://bingx-api.github.io/docs/#/standard/contract-interface.html#Query%20standard%20contract%20balance
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20Account%20Assets
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param boolean [params.standard]: whether to fetch standard contract balances
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
@@ -1707,111 +1709,220 @@ class bingx(Exchange, ImplicitAPI):
         response = None
         standard = None
         standard, params = self.handle_option_and_params(params, 'fetchBalance', 'standard', False)
+        subType = None
+        subType, params = self.handle_sub_type_and_params('fetchBalance', None, params)
         marketType, marketTypeQuery = self.handle_market_type_and_params('fetchBalance', None, params)
         if standard:
             response = await self.contractV1PrivateGetBalance(marketTypeQuery)
+            #
+            #     {
+            #         "code": 0,
+            #         "timestamp": 1721192833454,
+            #         "data": [
+            #             {
+            #                 "asset": "USDT",
+            #                 "balance": "4.72644300000000000000",
+            #                 "crossWalletBalance": "4.72644300000000000000",
+            #                 "crossUnPnl": "0",
+            #                 "availableBalance": "4.72644300000000000000",
+            #                 "maxWithdrawAmount": "4.72644300000000000000",
+            #                 "marginAvailable": False,
+            #                 "updateTime": 1721192833443
+            #             },
+            #         ]
+            #     }
+            #
         elif marketType == 'spot':
             response = await self.spotV1PrivateGetAccountBalance(marketTypeQuery)
+            #
+            #     {
+            #         "code": 0,
+            #         "msg": "",
+            #         "debugMsg": "",
+            #         "data": {
+            #             "balances": [
+            #                 {
+            #                     "asset": "USDT",
+            #                     "free": "45.733046995800514",
+            #                     "locked": "0"
+            #                 },
+            #             ]
+            #         }
+            #     }
+            #
         else:
-            response = await self.swapV2PrivateGetUserBalance(marketTypeQuery)
+            if subType == 'inverse':
+                response = await self.cswapV1PrivateGetUserBalance(marketTypeQuery)
+                #
+                #     {
+                #         "code": 0,
+                #         "msg": "",
+                #         "timestamp": 1721191833813,
+                #         "data": [
+                #             {
+                #                 "asset": "SOL",
+                #                 "balance": "0.35707951",
+                #                 "equity": "0.35791051",
+                #                 "unrealizedProfit": "0.00083099",
+                #                 "availableMargin": "0.35160653",
+                #                 "usedMargin": "0.00630397",
+                #                 "freezedMargin": "0",
+                #                 "shortUid": "12851936"
+                #             }
+                #         ]
+                #     }
+                #
+            else:
+                response = await self.swapV2PrivateGetUserBalance(marketTypeQuery)
+                #
+                #     {
+                #         "code": 0,
+                #         "msg": "",
+                #         "data": {
+                #             "balance": {
+                #                 "userId": "1177064765068660742",
+                #                 "asset": "USDT",
+                #                 "balance": "51.5198",
+                #                 "equity": "50.5349",
+                #                 "unrealizedProfit": "-0.9849",
+                #                 "realisedProfit": "-0.2134",
+                #                 "availableMargin": "49.1428",
+                #                 "usedMargin": "1.3922",
+                #                 "freezedMargin": "0.0000",
+                #                 "shortUid": "12851936"
+                #             }
+                #         }
+                #     }
+                #
+        return self.parse_balance(response)
+
+    def parse_balance(self, response) -> Balances:
+        #
+        # standard
+        #
+        #     {
+        #         "code": 0,
+        #         "timestamp": 1721192833454,
+        #         "data": [
+        #             {
+        #                 "asset": "USDT",
+        #                 "balance": "4.72644300000000000000",
+        #                 "crossWalletBalance": "4.72644300000000000000",
+        #                 "crossUnPnl": "0",
+        #                 "availableBalance": "4.72644300000000000000",
+        #                 "maxWithdrawAmount": "4.72644300000000000000",
+        #                 "marginAvailable": False,
+        #                 "updateTime": 1721192833443
+        #             },
+        #         ]
+        #     }
         #
         # spot
         #
-        #    {
-        #        "code": 0,
-        #        "msg": "",
-        #        "ttl": 1,
-        #        "data": {
-        #            "balances": [
-        #                {
-        #                    "asset": "USDT",
-        #                    "free": "16.73971130673954",
-        #                    "locked": "0"
-        #                }
-        #            ]
-        #        }
-        #    }
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "debugMsg": "",
+        #         "data": {
+        #             "balances": [
+        #                 {
+        #                     "asset": "USDT",
+        #                     "free": "45.733046995800514",
+        #                     "locked": "0"
+        #                 },
+        #             ]
+        #         }
+        #     }
         #
-        # swap
+        # inverse swap
         #
-        #    {
-        #        "code": 0,
-        #        "msg": "",
-        #        "data": {
-        #          "balance": {
-        #            "asset": "USDT",
-        #            "balance": "15.6128",
-        #            "equity": "15.6128",
-        #            "unrealizedProfit": "0.0000",
-        #            "realisedProfit": "0.0000",
-        #            "availableMargin": "15.6128",
-        #            "usedMargin": "0.0000",
-        #            "freezedMargin": "0.0000"
-        #          }
-        #        }
-        #    }
-        # standard futures
-        #    {
-        #        "code":"0",
-        #        "timestamp":"1691148990942",
-        #        "data":[
-        #           {
-        #              "asset":"VST",
-        #              "balance":"100000.00000000000000000000",
-        #              "crossWalletBalance":"100000.00000000000000000000",
-        #              "crossUnPnl":"0",
-        #              "availableBalance":"100000.00000000000000000000",
-        #              "maxWithdrawAmount":"100000.00000000000000000000",
-        #              "marginAvailable":false,
-        #              "updateTime":"1691148990902"
-        #           },
-        #           {
-        #              "asset":"USDT",
-        #              "balance":"0",
-        #              "crossWalletBalance":"0",
-        #              "crossUnPnl":"0",
-        #              "availableBalance":"0",
-        #              "maxWithdrawAmount":"0",
-        #              "marginAvailable":false,
-        #              "updateTime":"1691148990902"
-        #           },
-        #        ]
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "timestamp": 1721191833813,
+        #         "data": [
+        #             {
+        #                 "asset": "SOL",
+        #                 "balance": "0.35707951",
+        #                 "equity": "0.35791051",
+        #                 "unrealizedProfit": "0.00083099",
+        #                 "availableMargin": "0.35160653",
+        #                 "usedMargin": "0.00630397",
+        #                 "freezedMargin": "0",
+        #                 "shortUid": "12851936"
+        #             }
+        #         ]
+        #     }
+        #
+        # linear swap
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "data": {
+        #             "balance": {
+        #                 "userId": "1177064765068660742",
+        #                 "asset": "USDT",
+        #                 "balance": "51.5198",
+        #                 "equity": "50.5349",
+        #                 "unrealizedProfit": "-0.9849",
+        #                 "realisedProfit": "-0.2134",
+        #                 "availableMargin": "49.1428",
+        #                 "usedMargin": "1.3922",
+        #                 "freezedMargin": "0.0000",
+        #                 "shortUid": "12851936"
+        #             }
+        #         }
         #     }
         #
-        return self.parse_balance(response)
-
-    def parse_balance(self, response) -> Balances:
-        data = self.safe_value(response, 'data')
-        balances = self.safe_value_2(data, 'balance', 'balances', data)
         result: dict = {'info': response}
-        if isinstance(balances, list):
-            for i in range(0, len(balances)):
-                balance = balances[i]
+        standardAndInverseBalances = self.safe_list(response, 'data')
+        firstStandardOrInverse = self.safe_dict(standardAndInverseBalances, 0)
+        isStandardOrInverse = firstStandardOrInverse is not None
+        spotData = self.safe_dict(response, 'data', {})
+        spotBalances = self.safe_list(spotData, 'balances')
+        firstSpot = self.safe_dict(spotBalances, 0)
+        isSpot = firstSpot is not None
+        if isStandardOrInverse:
+            for i in range(0, len(standardAndInverseBalances)):
+                balance = standardAndInverseBalances[i]
+                currencyId = self.safe_string(balance, 'asset')
+                code = self.safe_currency_code(currencyId)
+                account = self.account()
+                account['free'] = self.safe_string_2(balance, 'availableMargin', 'availableBalance')
+                account['used'] = self.safe_string(balance, 'usedMargin')
+                account['total'] = self.safe_string(balance, 'maxWithdrawAmount')
+                result[code] = account
+        elif isSpot:
+            for i in range(0, len(spotBalances)):
+                balance = spotBalances[i]
                 currencyId = self.safe_string(balance, 'asset')
                 code = self.safe_currency_code(currencyId)
                 account = self.account()
-                account['free'] = self.safe_string_2(balance, 'free', 'availableBalance')
+                account['free'] = self.safe_string(balance, 'free')
                 account['used'] = self.safe_string(balance, 'locked')
-                account['total'] = self.safe_string(balance, 'balance')
                 result[code] = account
         else:
-            currencyId = self.safe_string(balances, 'asset')
+            linearSwapData = self.safe_dict(response, 'data', {})
+            linearSwapBalance = self.safe_dict(linearSwapData, 'balance')
+            currencyId = self.safe_string(linearSwapBalance, 'asset')
             code = self.safe_currency_code(currencyId)
             account = self.account()
-            account['free'] = self.safe_string(balances, 'availableMargin')
-            account['used'] = self.safe_string(balances, 'usedMargin')
+            account['free'] = self.safe_string(linearSwapBalance, 'availableMargin')
+            account['used'] = self.safe_string(linearSwapBalance, 'usedMargin')
             result[code] = account
         return self.safe_balance(result)
 
     async def fetch_positions(self, symbols: Strings = None, params={}):
         """
         fetch all open positions
-        :see: https://bingx-api.github.io/docs/#/swapV2/account-api.html#Perpetual%20Swap%20Positions
-        :see: https://bingx-api.github.io/docs/#/standard/contract-interface.html#Query%20standard%20contract%20balance
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/account-api.html#Query%20position%20data
+        :see: https://bingx-api.github.io/docs/#/en-us/standard/contract-interface.html#position
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20warehouse
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param boolean [params.standard]: whether to fetch standard contract positions
-        :returns dict[]: a list of `position structure <https://docs.ccxt.com/#/?id=position-structure>`
+        :returns dict[]: a list of `position structures <https://docs.ccxt.com/#/?id=position-structure>`
         """
         await self.load_markets()
         symbols = self.market_symbols(symbols)
@@ -1821,54 +1932,207 @@ class bingx(Exchange, ImplicitAPI):
         if standard:
             response = await self.contractV1PrivateGetAllPosition(params)
         else:
-            response = await self.swapV2PrivateGetUserPositions(params)
-        #
-        #    {
-        #        "code": 0,
-        #            "msg": "",
-        #            "data": [
-        #            {
-        #                "symbol": "BTC-USDT",
-        #                "positionId": "12345678",
-        #                "positionSide": "LONG",
-        #                "isolated": True,
-        #                "positionAmt": "123.33",
-        #                "availableAmt": "128.99",
-        #                "unrealizedProfit": "1.22",
-        #                "realisedProfit": "8.1",
-        #                "initialMargin": "123.33",
-        #                "avgPrice": "2.2",
-        #                "leverage": 10,
-        #            }
-        #        ]
-        #    }
-        #
+            market = None
+            if symbols is not None:
+                symbols = self.market_symbols(symbols)
+                firstSymbol = self.safe_string(symbols, 0)
+                if firstSymbol is not None:
+                    market = self.market(firstSymbol)
+            subType = None
+            subType, params = self.handle_sub_type_and_params('fetchPositions', market, params)
+            if subType == 'inverse':
+                response = await self.cswapV1PrivateGetUserPositions(params)
+                #
+                #     {
+                #         "code": 0,
+                #         "msg": "",
+                #         "timestamp": 0,
+                #         "data": [
+                #             {
+                #                 "symbol": "SOL-USD",
+                #                 "positionId": "1813080351385337856",
+                #                 "positionSide": "LONG",
+                #                 "isolated": False,
+                #                 "positionAmt": "1",
+                #                 "availableAmt": "1",
+                #                 "unrealizedProfit": "-0.00009074",
+                #                 "initialMargin": "0.00630398",
+                #                 "liquidationPrice": 23.968303426677032,
+                #                 "avgPrice": "158.63",
+                #                 "leverage": 10,
+                #                 "markPrice": "158.402",
+                #                 "riskRate": "0.00123783",
+                #                 "maxMarginReduction": "0",
+                #                 "updateTime": 1721107015848
+                #             }
+                #         ]
+                #     }
+                #
+            else:
+                response = await self.swapV2PrivateGetUserPositions(params)
+                #
+                #     {
+                #         "code": 0,
+                #         "msg": "",
+                #         "data": [
+                #             {
+                #                 "positionId": "1792480725958881280",
+                #                 "symbol": "LTC-USDT",
+                #                 "currency": "USDT",
+                #                 "positionAmt": "0.1",
+                #                 "availableAmt": "0.1",
+                #                 "positionSide": "LONG",
+                #                 "isolated": False,
+                #                 "avgPrice": "83.53",
+                #                 "initialMargin": "1.3922",
+                #                 "margin": "0.3528",
+                #                 "leverage": 6,
+                #                 "unrealizedProfit": "-1.0393",
+                #                 "realisedProfit": "-0.2119",
+                #                 "liquidationPrice": 0,
+                #                 "pnlRatio": "-0.7465",
+                #                 "maxMarginReduction": "0.0000",
+                #                 "riskRate": "0.0008",
+                #                 "markPrice": "73.14",
+                #                 "positionValue": "7.3136",
+                #                 "onlyOnePosition": True,
+                #                 "updateTime": 1721088016688
+                #             }
+                #         ]
+                #     }
+                #
         positions = self.safe_list(response, 'data', [])
         return self.parse_positions(positions, symbols)
 
+    async def fetch_position(self, symbol: str, params={}):
+        """
+        fetch data on a single open contract trade position
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/account-api.html#Query%20position%20data
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20warehouse
+        :param str symbol: unified market symbol of the market the position is held in
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `position structure <https://docs.ccxt.com/#/?id=position-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        if not market['swap']:
+            raise BadRequest(self.id + ' fetchPosition() supports swap markets only')
+        request: dict = {
+            'symbol': market['id'],
+        }
+        response = None
+        if market['inverse']:
+            response = await self.cswapV1PrivateGetUserPositions(self.extend(request, params))
+            #
+            #     {
+            #         "code": 0,
+            #         "msg": "",
+            #         "timestamp": 0,
+            #         "data": [
+            #             {
+            #                 "symbol": "SOL-USD",
+            #                 "positionId": "1813080351385337856",
+            #                 "positionSide": "LONG",
+            #                 "isolated": False,
+            #                 "positionAmt": "1",
+            #                 "availableAmt": "1",
+            #                 "unrealizedProfit": "-0.00009074",
+            #                 "initialMargin": "0.00630398",
+            #                 "liquidationPrice": 23.968303426677032,
+            #                 "avgPrice": "158.63",
+            #                 "leverage": 10,
+            #                 "markPrice": "158.402",
+            #                 "riskRate": "0.00123783",
+            #                 "maxMarginReduction": "0",
+            #                 "updateTime": 1721107015848
+            #             }
+            #         ]
+            #     }
+            #
+        else:
+            response = await self.swapV2PrivateGetUserPositions(self.extend(request, params))
+            #
+            #     {
+            #         "code": 0,
+            #         "msg": "",
+            #         "data": [
+            #             {
+            #                 "positionId": "1792480725958881280",
+            #                 "symbol": "LTC-USDT",
+            #                 "currency": "USDT",
+            #                 "positionAmt": "0.1",
+            #                 "availableAmt": "0.1",
+            #                 "positionSide": "LONG",
+            #                 "isolated": False,
+            #                 "avgPrice": "83.53",
+            #                 "initialMargin": "1.3922",
+            #                 "margin": "0.3528",
+            #                 "leverage": 6,
+            #                 "unrealizedProfit": "-1.0393",
+            #                 "realisedProfit": "-0.2119",
+            #                 "liquidationPrice": 0,
+            #                 "pnlRatio": "-0.7465",
+            #                 "maxMarginReduction": "0.0000",
+            #                 "riskRate": "0.0008",
+            #                 "markPrice": "73.14",
+            #                 "positionValue": "7.3136",
+            #                 "onlyOnePosition": True,
+            #                 "updateTime": 1721088016688
+            #             }
+            #         ]
+            #     }
+            #
+        data = self.safe_list(response, 'data', [])
+        first = self.safe_dict(data, 0, {})
+        return self.parse_position(first, market)
+
     def parse_position(self, position: dict, market: Market = None):
         #
-        #    {
-        #        "positionId":"1773122376147623936",
-        #        "symbol":"XRP-USDT",
-        #        "currency":"USDT",
-        #        "positionAmt":"3",
-        #        "availableAmt":"3",
-        #        "positionSide":"LONG",
-        #        "isolated":false,
-        #        "avgPrice":"0.6139",
-        #        "initialMargin":"0.0897",
-        #        "leverage":20,
-        #        "unrealizedProfit":"-0.0023",
-        #        "realisedProfit":"-0.0009",
-        #        "liquidationPrice":0,
-        #        "pnlRatio":"-0.0260",
-        #        "maxMarginReduction":"",
-        #        "riskRate":"",
-        #        "markPrice":"",
-        #        "positionValue":"",
-        #        "onlyOnePosition":false
-        #    }
+        # inverse swap
+        #
+        #     {
+        #         "symbol": "SOL-USD",
+        #         "positionId": "1813080351385337856",
+        #         "positionSide": "LONG",
+        #         "isolated": False,
+        #         "positionAmt": "1",
+        #         "availableAmt": "1",
+        #         "unrealizedProfit": "-0.00009074",
+        #         "initialMargin": "0.00630398",
+        #         "liquidationPrice": 23.968303426677032,
+        #         "avgPrice": "158.63",
+        #         "leverage": 10,
+        #         "markPrice": "158.402",
+        #         "riskRate": "0.00123783",
+        #         "maxMarginReduction": "0",
+        #         "updateTime": 1721107015848
+        #     }
+        #
+        # linear swap
+        #
+        #     {
+        #         "positionId": "1792480725958881280",
+        #         "symbol": "LTC-USDT",
+        #         "currency": "USDT",
+        #         "positionAmt": "0.1",
+        #         "availableAmt": "0.1",
+        #         "positionSide": "LONG",
+        #         "isolated": False,
+        #         "avgPrice": "83.53",
+        #         "initialMargin": "1.3922",
+        #         "margin": "0.3528",
+        #         "leverage": 6,
+        #         "unrealizedProfit": "-1.0393",
+        #         "realisedProfit": "-0.2119",
+        #         "liquidationPrice": 0,
+        #         "pnlRatio": "-0.7465",
+        #         "maxMarginReduction": "0.0000",
+        #         "riskRate": "0.0008",
+        #         "markPrice": "73.14",
+        #         "positionValue": "7.3136",
+        #         "onlyOnePosition": True,
+        #         "updateTime": 1721088016688
+        #     }
         #
         # standard position
         #
@@ -1903,13 +2167,13 @@ class bingx(Exchange, ImplicitAPI):
             'percentage': None,
             'contracts': self.safe_number(position, 'positionAmt'),
             'contractSize': None,
-            'markPrice': None,
+            'markPrice': self.safe_number(position, 'markPrice'),
             'lastPrice': None,
             'side': self.safe_string_lower(position, 'positionSide'),
             'hedged': None,
             'timestamp': None,
             'datetime': None,
-            'lastUpdateTimestamp': None,
+            'lastUpdateTimestamp': self.safe_integer(position, 'updateTime'),
             'maintenanceMargin': None,
             'maintenanceMarginPercentage': None,
             'collateral': None,
@@ -4270,6 +4534,7 @@ class bingx(Exchange, ImplicitAPI):
         """
         retrieves the users liquidated positions
         :see: https://bingx-api.github.io/docs/#/swapV2/trade-api.html#User's%20Force%20Orders
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20force%20orders
         :param str [symbol]: unified CCXT market symbol
         :param int [since]: the earliest time in ms to fetch liquidations for
         :param int [limit]: the maximum number of liquidation structures to retrieve
@@ -4290,38 +4555,73 @@ class bingx(Exchange, ImplicitAPI):
             request['startTime'] = since
         if limit is not None:
             request['limit'] = limit
-        response = await self.swapV2PrivateGetTradeForceOrders(self.extend(request, params))
-        #
-        #     {
-        #         "code": 0,
-        #         "msg": "",
-        #         "data": {
-        #             "orders": [
-        #                 {
-        #                     "time": "int64",
-        #                     "symbol": "string",
-        #                     "side": "string",
-        #                      "type": "string",
-        #                     "positionSide": "string",
-        #                     "cumQuote": "string",
-        #                     "status": "string",
-        #                     "stopPrice": "string",
-        #                     "price": "string",
-        #                     "origQty": "string",
-        #                     "avgPrice": "string",
-        #                     "executedQty": "string",
-        #                     "orderId": "int64",
-        #                     "profit": "string",
-        #                     "commission": "string",
-        #                     "workingType": "string",
-        #                     "updateTime": "int64"
-        #                 },
-        #             ]
-        #         }
-        #     }
-        #
-        data = self.safe_dict(response, 'data', {})
-        liquidations = self.safe_list(data, 'orders', [])
+        subType = None
+        subType, params = self.handle_sub_type_and_params('fetchMyLiquidations', market, params)
+        response = None
+        liquidations = None
+        if subType == 'inverse':
+            response = await self.cswapV1PrivateGetTradeForceOrders(self.extend(request, params))
+            #
+            #     {
+            #         "code": 0,
+            #         "msg": "",
+            #         "timestamp": 1721280071678,
+            #         "data": [
+            #             {
+            #                 "orderId": "string",
+            #                 "symbol": "string",
+            #                 "type": "string",
+            #                 "side": "string",
+            #                 "positionSide": "string",
+            #                 "price": "string",
+            #                 "quantity": "float64",
+            #                 "stopPrice": "string",
+            #                 "workingType": "string",
+            #                 "status": "string",
+            #                 "time": "int64",
+            #                 "avgPrice": "string",
+            #                 "executedQty": "string",
+            #                 "profit": "string",
+            #                 "commission": "string",
+            #                 "updateTime": "string"
+            #             }
+            #         ]
+            #     }
+            #
+            liquidations = self.safe_list(response, 'data', [])
+        else:
+            response = await self.swapV2PrivateGetTradeForceOrders(self.extend(request, params))
+            #
+            #     {
+            #         "code": 0,
+            #         "msg": "",
+            #         "data": {
+            #             "orders": [
+            #                 {
+            #                     "time": "int64",
+            #                     "symbol": "string",
+            #                     "side": "string",
+            #                     "type": "string",
+            #                     "positionSide": "string",
+            #                     "cumQuote": "string",
+            #                     "status": "string",
+            #                     "stopPrice": "string",
+            #                     "price": "string",
+            #                     "origQty": "string",
+            #                     "avgPrice": "string",
+            #                     "executedQty": "string",
+            #                     "orderId": "int64",
+            #                     "profit": "string",
+            #                     "commission": "string",
+            #                     "workingType": "string",
+            #                     "updateTime": "int64"
+            #                 },
+            #             ]
+            #         }
+            #     }
+            #
+            data = self.safe_dict(response, 'data', {})
+            liquidations = self.safe_list(data, 'orders', [])
         return self.parse_liquidations(liquidations, market, since, limit)
 
     def parse_liquidation(self, liquidation, market: Market = None):