ccxt 4.3.20__py2.py3-none-any.whl → 4.3.22__py2.py3-none-any.whl

ccxt/coinex.py

@@ -307,7 +307,7 @@ class coinex(Exchange, ImplicitAPI):
                 'v2': {
                     'public': {
                         'get': {
-                            'maintain-info': 1,
+                            'maintain/info': 1,
                             'ping': 1,
                             'time': 1,
                             'spot/market': 1,
@@ -3987,160 +3987,127 @@ class coinex(Exchange, ImplicitAPI):
     def modify_margin_helper(self, symbol: str, amount, addOrReduce, params={}):
         self.load_markets()
         market = self.market(symbol)
+        rawAmount = self.amount_to_precision(symbol, amount)
+        requestAmount = rawAmount
+        if addOrReduce == 'reduce':
+            requestAmount = Precise.string_neg(rawAmount)
         request = {
             'market': market['id'],
-            'amount': self.amount_to_precision(symbol, amount),
-            'type': addOrReduce,
+            'market_type': 'FUTURES',
+            'amount': requestAmount,
         }
-        response = self.v1PerpetualPrivatePostPositionAdjustMargin(self.extend(request, params))
+        response = self.v2PrivatePostFuturesAdjustPositionMargin(self.extend(request, params))
         #
         #     {
         #         "code": 0,
         #         "data": {
-        #             "adl_sort": 1,
-        #             "adl_sort_val": "0.00004320",
-        #             "amount": "0.0005",
-        #             "amount_max": "0.0005",
-        #             "amount_max_margin": "6.57352000000000000000",
-        #             "bkr_price": "16294.08000000000000011090",
-        #             "bkr_price_imply": "0.00000000000000000000",
-        #             "close_left": "0.0005",
-        #             "create_time": 1651202571.320778,
-        #             "deal_all": "19.72000000000000000000",
-        #             "deal_asset_fee": "0.00000000000000000000",
-        #             "fee_asset": "",
-        #             "finish_type": 1,
-        #             "first_price": "39441.12",
-        #             "insurance": "0.00000000000000000000",
-        #             "latest_price": "39441.12",
+        #             "adl_level": 1,
+        #             "ath_margin_size": "2.034928",
+        #             "ath_position_amount": "0.0001",
+        #             "avg_entry_price": "61047.84",
+        #             "bkr_price": "30698.5600000000000004142",
+        #             "close_avbl": "0.0001",
+        #             "cml_position_value": "6.104784",
+        #             "created_at": 1715488472908,
         #             "leverage": "3",
-        #             "liq_amount": "0.00000000000000000000",
-        #             "liq_order_price": "0",
-        #             "liq_order_time": 0,
-        #             "liq_price": "16491.28560000000000011090",
-        #             "liq_price_imply": "0.00000000000000000000",
-        #             "liq_profit": "0.00000000000000000000",
-        #             "liq_time": 0,
-        #             "mainten_margin": "0.005",
-        #             "mainten_margin_amount": "0.09860280000000000000",
-        #             "maker_fee": "0.00000000000000000000",
-        #             "margin_amount": "11.57352000000000000000",
+        #             "liq_price": "30852.82412060301507579316",
+        #             "maintenance_margin_rate": "0.005",
+        #             "maintenance_margin_value": "0.03051465",
+        #             "margin_avbl": "3.034928",
+        #             "margin_mode": "isolated",
         #             "market": "BTCUSDT",
-        #             "open_margin": "0.58687582908396110455",
-        #             "open_margin_imply": "0.00000000000000000000",
-        #             "open_price": "39441.12000000000000000000",
-        #             "open_val": "19.72056000000000000000",
-        #             "open_val_max": "19.72056000000000000000",
-        #             "position_id": 65171206,
-        #             "profit_clearing": "-0.00986028000000000000",
-        #             "profit_real": "-0.00986028000000000000",
-        #             "profit_unreal": "0.00",
-        #             "side": 2,
-        #             "stop_loss_price": "0.00000000000000000000",
-        #             "stop_loss_type": 0,
-        #             "s ys": 0,
-        #             "take_profit_price": "0.00000000000000000000",
-        #             "take_profit_type": 0,
-        #             "taker_fee": "0.00000000000000000000",
-        #             "total": 3464,
-        #             "type": 1,
-        #             "update_time": 1651202638.911212,
-        #             "user_id": 3620173
+        #             "market_type": "FUTURES",
+        #             "max_position_value": "6.104784",
+        #             "open_interest": "0.0001",
+        #             "position_id": 306458800,
+        #             "position_margin_rate": "0.49713929272518077625",
+        #             "realized_pnl": "-0.003052392",
+        #             "settle_price": "61047.84",
+        #             "settle_value": "6.104784",
+        #             "side": "long",
+        #             "stop_loss_price": "0",
+        #             "stop_loss_type": "",
+        #             "take_profit_price": "0",
+        #             "take_profit_type": "",
+        #             "unrealized_pnl": "0",
+        #             "updated_at": 1715488805563
         #         },
-        #         "message":"OK"
+        #         "message": "OK"
         #     }
         #
         data = self.safe_dict(response, 'data')
-        status = self.safe_string(response, 'message')
+        status = self.safe_string_lower(response, 'message')
+        type = 'reduce' if (addOrReduce == 'reduce') else 'add'
         return self.extend(self.parse_margin_modification(data, market), {
+            'type': type,
             'amount': self.parse_number(amount),
             'status': status,
         })
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         # addMargin/reduceMargin
         #
-        #    {
-        #        "adl_sort": 1,
-        #        "adl_sort_val": "0.00004320",
-        #        "amount": "0.0005",
-        #        "amount_max": "0.0005",
-        #        "amount_max_margin": "6.57352000000000000000",
-        #        "bkr_price": "16294.08000000000000011090",
-        #        "bkr_price_imply": "0.00000000000000000000",
-        #        "close_left": "0.0005",
-        #        "create_time": 1651202571.320778,
-        #        "deal_all": "19.72000000000000000000",
-        #        "deal_asset_fee": "0.00000000000000000000",
-        #        "fee_asset": "",
-        #        "finish_type": 1,
-        #        "first_price": "39441.12",
-        #        "insurance": "0.00000000000000000000",
-        #        "latest_price": "39441.12",
-        #        "leverage": "3",
-        #        "liq_amount": "0.00000000000000000000",
-        #        "liq_order_price": "0",
-        #        "liq_order_time": 0,
-        #        "liq_price": "16491.28560000000000011090",
-        #        "liq_price_imply": "0.00000000000000000000",
-        #        "liq_profit": "0.00000000000000000000",
-        #        "liq_time": 0,
-        #        "mainten_margin": "0.005",
-        #        "mainten_margin_amount": "0.09860280000000000000",
-        #        "maker_fee": "0.00000000000000000000",
-        #        "margin_amount": "11.57352000000000000000",
-        #        "market": "BTCUSDT",
-        #        "open_margin": "0.58687582908396110455",
-        #        "open_margin_imply": "0.00000000000000000000",
-        #        "open_price": "39441.12000000000000000000",
-        #        "open_val": "19.72056000000000000000",
-        #        "open_val_max": "19.72056000000000000000",
-        #        "position_id": 65171206,
-        #        "profit_clearing": "-0.00986028000000000000",
-        #        "profit_real": "-0.00986028000000000000",
-        #        "profit_unreal": "0.00",
-        #        "side": 2,
-        #        "stop_loss_price": "0.00000000000000000000",
-        #        "stop_loss_type": 0,
-        #        "sy s": 0,
-        #        "take_profit_price": "0.00000000000000000000",
-        #        "take_profit_type": 0,
-        #        "taker_fee": "0.00000000000000000000",
-        #        "total": 3464,
-        #        "type": 1,
-        #        "update_time": 1651202638.911212,
-        #        "user_id": 3620173
-        #    }
+        #     {
+        #         "adl_level": 1,
+        #         "ath_margin_size": "2.034928",
+        #         "ath_position_amount": "0.0001",
+        #         "avg_entry_price": "61047.84",
+        #         "bkr_price": "30698.5600000000000004142",
+        #         "close_avbl": "0.0001",
+        #         "cml_position_value": "6.104784",
+        #         "created_at": 1715488472908,
+        #         "leverage": "3",
+        #         "liq_price": "30852.82412060301507579316",
+        #         "maintenance_margin_rate": "0.005",
+        #         "maintenance_margin_value": "0.03051465",
+        #         "margin_avbl": "3.034928",
+        #         "margin_mode": "isolated",
+        #         "market": "BTCUSDT",
+        #         "market_type": "FUTURES",
+        #         "max_position_value": "6.104784",
+        #         "open_interest": "0.0001",
+        #         "position_id": 306458800,
+        #         "position_margin_rate": "0.49713929272518077625",
+        #         "realized_pnl": "-0.003052392",
+        #         "settle_price": "61047.84",
+        #         "settle_value": "6.104784",
+        #         "side": "long",
+        #         "stop_loss_price": "0",
+        #         "stop_loss_type": "",
+        #         "take_profit_price": "0",
+        #         "take_profit_type": "",
+        #         "unrealized_pnl": "0",
+        #         "updated_at": 1715488805563
+        #     }
         #
         # fetchMarginAdjustmentHistory
         #
-        #    {
-        #        bkr_price: '0',
-        #        leverage: '3',
-        #        liq_price: '0',
-        #        margin_amount: '5.33236666666666666666',
-        #        margin_change: '3',
-        #        market: 'XRPUSDT',
-        #        position_amount: '11',
-        #        position_id: '297155652',
-        #        position_type: '2',
-        #        settle_price: '0.6361',
-        #        time: '1711050906.382891',
-        #        type: '1',
-        #        user_id: '3685860'
-        #    }
+        #     {
+        #         "bkr_pirce": "24698.56000000000000005224",
+        #         "created_at": 1715489978697,
+        #         "leverage": "3",
+        #         "liq_price": "24822.67336683417085432386",
+        #         "margin_avbl": "3.634928",
+        #         "margin_change": "-1.5",
+        #         "margin_mode": "isolated",
+        #         "market": "BTCUSDT",
+        #         "market_type": "FUTURES",
+        #         "open_interest": "0.0001",
+        #         "position_id": 306458800,
+        #         "settle_price": "61047.84"
+        #     }
         #
         marketId = self.safe_string(data, 'market')
-        type = self.safe_string(data, 'type')
-        timestamp = self.safe_integer_product_2(data, 'time', 'update_time', 1000)
+        timestamp = self.safe_integer_2(data, 'updated_at', 'created_at')
+        change = self.safe_string(data, 'margin_change')
         return {
             'info': data,
             'symbol': self.safe_symbol(marketId, market, None, 'swap'),
-            'type': 'add' if (type == '1') else 'reduce',
+            'type': None,
             'marginMode': 'isolated',
-            'amount': self.safe_number(data, 'margin_change'),
-            'total': self.safe_number(data, 'position_amount'),
+            'amount': self.parse_number(Precise.string_abs(change)),
+            'total': self.safe_number(data, 'margin_avbl'),
             'code': market['quote'],
             'status': None,
             'timestamp': timestamp,
@@ -4150,24 +4117,24 @@ class coinex(Exchange, ImplicitAPI):
     def add_margin(self, symbol: str, amount: float, params={}) -> MarginModification:
         """
         add margin
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http032_adjust_position_margin
+        :see: https://docs.coinex.com/api/v2/futures/position/http/adjust-position-margin
         :param str symbol: unified market symbol
         :param float amount: amount of margin to add
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `margin structure <https://docs.ccxt.com/#/?id=add-margin-structure>`
         """
-        return self.modify_margin_helper(symbol, amount, 1, params)
+        return self.modify_margin_helper(symbol, amount, 'add', params)
 
     def reduce_margin(self, symbol: str, amount: float, params={}) -> MarginModification:
         """
         remove margin from a position
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http032_adjust_position_margin
+        :see: https://docs.coinex.com/api/v2/futures/position/http/adjust-position-margin
         :param str symbol: unified market symbol
         :param float amount: the amount of margin to remove
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `margin structure <https://docs.ccxt.com/#/?id=reduce-margin-structure>`
         """
-        return self.modify_margin_helper(symbol, amount, 2, params)
+        return self.modify_margin_helper(symbol, amount, 'reduce', params)
 
     def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
@@ -5582,7 +5549,7 @@ class coinex(Exchange, ImplicitAPI):
         code = self.safe_string(response, 'code')
         data = self.safe_value(response, 'data')
         message = self.safe_string(response, 'message')
-        if (code != '0') or ((message != 'Success') and (message != 'Succeeded') and (message != 'Ok') and not data):
+        if (code != '0') or ((message != 'Success') and (message != 'Succeeded') and (message.lower() != 'ok') and not data):
             feedback = self.id + ' ' + message
             self.throw_broadly_matched_exception(self.exceptions['broad'], message, feedback)
             self.throw_exactly_matched_exception(self.exceptions['exact'], code, feedback)
@@ -5592,65 +5559,60 @@ class coinex(Exchange, ImplicitAPI):
     def fetch_margin_adjustment_history(self, symbol: Str = None, type: Str = None, since: Num = None, limit: Num = None, params={}) -> List[MarginModification]:
         """
         fetches the history of margin added or reduced from contract isolated positions
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http046_position_margin_history
-        :param str [symbol]: unified market symbol
+        :see: https://docs.coinex.com/api/v2/futures/position/http/list-position-margin-history
+        :param str symbol: unified market symbol
         :param str [type]: not used by coinex fetchMarginAdjustmentHistory
         :param int [since]: timestamp in ms of the earliest change to fetch
-        :param int [limit]: the maximum amount of changes to fetch, default=100, max=100
+        :param int [limit]: the maximum amount of changes to fetch, default is 10
         :param dict params: extra parameters specific to the exchange api endpoint
         :param int [params.until]: timestamp in ms of the latest change to fetch
-         *
-         * EXCHANGE SPECIFIC PARAMETERS
-        :param int [params.offset]: offset
+        :param int [params.positionId]: the id of the position that you want to retrieve margin adjustment history for
         :returns dict[]: a list of `margin structures <https://docs.ccxt.com/#/?id=margin-loan-structure>`
         """
         self.load_markets()
-        until = self.safe_integer(params, 'until')
-        params = self.omit(params, 'until')
-        if limit is None:
-            limit = 100
+        if symbol is None:
+            raise ArgumentsRequired(self.id + ' fetchMarginAdjustmentHistory() requires a symbol argument')
+        positionId = self.safe_integer_2(params, 'positionId', 'position_id')
+        params = self.omit(params, 'positionId')
+        if positionId is None:
+            raise ArgumentsRequired(self.id + ' fetchMarginAdjustmentHistory() requires a positionId parameter')
+        market = self.market(symbol)
         request = {
-            'market': '',
-            'position_id': 0,
-            'offset': 0,
-            'limit': limit,
+            'market': market['id'],
+            'market_type': 'FUTURES',
+            'position_id': positionId,
         }
-        if symbol is not None:
-            market = self.market(symbol)
-            request['market'] = market['id']
+        request, params = self.handle_until_option('end_time', request, params)
         if since is not None:
             request['start_time'] = since
-        if until is not None:
-            request['end_time'] = until
-        response = self.v1PerpetualPrivateGetPositionMarginHistory(self.extend(request, params))
+        if limit is not None:
+            request['limit'] = limit
+        response = self.v2PrivateGetFuturesPositionMarginHistory(self.extend(request, params))
         #
-        #    {
-        #        code: '0',
-        #        data: {
-        #            limit: '100',
-        #            offset: '0',
-        #            records: [
-        #                {
-        #                    bkr_price: '0',
-        #                    leverage: '3',
-        #                    liq_price: '0',
-        #                    margin_amount: '5.33236666666666666666',
-        #                    margin_change: '3',
-        #                    market: 'XRPUSDT',
-        #                    position_amount: '11',
-        #                    position_id: '297155652',
-        #                    position_type: '2',
-        #                    settle_price: '0.6361',
-        #                    time: '1711050906.382891',
-        #                    type: '1',
-        #                    user_id: '3685860'
-        #                }
-        #            ]
-        #        },
-        #        message: 'OK'
-        #    }
+        #     {
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "bkr_pirce": "24698.56000000000000005224",
+        #                 "created_at": 1715489978697,
+        #                 "leverage": "3",
+        #                 "liq_price": "24822.67336683417085432386",
+        #                 "margin_avbl": "3.634928",
+        #                 "margin_change": "-1.5",
+        #                 "margin_mode": "isolated",
+        #                 "market": "BTCUSDT",
+        #                 "market_type": "FUTURES",
+        #                 "open_interest": "0.0001",
+        #                 "position_id": 306458800,
+        #                 "settle_price": "61047.84"
+        #             },
+        #         ],
+        #         "message": "OK",
+        #         "pagination": {
+        #             "has_next": True
+        #         }
+        #     }
         #
-        data = self.safe_dict(response, 'data', {})
-        records = self.safe_list(data, 'records', [])
-        modifications = self.parse_margin_modifications(records, None, 'market', 'swap')
+        data = self.safe_list(response, 'data', [])
+        modifications = self.parse_margin_modifications(data, None, 'market', 'swap')
         return self.filter_by_symbol_since_limit(modifications, symbol, since, limit)

ccxt/delta.py

@@ -2539,7 +2539,7 @@ class delta(Exchange, ImplicitAPI):
         result = self.safe_dict(response, 'result', {})
         return self.parse_margin_modification(result, market)
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #     {
         #         "auto_topup": False,

ccxt/digifinex.py

@@ -3791,7 +3791,7 @@ class digifinex(Exchange, ImplicitAPI):
             'status': status,
         })
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #     {
         #         "instrument_id": "BTCUSDTPERP",

ccxt/exmo.py

@@ -270,7 +270,7 @@ class exmo(Exchange, ImplicitAPI):
             margin['amount'] = amount
         return margin
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #      {}
         #

ccxt/gate.py

@@ -5678,7 +5678,7 @@ class gate(Exchange, ImplicitAPI):
             raise NotSupported(self.id + ' modifyMarginHelper() not support self market type')
         return self.parse_margin_modification(response, market)
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #     {
         #         "value": "11.9257",

ccxt/hitbtc.py

@@ -3057,7 +3057,7 @@ class hitbtc(Exchange, ImplicitAPI):
             'type': type,
         })
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         # addMargin/reduceMargin
         #

ccxt/hyperliquid.py

@@ -1544,14 +1544,17 @@ class hyperliquid(Exchange, ImplicitAPI):
         :param int [limit]: the maximum number of open orders structures to retrieve
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.user]: user address, will default to self.walletAddress if not provided
+        :param str [params.method]: 'openOrders' or 'frontendOpenOrders' default is 'frontendOpenOrders'
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         userAddress = None
         userAddress, params = self.handle_public_address('fetchOpenOrders', params)
+        method = None
+        method, params = self.handle_option_and_params(params, 'fetchOpenOrders', 'method', 'frontendOpenOrders')
         self.load_markets()
         market = self.safe_market(symbol)
         request = {
-            'type': 'openOrders',
+            'type': method,
             'user': userAddress,
         }
         response = self.publicPostInfo(self.extend(request, params))
@@ -1725,6 +1728,25 @@ class hyperliquid(Exchange, ImplicitAPI):
         #           "oid":6195281425
         #        }
         #     }
+        # frontendOrder
+        # {
+        #     "children": [],
+        #     "cloid": null,
+        #     "coin": "BLUR",
+        #     "isPositionTpsl": False,
+        #     "isTrigger": True,
+        #     "limitPx": "0.5",
+        #     "oid": 8670487141,
+        #     "orderType": "Stop Limit",
+        #     "origSz": "20.0",
+        #     "reduceOnly": False,
+        #     "side": "B",
+        #     "sz": "20.0",
+        #     "tif": null,
+        #     "timestamp": 1715523663687,
+        #     "triggerCondition": "Price above 0.6",
+        #     "triggerPx": "0.6"
+        # }
         #
         entry = self.safe_dict_n(order, ['order', 'resting', 'filled'])
         if entry is None:
@@ -1755,7 +1777,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'lastTradeTimestamp': None,
             'lastUpdateTimestamp': None,
             'symbol': symbol,
-            'type': self.safe_string_lower(entry, 'orderType'),
+            'type': self.parse_order_type(self.safe_string_lower(entry, 'orderType')),
             'timeInForce': self.safe_string_upper(entry, 'tif'),
             'postOnly': None,
             'reduceOnly': self.safe_bool(entry, 'reduceOnly'),
@@ -2190,7 +2212,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'code': self.safe_string(response, 'status'),
         })
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #    {
         #        'type': 'default'

ccxt/okx.py

@@ -269,6 +269,9 @@ class okx(Exchange, ImplicitAPI):
                         'sprd/books': 1 / 2,
                         'sprd/ticker': 1,
                         'sprd/public-trades': 1 / 5,
+                        'market/sprd-ticker': 2,
+                        'market/sprd-candles': 2,
+                        'market/sprd-history-candles': 2,
                         'tradingBot/grid/ai-param': 1,
                         'tradingBot/grid/min-investment': 1,
                         'tradingBot/public/rsi-back-testing': 1,
@@ -6235,7 +6238,7 @@ class okx(Exchange, ImplicitAPI):
             'status': 'ok' if (errorCode == '0') else 'failed',
         })
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         # addMargin/reduceMargin
         #

ccxt/phemex.py

@@ -1658,6 +1658,26 @@ class phemex(Exchange, ImplicitAPI):
         #         "execId": "8718cae",
         #         "execStatus": 6
         #     }
+        # spot with fees paid using PT token
+        #     "createdAt": "1714990724076",
+        #     "symbol": "BTCUSDT",
+        #     "currency": "USDT",
+        #     "action": "1",
+        #     "tradeType": "1",
+        #     "execQtyRq": "0.003",
+        #     "execPriceRp": "64935",
+        #     "side": "2",
+        #     "orderQtyRq": "0.003",
+        #     "priceRp": "51600",
+        #     "execValueRv": "194.805",
+        #     "feeRateRr": "0.000495",
+        #     "execFeeRv": "0",
+        #     "ordType": "3",
+        #     "execId": "XXXXXX",
+        #     "execStatus": "7",
+        #     "posSide": "1",
+        #     "ptFeeRv": "0.110012249248",
+        #     "ptPriceRp": "0.876524893"
         #
         priceString: Str
         amountString: Str
@@ -1706,10 +1726,16 @@ class phemex(Exchange, ImplicitAPI):
                 priceString = self.safe_string(trade, 'execPriceRp')
                 amountString = self.safe_string(trade, 'execQtyRq')
                 costString = self.safe_string(trade, 'execValueRv')
-                feeCostString = self.safe_string(trade, 'execFeeRv')
+                feeCostString = self.omit_zero(self.safe_string(trade, 'execFeeRv'))
                 feeRateString = self.safe_string(trade, 'feeRateRr')
-                currencyId = self.safe_string(trade, 'currency')
-                feeCurrencyCode = self.safe_currency_code(currencyId)
+                if feeCostString is not None:
+                    currencyId = self.safe_string(trade, 'currency')
+                    feeCurrencyCode = self.safe_currency_code(currencyId)
+                else:
+                    ptFeeRv = self.omit_zero(self.safe_string(trade, 'ptFeeRv'))
+                    if ptFeeRv is not None:
+                        feeCostString = ptFeeRv
+                        feeCurrencyCode = 'PT'
             else:
                 side = self.safe_string_lower(trade, 'side')
                 type = self.parse_order_type(self.safe_string(trade, 'ordType'))
@@ -1720,7 +1746,7 @@ class phemex(Exchange, ImplicitAPI):
                 amountString = self.from_ev(self.safe_string(trade, 'execBaseQtyEv'), market)
                 amountString = self.safe_string(trade, 'execQty', amountString)
                 costString = self.from_er(self.safe_string_2(trade, 'execQuoteQtyEv', 'execValueEv'), market)
-                feeCostString = self.from_er(self.safe_string(trade, 'execFeeEv'), market)
+                feeCostString = self.from_er(self.omit_zero(self.safe_string(trade, 'execFeeEv')), market)
                 if feeCostString is not None:
                     feeRateString = self.from_er(self.safe_string(trade, 'feeRateEr'), market)
                     if market['spot']:
@@ -1730,6 +1756,10 @@ class phemex(Exchange, ImplicitAPI):
                         if info is not None:
                             settlementCurrencyId = self.safe_string(info, 'settlementCurrency')
                             feeCurrencyCode = self.safe_currency_code(settlementCurrencyId)
+                else:
+                    feeCostString = self.safe_string(trade, 'ptFeeRv')
+                    if feeCostString is not None:
+                        feeCurrencyCode = 'PT'
             fee = {
                 'cost': feeCostString,
                 'rate': feeRateString,
@@ -3790,7 +3820,7 @@ class phemex(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_margin_modification(self, data, market: Market = None) -> MarginModification:
+    def parse_margin_modification(self, data: dict, market: Market = None) -> MarginModification:
         #
         #     {
         #         "code": 0,

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.20'
+__version__ = '4.3.22'
 
 # ----------------------------------------------------------------------------